diff --git a/incoming/pattern-study/README.md b/incoming/pattern-study/README.md
index 2aadb9772..7a9918be3 100644
--- a/incoming/pattern-study/README.md
+++ b/incoming/pattern-study/README.md
@@ -1,6 +1,6 @@
 # 패턴 연구 2026-10
 
-새 패턴 598개를 쉰여섯 갈래로 나눠 만들었어요. 1판에서 열세 갈래로 23개를 만들고, 2판에서 1판에 없던 아홉 갈래로 16개를, 3판에서 하나를, 4판에서 새 갈래인 직물로 하나를 더했어요. 5판은 새 패턴 없이 1판의 Euclid Pulse 를 다시 짰고, 6판은 세운 패널의 128줄을 위아래로 다 쓰는 패턴 하나를 더했어요. 7판은 또렷한 모양이 멀리 흘러가는 지도 칸에 패턴 하나를 더했어요. 8판은 새 갈래인 기계로 하나를 더했어요. 9판은 새 패턴 없이 1판의 Sprout 을 다시 짰어요. 10판은 세운 패널을 떨어지는 블록의 우물로 쓰는 패턴 하나를 더했어요. 11판은 여러 색이 꽤 멀리 흘러가는 지도 칸에 패턴 하나를 더했어요. 12판은 새 갈래인 천체로 하나를 더했어요. 13판은 새 패턴 없이 1판의 Glyph Rain 을 다시 짰어요. 14판은 절차가 바뀌기 전에 띄운 바퀴라서, 세운 패널의 높이를 다 떨어지는 폭포 하나를 더했어요. 15판은 바뀐 절차의 첫 판이라 열 갈래에 새 패턴을 하나씩, 모두 열 개를 더했어요. 도시와 음악 갈래는 그때 새로 열었어요. 16판도 열 갈래에 하나씩 열 개를 더했고, 바다와 곤충 갈래를 새로 열었어요. 17판도 열 갈래에 하나씩 열 개를 더했고, 전자 회로와 장난감 갈래를 새로 열었어요. 18판도 열 갈래에 하나씩 열 개를 더했고, 유리와 광물·결정, 놀이공원 갈래를 새로 열었어요. 19판도 열 갈래에 하나씩 열 개를 더했고, 부엌과 버섯·균사 갈래를 새로 열었어요. 20판도 열 갈래에 하나씩 열 개를 더했고, 새와 화학·실험 갈래를 새로 열었어요. 21판도 열 갈래에 하나씩 열 개를 더했고, 종이와 운동·경기 갈래를 새로 열었어요. 22판도 열 갈래에 하나씩 열 개를 더했고, 몸과 비행 갈래를 새로 열었어요. 23판도 열 갈래에 하나씩 열 개를 더했고, 무대·공연과 짐승 갈래를 새로 열었어요. 24판도 열 갈래에 하나씩 열 개를 더했고, 공사·건설과 도자기 갈래를 새로 열었어요. 25판도 열 갈래에 하나씩 열 개를 더했고, 농사·밭과 화산 갈래를 새로 열었어요. 26판도 열 갈래에 하나씩 열 개를 더했고, 얼음·극지와 미생물 갈래를 새로 열었어요. 27판도 열 갈래에 하나씩 열 개를 더했고, 철도와 필름·영화 갈래를 새로 열었어요. 28판은 주제 표가 수학 쪽으로 바뀐 첫 판이라 이름 있는 수학 대상 열 개를 열 갈래에 하나씩 더했고, 수론 갈래를 새로 열었어요. 29판은 주제 표가 수학 여섯과 화장품 팝업 넷으로 나뉜 첫 판이라, 이름 있는 수학 대상 여섯과 화장품 매장 벽에 틀 질감 넷을 더했고, 위상·매듭과 화장품 팝업 갈래를 새로 열었어요. 30판도 같은 표로 돌아서 이름 있는 수학 대상 여섯을 여섯 갈래에 하나씩 더하고, 팝업 매장의 LED 벽에 틀 질감 넷을 화장품 팝업 갈래에 더했어요. 31판도 같은 표로 돌아서 이름 있는 수학 대상 여섯을 여섯 갈래에 하나씩, 매장 벽 질감 넷을 화장품 팝업 갈래에 더했고, 새 갈래는 열지 않았어요. 32판도 같은 표로 돌아서 수학 대상 여섯을 여섯 갈래에 하나씩, 매장 벽의 질감 넷을 화장품 팝업 갈래에 더했어요. 33판도 같은 표로 돌아서 수학 대상 여섯을 여섯 갈래에 하나씩, 매장 벽 질감 넷을 화장품 팝업 갈래에 더했어요. 34판도 수학 대상 여섯을 여섯 갈래에 하나씩, 매장 벽 질감 넷을 화장품 팝업 갈래에 더했어요. 35판도 수학 대상 여섯을 여섯 갈래에 하나씩, 매장 벽 질감 넷을 화장품 팝업 갈래에 더했어요. 36판도 수학 대상 여섯을 여섯 갈래에 하나씩, 매장 벽 질감 넷을 화장품 팝업 갈래에 더했어요. 37판도 수학 대상 여섯을 여섯 갈래에 하나씩, 매장 벽 질감 넷을 화장품 팝업 갈래에 더했어요. 38판도 수학 대상 여섯을 여섯 갈래에 하나씩, 매장 벽 질감 넷을 화장품 팝업 갈래에 더했어요. 39판도 수학 대상 여섯을 여섯 갈래에 하나씩, 매장 벽 질감 넷을 화장품 팝업 갈래에 더했어요. 40판도 수학 대상 여섯을 여섯 갈래에 하나씩, 매장 벽 질감 넷을 화장품 팝업 갈래에 더했어요. 41판은 주제 표가 수학·추상 다섯과 할로윈 다섯으로 바뀐 첫 판이라, 수학 대상 다섯을 다섯 갈래에 하나씩 더하고 할로윈 갈래를 새로 열어 10월 31일에 틀 패턴 다섯을 넣었어요. 42판도 같은 표로 돌아서 수학 대상 다섯을 다섯 갈래에 하나씩 더하고, 할로윈 밤에 틀 그림 다섯을 41판이 연 할로윈 갈래에 더했어요. 43판도 같은 표로 돌아서 수학 대상 다섯을 다섯 갈래에 하나씩, 할로윈 그림 다섯을 할로윈 갈래에 더했어요. 44판도 같은 표로 돌아서 수학 대상 다섯을 다섯 갈래에 하나씩 더하고, 할로윈 밤에 틀 그림 다섯을 할로윈 갈래에 더했어요. 45판도 같은 표로 돌아서 수학 대상 다섯을 패턴이 열 개 아래인 다섯 갈래에 하나씩, 할로윈 그림 다섯을 할로윈 갈래에 더했어요. 46판도 같은 표로 돌아서 수학 대상 다섯을 다섯 갈래에 하나씩, 할로윈 그림 다섯을 할로윈 갈래에 더했어요. 47판도 같은 표로 돌아서 수학 대상 다섯을 다섯 갈래에 하나씩, 할로윈 밤에 틀 그림 다섯을 할로윈 갈래에 더했어요. 48판도 같은 표로 돌아서 수학 대상 다섯을 다섯 갈래에 하나씩, 할로윈 그림 다섯을 할로윈 갈래에 더했어요. 49판도 같은 표로 돌아서 수학 대상 다섯을 다섯 갈래에 하나씩, 할로윈 그림 다섯을 할로윈 갈래에 더했어요. 50판도 같은 표로 돌아서 수학 대상 다섯을 패턴이 적은 다섯 갈래에 하나씩, 할로윈 밤에 틀 그림 다섯을 할로윈 갈래에 더했어요. 51판도 같은 표로 돌아서 수학 대상 다섯을 다섯 갈래에 하나씩, 할로윈 밤에 틀 그림 다섯을 할로윈 갈래에 더했어요. 52판도 같은 표로 돌아서 수학 대상 다섯을 패턴이 적은 다섯 갈래에 하나씩, 할로윈 그림 다섯을 할로윈 갈래에 더했어요. 53판은 할로윈 몫이 쉬게 된 첫 판이라, 수학 대상 열 개를 열 갈래에 하나씩 더했어요. 54판도 수학 대상 열 개를 패턴이 적은 열 갈래에 하나씩 더했어요. 55판도 수학 대상 열 개를 열 갈래에 하나씩 더했어요. 56판도 수학 대상 열 개를 열 갈래에 하나씩 더했어요. 57판도 수학 대상 열 개를 패턴이 적은 열 갈래에 하나씩 더했어요. 58판도 수학 대상 열 개를 패턴이 적은 열 갈래에 하나씩 더했어요. 59판도 수학 대상 열 개를 열 갈래에 하나씩 더했어요. 60판도 수학 대상 열 개를 열 갈래에 하나씩 더했어요. 61판도 수학 대상 열 개를 패턴이 적은 갈래부터 열 갈래에 하나씩 더했어요. 62판도 수학 대상 열 개를 열 갈래에 하나씩 더했어요. 63판은 64판과 같이 주제 표에 「타이포」가 들어온 첫 판이라, 글자가 들어간 패턴 다섯을 글자 갈래에, 수학 대상 다섯을 다섯 갈래에 하나씩 더했어요. 64판은 주제 표가 바뀌어 글자 패턴 다섯을 글자 갈래에, 수학 대상 다섯을 네 갈래에 더했어요. 65판도 같은 표로 돌아서 글자 패턴 다섯을 글자 갈래에, 수학 대상 다섯을 다섯 갈래에 하나씩 더했어요. 66판도 같은 표로 돌아서 글자 패턴 넷을 글자 갈래에, 하나를 데이터 그림 갈래에 더하고, 수학 대상 다섯을 다섯 갈래에 하나씩 더했어요. 67판도 같은 표로 돌아서 글자 패턴 다섯을 글자 갈래에, 수학 대상 다섯을 다섯 갈래에 하나씩 더했어요. 68판도 같은 표로 돌아서 글자 패턴 다섯을 글자 갈래에, 수학 대상 다섯을 다섯 갈래에 하나씩 더했어요. 69판도 같은 표로 돌아서 글자 패턴 다섯을 글자 갈래에, 수학 대상 다섯을 다섯 갈래에 하나씩 더했어요. [index.html](index.html) 을 브라우저로 열면 전부 한 장에서 돌아가요. 맨 위 지도에서 점을 누르면 그 패턴으로 가고, 카드의 슬라이더가 노브 넷이에요. 마음에 드는 것은 「코드 복사」로 가져가 Pattern Lab 의 CODE 칸에 붙여 넣으면 같은 그림이 나와요. 페이지는 파일 하나라서 바깥에서 받아 오는 것이 없어요.
+새 패턴 608개를 쉰여섯 갈래로 나눠 만들었어요. 1판에서 열세 갈래로 23개를 만들고, 2판에서 1판에 없던 아홉 갈래로 16개를, 3판에서 하나를, 4판에서 새 갈래인 직물로 하나를 더했어요. 5판은 새 패턴 없이 1판의 Euclid Pulse 를 다시 짰고, 6판은 세운 패널의 128줄을 위아래로 다 쓰는 패턴 하나를 더했어요. 7판은 또렷한 모양이 멀리 흘러가는 지도 칸에 패턴 하나를 더했어요. 8판은 새 갈래인 기계로 하나를 더했어요. 9판은 새 패턴 없이 1판의 Sprout 을 다시 짰어요. 10판은 세운 패널을 떨어지는 블록의 우물로 쓰는 패턴 하나를 더했어요. 11판은 여러 색이 꽤 멀리 흘러가는 지도 칸에 패턴 하나를 더했어요. 12판은 새 갈래인 천체로 하나를 더했어요. 13판은 새 패턴 없이 1판의 Glyph Rain 을 다시 짰어요. 14판은 절차가 바뀌기 전에 띄운 바퀴라서, 세운 패널의 높이를 다 떨어지는 폭포 하나를 더했어요. 15판은 바뀐 절차의 첫 판이라 열 갈래에 새 패턴을 하나씩, 모두 열 개를 더했어요. 도시와 음악 갈래는 그때 새로 열었어요. 16판도 열 갈래에 하나씩 열 개를 더했고, 바다와 곤충 갈래를 새로 열었어요. 17판도 열 갈래에 하나씩 열 개를 더했고, 전자 회로와 장난감 갈래를 새로 열었어요. 18판도 열 갈래에 하나씩 열 개를 더했고, 유리와 광물·결정, 놀이공원 갈래를 새로 열었어요. 19판도 열 갈래에 하나씩 열 개를 더했고, 부엌과 버섯·균사 갈래를 새로 열었어요. 20판도 열 갈래에 하나씩 열 개를 더했고, 새와 화학·실험 갈래를 새로 열었어요. 21판도 열 갈래에 하나씩 열 개를 더했고, 종이와 운동·경기 갈래를 새로 열었어요. 22판도 열 갈래에 하나씩 열 개를 더했고, 몸과 비행 갈래를 새로 열었어요. 23판도 열 갈래에 하나씩 열 개를 더했고, 무대·공연과 짐승 갈래를 새로 열었어요. 24판도 열 갈래에 하나씩 열 개를 더했고, 공사·건설과 도자기 갈래를 새로 열었어요. 25판도 열 갈래에 하나씩 열 개를 더했고, 농사·밭과 화산 갈래를 새로 열었어요. 26판도 열 갈래에 하나씩 열 개를 더했고, 얼음·극지와 미생물 갈래를 새로 열었어요. 27판도 열 갈래에 하나씩 열 개를 더했고, 철도와 필름·영화 갈래를 새로 열었어요. 28판은 주제 표가 수학 쪽으로 바뀐 첫 판이라 이름 있는 수학 대상 열 개를 열 갈래에 하나씩 더했고, 수론 갈래를 새로 열었어요. 29판은 주제 표가 수학 여섯과 화장품 팝업 넷으로 나뉜 첫 판이라, 이름 있는 수학 대상 여섯과 화장품 매장 벽에 틀 질감 넷을 더했고, 위상·매듭과 화장품 팝업 갈래를 새로 열었어요. 30판도 같은 표로 돌아서 이름 있는 수학 대상 여섯을 여섯 갈래에 하나씩 더하고, 팝업 매장의 LED 벽에 틀 질감 넷을 화장품 팝업 갈래에 더했어요. 31판도 같은 표로 돌아서 이름 있는 수학 대상 여섯을 여섯 갈래에 하나씩, 매장 벽 질감 넷을 화장품 팝업 갈래에 더했고, 새 갈래는 열지 않았어요. 32판도 같은 표로 돌아서 수학 대상 여섯을 여섯 갈래에 하나씩, 매장 벽의 질감 넷을 화장품 팝업 갈래에 더했어요. 33판도 같은 표로 돌아서 수학 대상 여섯을 여섯 갈래에 하나씩, 매장 벽 질감 넷을 화장품 팝업 갈래에 더했어요. 34판도 수학 대상 여섯을 여섯 갈래에 하나씩, 매장 벽 질감 넷을 화장품 팝업 갈래에 더했어요. 35판도 수학 대상 여섯을 여섯 갈래에 하나씩, 매장 벽 질감 넷을 화장품 팝업 갈래에 더했어요. 36판도 수학 대상 여섯을 여섯 갈래에 하나씩, 매장 벽 질감 넷을 화장품 팝업 갈래에 더했어요. 37판도 수학 대상 여섯을 여섯 갈래에 하나씩, 매장 벽 질감 넷을 화장품 팝업 갈래에 더했어요. 38판도 수학 대상 여섯을 여섯 갈래에 하나씩, 매장 벽 질감 넷을 화장품 팝업 갈래에 더했어요. 39판도 수학 대상 여섯을 여섯 갈래에 하나씩, 매장 벽 질감 넷을 화장품 팝업 갈래에 더했어요. 40판도 수학 대상 여섯을 여섯 갈래에 하나씩, 매장 벽 질감 넷을 화장품 팝업 갈래에 더했어요. 41판은 주제 표가 수학·추상 다섯과 할로윈 다섯으로 바뀐 첫 판이라, 수학 대상 다섯을 다섯 갈래에 하나씩 더하고 할로윈 갈래를 새로 열어 10월 31일에 틀 패턴 다섯을 넣었어요. 42판도 같은 표로 돌아서 수학 대상 다섯을 다섯 갈래에 하나씩 더하고, 할로윈 밤에 틀 그림 다섯을 41판이 연 할로윈 갈래에 더했어요. 43판도 같은 표로 돌아서 수학 대상 다섯을 다섯 갈래에 하나씩, 할로윈 그림 다섯을 할로윈 갈래에 더했어요. 44판도 같은 표로 돌아서 수학 대상 다섯을 다섯 갈래에 하나씩 더하고, 할로윈 밤에 틀 그림 다섯을 할로윈 갈래에 더했어요. 45판도 같은 표로 돌아서 수학 대상 다섯을 패턴이 열 개 아래인 다섯 갈래에 하나씩, 할로윈 그림 다섯을 할로윈 갈래에 더했어요. 46판도 같은 표로 돌아서 수학 대상 다섯을 다섯 갈래에 하나씩, 할로윈 그림 다섯을 할로윈 갈래에 더했어요. 47판도 같은 표로 돌아서 수학 대상 다섯을 다섯 갈래에 하나씩, 할로윈 밤에 틀 그림 다섯을 할로윈 갈래에 더했어요. 48판도 같은 표로 돌아서 수학 대상 다섯을 다섯 갈래에 하나씩, 할로윈 그림 다섯을 할로윈 갈래에 더했어요. 49판도 같은 표로 돌아서 수학 대상 다섯을 다섯 갈래에 하나씩, 할로윈 그림 다섯을 할로윈 갈래에 더했어요. 50판도 같은 표로 돌아서 수학 대상 다섯을 패턴이 적은 다섯 갈래에 하나씩, 할로윈 밤에 틀 그림 다섯을 할로윈 갈래에 더했어요. 51판도 같은 표로 돌아서 수학 대상 다섯을 다섯 갈래에 하나씩, 할로윈 밤에 틀 그림 다섯을 할로윈 갈래에 더했어요. 52판도 같은 표로 돌아서 수학 대상 다섯을 패턴이 적은 다섯 갈래에 하나씩, 할로윈 그림 다섯을 할로윈 갈래에 더했어요. 53판은 할로윈 몫이 쉬게 된 첫 판이라, 수학 대상 열 개를 열 갈래에 하나씩 더했어요. 54판도 수학 대상 열 개를 패턴이 적은 열 갈래에 하나씩 더했어요. 55판도 수학 대상 열 개를 열 갈래에 하나씩 더했어요. 56판도 수학 대상 열 개를 열 갈래에 하나씩 더했어요. 57판도 수학 대상 열 개를 패턴이 적은 열 갈래에 하나씩 더했어요. 58판도 수학 대상 열 개를 패턴이 적은 열 갈래에 하나씩 더했어요. 59판도 수학 대상 열 개를 열 갈래에 하나씩 더했어요. 60판도 수학 대상 열 개를 열 갈래에 하나씩 더했어요. 61판도 수학 대상 열 개를 패턴이 적은 갈래부터 열 갈래에 하나씩 더했어요. 62판도 수학 대상 열 개를 열 갈래에 하나씩 더했어요. 63판은 64판과 같이 주제 표에 「타이포」가 들어온 첫 판이라, 글자가 들어간 패턴 다섯을 글자 갈래에, 수학 대상 다섯을 다섯 갈래에 하나씩 더했어요. 64판은 주제 표가 바뀌어 글자 패턴 다섯을 글자 갈래에, 수학 대상 다섯을 네 갈래에 더했어요. 65판도 같은 표로 돌아서 글자 패턴 다섯을 글자 갈래에, 수학 대상 다섯을 다섯 갈래에 하나씩 더했어요. 66판도 같은 표로 돌아서 글자 패턴 넷을 글자 갈래에, 하나를 데이터 그림 갈래에 더하고, 수학 대상 다섯을 다섯 갈래에 하나씩 더했어요. 67판도 같은 표로 돌아서 글자 패턴 다섯을 글자 갈래에, 수학 대상 다섯을 다섯 갈래에 하나씩 더했어요. 68판도 같은 표로 돌아서 글자 패턴 다섯을 글자 갈래에, 수학 대상 다섯을 다섯 갈래에 하나씩 더했어요. 69판도 같은 표로 돌아서 글자 패턴 다섯을 글자 갈래에, 수학 대상 다섯을 다섯 갈래에 하나씩 더했어요. 70판도 같은 표로 돌아서 글자 패턴 다섯을 글자 갈래에, 수학 대상 다섯을 다섯 갈래에 하나씩 더했어요. [index.html](index.html) 을 브라우저로 열면 전부 한 장에서 돌아가요. 맨 위 지도에서 점을 누르면 그 패턴으로 가고, 카드의 슬라이더가 노브 넷이에요. 마음에 드는 것은 「코드 복사」로 가져가 Pattern Lab 의 CODE 칸에 붙여 넣으면 같은 그림이 나와요. 페이지는 파일 하나라서 바깥에서 받아 오는 것이 없어요.
 
 패널은 세로로 서요. 64 LED 너비에 128 LED 높이가 기본이라서 모든 패턴의 머리에 `@matrix 64x128` 이 있어요. 레포의 패널 설정은 그대로예요. `shared/constants.json` 의 `PANEL_GEOM_DEFAULT` 는 `128x64_SINGLE` 이고, 패턴이 가로세로를 바꾼 판을 적으면 펌웨어의 `firmware/patternflow/src/core_canvas.h` 가 90도 돌려 패널을 꽉 채워요. 1판 23개는 처음에 가로 128×64 로 만들었다가 2판에서 세로로 다시 짰어요.
 
@@ -945,6 +945,21 @@
 | [Whitney-Graustein](patterns/whitney-graustein.js) | 위상·매듭 | 접선 방향을 무지개빛으로 두른 닫힌 곡선이 멈추지 않고 모양을 바꾸며 감은 수대로 칸을 칠하고, Turns 를 돌리면 작은 고리가 뾰족점으로 조여 사라지거나 뾰족점에서 고리가 태어나며 위 다이얼의 회전수가 바뀌어요. |
 | [Steiner Symmetrization](patterns/steiner-symmetrization.js) | 선·궤적 | 초승달, 구멍 난 달걀, 일곱 뿔 별, 떨어진 두 덩이, 빗이 한 LED 현의 빗금으로 그려지고, 현마다 제 박자로 미끄러져 가운데가 흐린 축에 오고 틈으로 갈렸던 현은 한 줄로 붙은 뒤, 빗금이 새 축으로 돌아 다시 미끄러지는 동안 아래 막대가 같은 넓이 원의 눈금까지 줄어요. |
 
+### 70판
+
+| 패턴 | 갈래 | 한 줄 |
+| --- | --- | --- |
+| [Ink Traps](patterns/ink-traps.js) | 글자 | 신문 용지에 같은 글자를 위아래로 찍으면, 이음매에 잉크 트랩을 판 위 글자는 번진 잉크가 홈을 메워 그린 모양으로 남고 트랩 없는 아래 글자는 뾰족한 이음매부터 막혀요. |
+| [Eight Principles of Yong](patterns/eight-principles-of-yong.js) | 글자 | 붓이 패널 높이의 永 을 다섯 획 차례로 쓰는 동안 여덟 필법의 이름이 그 획 옆에 주홍으로 켜지고, 다 쓰면 여덟이 차례로 제 획과 함께 빛나요. |
+| [Photon Disk](patterns/photon-disk.js) | 글자 | 어두운 유리 원판이 돌다가 줄에 필요한 글자가 12시 창을 지나는 순간 섬광이 그 글자를 하얗게 멈춰 세우고, 렌즈를 지난 빛이 위 필름 띠에 한 자씩 글줄을 쌓아요. |
+| [Quousque Tandem](patterns/quousque-tandem.js) | 글자 | 캐즐런 견본처럼 키케로의 글줄 하나를 크기만 줄여 왼쪽 정렬로 쌓아, 위는 읽히는 큰 글자이고 아래는 1 LED 보다 작은 글자의 회색 결이 되며, 줄마다 윗줄 크기로 자라는 확대가 끝없이 돌아요. |
+| [Hellschreiber](patterns/hellschreiber.js) | 글자 | 무선으로 온 글자가 한 열씩 아래에서 위로 종이 테이프에 두 벌 찍히고, 낱말 사이에서 잘린 띠가 양식지에 한 줄씩 붙으며, 수신기 시계가 어긋나면 글줄이 띠를 타고 내려가요. |
+| [Laguerre Cells](patterns/laguerre-cells.js) | 보로노이·셀 | 점마다 무게를 단 파워 다이어그램을 뉴턴 걸음이 고쳐, 세 봉우리로 몰린 밀도를 칸마다 같은 질량으로 나눌 때까지 곧은 변이 미끄러지고, 넘친 칸은 보라로, 모자란 칸은 초록으로 기울어요. |
+| [Hexachordal Theorem](patterns/hexachordal-theorem.js) | 리듬·펄스 | 12박 고리의 여섯 온셋과 나머지 여섯이 위아래 고리에서 번갈아 울리고, 한 바퀴마다 온셋 하나가 옆으로 옮겨도 사이의 거리 막대는 늘 거울처럼 같아요. |
+| [Frenkel-Kontorova](patterns/frenkel-kontorova.js) | 시뮬레이션 | 우물 12개가 두른 바닥 위 용수철 사슬에 공이 남거나 모자라 생긴 꼬임이 미는 힘에 고리를 돌고, 위 113줄 기록에서 꼬임은 비스듬한 자홍 띠로, 크림색 공의 세계선은 띠마다 한 우물씩 비켜 가는 계단으로 남아요. |
+| [Granular Leidenfrost](patterns/granular-leidenfrost.js) | 입자 | 바닥이 쳐 올리는 상자에서 320알이 차가운 결정 덩어리로 뭉쳐 뜨거운 알갱이 기체 위에 뜨고, 흔들기를 줄이면 바닥에 내려앉고 키우면 뚜껑에 눌리며, 알을 덜 비탄성으로 하면 결정이 녹아요. |
+| [Multiplicative Chaos](patterns/multiplicative-chaos.js) | 노이즈·흐름 | 로그 상관 가우스장을 깊은 파랑 부조로 깔고 그 지수로 만든 카안의 측도를 금빛으로 띄우면, γ 가 오를수록 질량이 장의 가장 높은 몇 LED 로 모여 흰 점이 돼요. |
+
 ## 1판 갈래마다
 
 노브 넷의 자리는 갈래가 달라도 거의 같아요. K1 은 색이고 K2 는 빠르기예요. K3 은 모양을 바꾸고, K4 는 그 갈래만의 손잡이예요. 그래서 처음 보는 패턴도 K1 과 K2 는 손이 먼저 알아요.
@@ -3819,6 +3834,70 @@ Lab 에서 해 보기: Text 레이어를 mask 로 두고 maskInvert 를 켠 뒤
 
 주제 5 「수학 · 추상」으로, 모양을 원으로 다듬는 가장 오래된 손놀림을 빗금 한 장으로 보여 주려 했어요. 야코프 슈타이너(Jakob Steiner)는 1838년 Crelle 지에 낸 등주 문제 증명에서, 축을 하나 정하고 축에 수직인 현을 모두 제 길이 그대로 축 가운데로 옮기는 대칭화를 썼어요. 한 직선 위에 현이 여럿이면 길이를 더한 현 하나가 돼요. 넓이는 그대로이고 둘레는 늘지 않아요. 축을 바꿔 가며 되풀이하면 원으로 간다는 것은 빌헬름 그로스(Wilhelm Gross)가 1917년에 방향의 차례를 골라 보였고, 거기 쓰인 수렴 부분열은 빌헬름 블라슈케(Wilhelm Blaschke)가 1916년 『Kreis und Kugel』에서 낸 선택 정리에서 와요. 축 몇 개만 돌려 쓰면 그 축마다 거울 대칭인 모양에서 멈춘다는 것은 대니얼 클레인(Daniel Klain)이 2012년에 보였어요. 패널에는 1 LED 간격 현 144 개가 축을 따라 서고, 모양은 점의 고리로 들고 있다가 현마다 고리와 만나는 점을 정렬해 둘씩 묶어 조각을 얻어요. 조각들은 제 차례대로 쌓여 가운데 맞춘 현 하나가 되고, 현마다 축을 따라 0.45 초에 걸쳐 늦게 출발하며 0.56~0.84 초 동안 미끄러져서 빗금 더미에 층밀림 물결이 지나가요. 새 모양은 가운데 맞춘 현 끝을 잇는 고리이고, 1 LED 로 곡선을 샘플링하며 잃는 넓이는 길이를 그만큼 늘려 되돌려요. Axes 0 에서 축은 반 바퀴의 황금각 68.75 도씩 돌아요. 초승달의 둘레는 원의 1.520 배에서 1.371, 1.020, 1.013, 1.006, 1.004 배로 다섯 번에 들어오고, 구멍 난 달걀은 1.569 배에서 여덟 번 만에 1.005 배가 돼요. 잰 값은 움직임 0.361, 촘촘함 0.084, 가장자리 0.902, 복잡도 0.228, 채움 0.326, 색 0.289, 모양 바뀜 0.184 이고, thirds 는 11/71/14, ms 는 0.5~0.7, 노브는 0.14, 0.11, 0.14, 0.06 이에요. 첫 판은 새 고리의 꼭짓점이 현과 정확히 같은 높이에 놓여서 반올림으로 꼭짓점 하나가 두 번 세어졌고, 현 24 개가 홀수 개의 교점을 얻어 모양을 검은 줄무늬가 가로질렀어요. 현의 두 끝 검사를 같은 s 값으로 하자 사라졌어요. 떨어진 두 덩이는 고리 하나로 이어지며 가는 목이 생겨서 첫 대칭화에 둘레가 255.3 에서 262.5 로 늘었는데, 빈 현에서 고리를 끊자 255.6 이 됐어요. Axes 노브는 0.03 으로 약했는데, 처음 쉼을 0.6 초에서 0.15 초로 줄이고 가장 긴 미끄럼을 1.59 초에서 1.37 초로 당겨 둘째 미끄럼이 2~3 초 창에 들어오자 0.06 이 됐어요. 새로 본 것은 빗이에요. 세로 축의 첫 대칭화는 가로 현이 모두 한 조각이라 E 꼴 빗을 王 자 꼴로 가운데 맞출 뿐이고 둘레는 432.0 에서 424.2 로 2% 줄어요. 158.8 도의 둘째 축에서 이 셋을 가로지르는 현이 붙으면서 둘레가 243.5 로 한 번에 43% 줄어요.
 
+## 70판
+
+70판은 69판(#332)과 같이 돌았어요. 앞 바퀴와 같이 도는 바퀴의 PR 70개에는 댓글도 리뷰도 하나 없어서 따를 글이 없었어요. 69판이 PR 본문에 먼저 밝힌 열 개와 지도 칸 둘을 읽고 겹치지 않게 골랐어요. 69판의 Letter Melt 가 글자를 물처럼 녹이니 Ink Traps 는 글자 꼴을 그대로 두고 잉크만 종이로 번지게 했고, Caustic Letters 가 굴절한 빛을 모아 낱말을 지으니 Photon Disk 는 도는 유리 원판의 글자를 섬광으로 찍었어요. 타이포 다섯은 「타이포 실험」의 출발점 다섯을 하나씩 맡았어요. Ink Traps 는 글자의 몸, Eight Principles of Yong 은 세로 패널다운 글, Photon Disk 는 글자와 빛, Quousque Tandem 은 글자로 짠 무늬, Hellschreiber 는 글자가 만들어지는 과정이에요. 다섯 다 글자 꼴을 새로 그렸고 옮겨 쓴 글꼴은 없어요. Ink Traps 는 볼록 조각으로 적은 직선 대문자와 숫자 열둘을, Eight Principles of Yong 은 永 의 다섯 획 마디와 13×13 한자 여덟을, Photon Disk 는 5×7 글꼴 40자를, Quousque Tandem 은 30도로 쥔 넓적한 펜으로 긋는 19자를, Hellschreiber 는 세로획이 2 LED 인 굵은 5×7 대문자를 지었어요. 수학 다섯은 69판까지 든 598개에 없던 대상이고, 다섯 다 이 README 의 「다음 판 감」이 앞 판의 파일을 짚어 적어 둔 것이에요. 「낯선 수학 예」에서는 하나도 고르지 않았어요. 69판의 다섯을 넣어도 패턴이 스물하나로 가장 적은 일곱 갈래 가운데, 65판과 67판 뒤로 새 패턴이 없던 입자와 시뮬레이션, 그리고 보로노이·셀, 리듬·펄스, 노이즈·흐름에 하나씩 넣었어요. 주제 1 은 69판까지 든 598개에도 빈 칸과 둘뿐인 칸이 없어서, 셋뿐인 칸 셋 가운데 가장자리 × 촘촘함 1,3 에 Quousque Tandem 을, 촘촘함 × 복잡도 4,4 에 Multiplicative Chaos 를 세웠어요. 주제 4 는 Eight Principles of Yong 과 Granular Leidenfrost 가 맡았어요. 다섯 일꾼이 둘씩 짰고, 일곱 축의 양 끝 값과 칸 경계를 먼저 받아 그 안에 서게 했어요. 합친 뒤 다시 세어도 열 개 다 축 끝 안이었어요.
+
+### Ink Traps
+
+주제 7 「타이포」의 「글자의 몸」으로, 녹거나 흐르는 글자 대신 제자리에 선 글자 둘레로 잉크가 종이에 스며드는 그림을 세웠어요. 69판의 Letter Melt 는 글자를 물처럼 녹이고, 여기서는 글자 꼴은 그대로 둔 채 잉크만 종이 섬유로 번져요. 매튜 카터(Matthew Carter)가 AT&T 전화번호부를 위해 그리고 1978년에 머겐탈러 라이노타입(Mergenthaler Linotype)이 낸 벨 센테니얼(Bell Centennial)은 6포인트로 신문 용지에 빠르게 찍히는 글자였어요. 신문 용지는 잉크를 빨아들여서, 두 획이 좁은 각으로 만나는 이음매는 양쪽 획에서 잉크가 몰려 먼저 막혀요. 카터는 그 이음매에 홈을 팠어요. 잉크 트랩이에요. 번진 잉크가 홈을 메우면 이음매가 그린 대로 남아요. 패널은 확대경이에요. 한 장에 같은 글자를 위아래로 두 번, 50×58 LED 로 찍고 사이에 8줄을 비워요. 트랩은 위 글자에만 있어요. 글자는 이 패턴에 그린 직선 대문자와 숫자 열둘이고 벨 센테니얼의 윤곽은 아니에요. 종이 쪽 각이 84° 보다 좁은 이음매를 코드가 찾아서 열두 글자에서 스물다섯 개가 나왔어요. 잉크는 농도로 두고 LED 격자에서 확산시켜요. 섬유가 가로로 누워서 가로로 1.15배, 세로로 0.85배 빨리 퍼지고, 농도가 0.12 를 넘는 LED 가 검어져요. 퍼짐의 분산이 시간에 비례해서 획 가장자리는 시간의 제곱근으로 나가요. 에드워드 워시번(Edward W. Washburn)이 1921년에 적은 모세관 침투와 같은 꼴이에요. Speed 2 에서 한 장은 3 초 스미고 2.6 초 머문 뒤 0.8 초에 올라가서, 6.4 초마다 다음 글자가 찍혀요. 노란 전화번호부 종이 (182, 164, 69) 에 검은 잉크로 열어요. 첫 판은 잉크를 표준편차 2.7 LED 로 넓게 퍼뜨리고 농도 0.3 에서 검게 했고, 트랩은 이음매 꼭짓점에서 획 안으로 판 폭 2 LED 의 좁은 홈이었어요. 그랬더니 M 의 23° 이음매가 트랩이 있어도 없어도 꼭짓점에서 17 LED 바깥까지 찼어요. 모든 획을 같은 거리만큼 키우는 번짐이었다면 8.2 LED 였을 자리예요. 좁은 쐐기는 꼭짓점에서 먼 곳까지 양쪽 획의 잉크를 받아서, 꼭짓점의 작은 홈으로는 막을 수 없었어요. 그래서 표준편차를 1.28 LED 로 줄이고 문턱을 0.12 로 낮췄어요. 곧은 가장자리는 똑같이 1.5 LED 를 나가는데 먼 곳은 덜 차요. 트랩은 이음매의 쐐기를 그대로 획 안으로 D 만큼 밀어 넣은 꼴로 바꿨어요. D 는 k × 1.5 LED ÷ sin(각의 절반)이고, 쐐기의 옆선은 다시 D 만큼 가며 원래 획 가장자리로 돌아와요. 모든 획을 같은 거리만큼 키우는 번짐이면 k = 1 에서 이음매가 그린 자리에 찍히는데, 확산은 그보다 더 차서 k 를 재며 골랐어요. k 가 1 이면 홈이 다 메워져 트랩 없는 글자와 같았어요. 1.4 면 같은 글자 안에서도 어떤 이음매는 1.5 LED 안에, 어떤 이음매는 11 LED 바깥에 찍혔어요. 1.6 에서 스물다섯 이음매가 다 그린 꼭짓점의 1 LED 안에 찍히고, 트랩 없는 쪽은 3.1~13.3 LED 바깥까지 차요. M 의 23° 이음매에는 12.3 LED 깊이의 홈이 들어가요. 처음 잰 모양 바뀜은 0.403 으로 0.40 을 넘었어요. 종이가 올라가는 동안 패널 아래 절반이 빈 종이가 되는 프레임 때문이었어요. 종이 밝기를 205 에서 172 로 내리자 0.335 가 됐고, 노랑을 살리려고 182 에 채도 0.62 로 다시 올려 0.355 예요. 잰 값은 움직임 0.308, 촘촘함 0.035, 가장자리 0.494, 복잡도 0.724, 채움 0.500, 색 0.240, 모양 바뀜 0.355 이고, 노브는 0.16, 0.06, 0.20, 0.09 예요. 새로 본 것은 트랩이 맞는 번짐의 폭이 좁다는 거예요. 트랩은 메워지거나 열려 있거나 둘 중 하나예요. 가장자리가 1.5 LED 나갈 때 M 가운데의 45° 이음매는 그린 자리에 찍히는데, 1.7 LED 에서는 홈이 통째로 막혀 트랩 없는 쪽과 같이 6.5 LED 바깥까지 차요. 1.15 LED 에서는 23° 이음매의 홈이 3.8 LED 깊이로 열린 채 남아요. Spread 노브를 0.5 로만 돌려도 두 글자가 똑같이 막혀요.
+
+Lab 에서 해 보기: Text 레이어에 Silkscreen 으로 TRAP 을 size 8, 색 #1a1408 로 x 32, y 64 에 가운데 맞춤으로 두고 blend 를 multiply 로 하면, 두 견본 사이 8줄 틈에 이름표가 찍혀요. 이 글자는 번지지 않아서, Spread 를 1 로 돌리면 패턴의 두 글자만 부풀어 이름표 바로 위아래까지 다가와요.
+
+기능 감: 패턴 코드가 Text 레이어의 글자 비트맵을 읽을 수 있으면 좋겠어요. 이 패턴의 글자 열둘은 볼록 조각을 좌표로 적어 손수 그렸는데, Lab 에서 친 낱말을 고른 글꼴 그대로 잉크로 받아 번지게 할 수 있으면 Inter 와 Newsreader 의 이음매가 신문 용지에서 어떻게 막히는지 바로 견줄 수 있어요.
+
+### Eight Principles of Yong
+
+주제 7 「타이포」의 「세로 패널다운 글」과 「글자가 만들어지는 과정」을 겨누고, 주제 4 「세로 64×128 에서 잘 읽히는 것」도 같이 맡았어요. 영자팔법(永字八法)은 永 한 글자에 해서(楷書)의 기본 획 여덟이 다 들어 있다는 서예의 가르침이에요. 처음 가르친 사람을 4세기의 왕희지(王羲之)라고도 하고 수나라 승려 지영(智永)이라고도 하는데, 전해 오는 말이라 누구로도 정하지 않았어요. 여덟은 옛 이름으로 측(側)이 점, 늑(勒)이 가로획, 노(努)가 세로획, 적(趯)이 갈고리, 책(策)이 치킴, 략(掠)이 긴 삐침, 탁(啄)이 짧은 삐침, 책(磔)이 파임이에요. 永 은 다섯 획이에요. 둘째 획 하나가 늑에서 노를 지나 적으로 끝나고, 셋째 획이 책에서 꺾어 략이 되어서 다섯 획에 여덟이 다 들어가요. 획순은 점, 가로로 가다 꺾어 내리는 갈고리, 왼쪽에서 치켜 올렸다 꺾는 삐침, 오른쪽 위의 짧은 삐침, 파임이고 KanjiVG 의 永 획 자료와 맞춰 봤어요. 패널에서는 永 이 4째 줄에서 116째 줄까지 서고 1열에서 63열까지 차요. 세로획만 76줄이라 정사각 글자를 세로로 두 배 늘인 꼴이에요. 붓은 마디를 지나는 원으로 3분의 1 LED 마다 찍히고, 누르는 힘에 따라 반지름이 0.15 LED 에서 4.7 LED 까지 바뀌어요. 획 머리에서는 붓끝이 먼저 닿고 비스듬히 눌러 굵어지며, 꺾는 어깨나 파임의 발처럼 붓이 머무는 곳에서는 0.08~0.21초 멈춰 14% 퍼지고 먹이 고여요. 붓털은 아홉 가닥이고 가닥마다 먹이 떨어지는 문턱이 달라서, 획이 길어질수록 가닥이 하나씩 빠지며 마른 줄(비백, 飛白)이 생겨요. 갓 쓴 먹은 0.3초쯤 희게 번들거려요. 여덟 이름은 이 패턴이 13×13 으로 그린 한자이고, 그 법이 시작되는 순간 획 옆에 주홍으로 켜져요. 다 쓰면 2.3초 머무는 동안 여덟 법이 0.23초씩 차례로 제 획과 이름을 같이 밝히고, 0.9초에 사라진 뒤 손떨림이 조금 다른 새 永 을 써요. Speed 2 에서 한 바퀴는 10.2초이고, 새로 열면 점이 이미 찍혀 있고 붓은 가로획으로 가는 중이에요. 첫 판은 움직임 0.043, 촘촘함 0.069, 가장자리 0.470, 복잡도 1.067, 채움 1.000, 색 0.236, 모양 바뀜 0.114 였고 노브는 0.13, 0.05, 0.04, 0.04 였어요. 2~3초 창에는 아직 글자의 앞쪽 3분의 1 남짓만 쓰여 있어서 Brush 와 Ink 가 바꿀 먹이 적었어요. 붓 크기의 폭을 0.6~1.4배에서 0.55~1.45배로 넓히고 젖은 먹의 번짐을 2.6 LED 에서 3.2 LED 로 늘리자 둘 다 0.06 이 됐어요. 한 글자에 9.7박이 걸리던 것은 붓이 공중에서 옮겨 가는 시간을 줄이고 박을 1.2배로 당겨 Speed 2 에서 6.7초가 됐어요. 파임은 가는 줄 끝에 둥근 덩이가 붙은 꼴이어서, 아래 절반을 굵히고 발을 눌렀다가 오른쪽으로 눕혀 빼게 마디를 다시 놨어요. 잰 값은 움직임 0.042, 촘촘함 0.084, 가장자리 0.527, 복잡도 1.136, 채움 1.000, 색 0.263, 모양 바뀜 0.097, thirds 99/99/99 이고 노브는 0.14, 0.07, 0.06, 0.06 이에요. 쪽빛 종이가 밝기 41 이라 다 켜진 것으로 세어져서, 종이를 검게 두고 먹과 이름만 재면 thirds 가 20.8/28.6/22.7 이에요. 뜻밖이었던 것은 마른 줄이 생기는 자리예요. 가장 긴 획은 긴 삐침일 줄 알았는데 먹이 먼저 떨어지는 곳은 세로획 아래쪽이었어요. 둘째 획은 가로획 23 LED 를 쓰고 꺾어서 세로획을 내리니, 세로획은 이미 먹을 덜어 쓴 붓으로 시작해요. 둘째 획이 통틀어 123 LED 로 셋째 획 83 LED 보다 길어서, 획순이 먹이 마르는 자리를 정한 셈이에요. Ink 를 -1 로 둔 첫 판에서는 세로획이 통째로 사라지고 점, 꺾는 어깨, 갈고리 앞, 파임의 발처럼 붓이 머문 자리만 남았어요. 그래서 가장 마른 붓에도 가닥 넷에 하나꼴은 긁히게 바닥을 뒀어요.
+
+Lab 에서 해 보기: Text 레이어에 永 한 자를 쓰고 Serif(system:serif)로 size 20, sharp 를 끄고, align center 로 x 53, y 12 에 둬요. 색은 #d8442a 예요. 보는 기기에 한자가 든 명조 계열 글꼴이 있으면 오른쪽 위 빈자리(42~63열, 0~22줄)에 활자 永 이 서서, 붓이 2:1 로 길게 쓴 永 과 정사각 활자의 永 을 나란히 견줄 수 있어요.
+
+기능 감: Text 레이어에 12~16 LED 한자 픽셀 글꼴이 있으면 좋겠어요. 사이트 글꼴 넷(Silkscreen, Inter, JetBrains Mono, Newsreader)에는 한자가 없고 system 글꼴은 보는 기기마다 다르게 그려져요. 이 패턴의 측 늑 노 적 책 략 탁 책 여덟 자는 13×13 으로 손으로 그렸는데, 21획인 趯 과 15획인 磔 은 13칸에 다 들어가지 않아 부수 자리와 큰 가로획만 남겼어요.
+
+### Photon Disk
+
+주제 7 「타이포」의 「글자와 빛」을 사진 식자기로 겨눴어요. 69판의 Caustic Letters 는 굴절한 빛을 모아 낱말을 만들고, 같은 갈래의 Typewriter 와 Composing Stick 은 먹과 금속 활자로 찍어요. 이 패턴에서는 돌아가는 유리 원판이 스텐실이고, 섬광이 찍는 손이에요. 프랑스의 르네 이고네(René Higonnet)와 루이 무아루(Louis Moyroud)가 1944년에 만들기 시작해 1946년 9월 프랑스에서 처음 보인 루미타입(Lumitype)은 미국에서 포톤(Photon)이라는 이름으로 나왔어요. 어두운 유리 원판에 글자가 투명하게 나 있고 원판은 쉬지 않고 돌아요. 원하는 글자가 빛길을 지나는 순간 짧은 섬광이 터지고, 렌즈가 그 상의 크기를 정해 사진 필름에 떨어뜨리면 필름이 다음 글자 자리로 나아가요. 포톤의 원판에는 동심원 여덟 줄마다 90자 글꼴이 둘씩, 모두 1,440자가 있었고 5포인트에서 72포인트까지 12가지 크기로 찍었어요. 처음부터 끝까지 이 기계로 짠 첫 책은 앨브로 골(Albro Gaul)의 『The Wonderful World of Insects』(1953)예요. 원판이 1초에 몇 바퀴 돌았는지와 섬광 램프가 무엇이었는지는 확인하지 못해서 적지 않았어요. 패널 아래 64줄이 지름 64 LED 의 원판이에요. 바깥 고리에는 대문자 26자가 반지름 26 LED 에, 안 고리에는 숫자와 . , & - 14자가 반지름 15 LED 에 머리를 테두리 쪽으로 두고 서 있어요. 글자는 이 패턴을 위해 그린 5×7 글꼴 40자예요. 원판은 반시계로 돌고, 그 줄의 다음 글자가 12시 창을 지나는 순간 그 글리프만 하얗게 멈춰 서요. 빛은 렌즈를 지나 위 45줄의 갈색 필름 띠에 닿고, 갓 찍힌 글자는 하얗다가 0.35초 남짓에 빛의 색으로 식어요. 줄이 차면 필름이 한 줄 올라가요. 렌즈는 얇은 렌즈 식대로 원판에서 필름까지의 거리를 1 대 m 으로 나누는 자리에 서서, m 이 1 이면 창 위 15.5줄, 2.25 면 10.9줄에 있어요. Speed 2 에서 원판은 1초에 0.8바퀴 돌아요. 글자마다 제 글리프가 돌아오기를 기다려야 해서 제목을 찍을 때 섬광은 1초에 1.2번 터지고, 26자 넉 줄인 제목 한 벌이 줄 바꿈과 끝 쉼까지 21초예요. Text 는 넷이에요. 0 은 그 첫 책의 제목, 1 은 THE QUICK BROWN FOX JUMPS OVER THE LAZY DOG. 의 섬광 36번, 2 는 원판의 40자를 고리 차례대로, 3 은 R. HIGONNET & L. MOYROUD 1946 이에요. Lens 는 글자 키를 7 LED 에서 15.75 LED 까지 바꾸고, 한 줄에 9자에서 4자가 들어가요. 줄보다 긴 낱말은 안 고리의 하이픈으로 끊어요. 크기를 바꾸면 두 줄 아래에서 새로 시작하고, 이미 찍힌 글자는 찍힐 때의 크기로 남아요. 첫 판은 원판이 시계 방향으로 돌았어요. 고리 차례 글 2 가 48.7초 걸렸는데, A 를 찍고 나면 B 가 이미 창을 지나 있어서 글자마다 한 바퀴를 기다렸기 때문이에요. 반시계로 돌리자 같은 글이 10초가 됐어요. 한 프레임 동안 돈 각도만큼 다 번지게 했더니 바깥 고리 글자가 3.3 LED 씩 끌려 읽히지 않아서, 셔터를 반 프레임만 연 것처럼 번짐을 반으로 줄였어요. 지금 Speed 2 에서는 2.2 LED 예요. 멈춘 글리프를 창 둘레 20열에 그리다 보니 옆 글자까지 하얗게 섰는데, 섬광을 받은 글리프 하나만 남겼어요. 첫 잰 값은 움직임 0.890, 촘촘함 0.067, 가장자리 0.476, 복잡도 0.592, 채움 0.745, 색 0.128, 모양 바뀜 0.053 이었고 프레임마다 1.8 ms 가 걸렸어요. 고리마다 글리프 배열을 미리 만들고 글리프 중심선에서 0.23 라디안 안쪽의 sin 과 cos 를 두 항으로 줄이자 0.8 ms 가 됐어요. 원판 유리 색을 Hue 에서 떼어 냈더니 Hue 반응이 0.05 에서 0.03 으로 떨어져서, 유리에는 옅은 색만 남기고 원판 글자의 색을 진하게 했어요. 잰 값은 움직임 0.959, 촘촘함 0.069, 가장자리 0.478, 복잡도 0.594, 채움 0.745, 색 0.134, 모양 바뀜 0.058, thirds 96/45/81, 0.8 ms 이고, 노브는 0.05, 0.06, 0.07, 0.08 이에요. 새로 본 것은 패널의 30 fps 가 스트로보 노릇을 한다는 거예요. 고리 차례 글에서는 다음 글리프가 0.048초 뒤에 창에 와서 섬광이 한두 프레임마다 터져요. 그러면 프레임마다 다른 글자가 같은 자리에 하얗게 서서, 원판은 돌고 있는데 글자가 창 안에서 S, T, U 로 한 칸씩 넘어가는 것처럼 보여요.
+
+Lab 에서 해 보기: Text 레이어에 PHOTON 을 쓰고 Silkscreen (pixel) 로 size 8, x 32 가운데 정렬, y 49, 색 #6fd3ff, blend 는 add 로 둬요. effect 를 twinkle 로 하고 효과 노브를 Speed 로 고르면 필름과 렌즈 사이 빈 줄에서 낱말이 깜박이고, 섬광이 칠 때마다 빛줄기가 그 글자 위를 지나가요. Speed 를 올리면 원판과 깜박임이 같이 빨라져요.
+
+기능 감: Text 레이어를 한 점을 중심으로 돌리거나 원 둘레에 앉히는 길이요. 원판의 글자 고리는 머리를 테두리로 두고 원을 따라 서야 하는데, Text 레이어는 가로 글줄만 짜서 Lab 에서는 원판을 만들 수 없었어요. 그래서 5×7 글꼴 40자를 코드에 직접 그리고 글리프마다 회전을 셈했어요.
+
+### Quousque Tandem
+
+주제 7 「타이포」의 「글자로 짠 무늬」이면서, 주제 1 로 Medial Axis, Möbius Loxodrome, Talbot Carpet 셋뿐이던 가장자리 × 촘촘함 1,3 칸을 겨눈 패턴이에요. 윌리엄 캐즐런(William Caslon)의 활자 견본은 1734년 날짜를 달고 나왔고, 로먼과 이탤릭을 14가지 크기로 보여 줘요. 탤벗 베인스 리드(Talbot Baines Reed)는 『A History of the Old English Letter Foundries』(1887)에서 이 한 장에 든 활자를 38벌로 셌어요. 견본이 크기마다 되풀이해 짠 글줄은 키케로(Marcus Tullius Cicero)가 기원전 63년 카틸리나(Catilina)를 겨눈 첫 연설의 첫 문장 「Quousque tandem abutere, Catilina, patientia nostra?」 예요. 패널에서는 이 글줄 하나가 줄마다 같은 자리에서 시작해 왼쪽 정렬로 쌓이고, 아랫줄은 윗줄의 0.7 배 크기예요. 맨 윗줄은 38줄 높이에 대문자가 24 LED 이고, 대문자가 1.5 LED 를 넘는 줄이 여덟이에요. 맨 아래 7줄에서는 그보다 작은 글자가 덮인 넓이로만 남아 회색 결이 돼요. 한 줄 걸러 12도 기울여 견본의 이탤릭 자리를 채웠는데, 진짜 이탤릭이 아니라 로먼을 기울인 꼴이에요. 글자는 이 패턴에서 새로 그린 19자예요. 뼈대를 em 단위 꺾은선으로 적고 30도로 쥔 넓적한 펜촉(0.089 em)으로 그어서, o 의 11시와 5시 자리가 가는 올드스타일 획이 나와요. 글줄 전체를 em 당 40 텍셀, 4×4 부표본으로 한 번 그려 넓이 합 표(summed-area table)로 두면, 어느 크기의 어느 LED 든 네 번 찾아 덮인 넓이를 정확히 구해요. 그래서 0.1 LED 높이의 줄도 큰 줄과 같은 셈으로 그려져요. 페이지는 왼쪽 아래 모서리를 중심으로 0.7 배씩 줄어든 제 그림이라, 2.5초마다 1.43 배 확대하면 모든 줄이 윗줄의 자리와 크기로 자라고 고리가 이어져요. 로먼과 기울인 줄이 한 주기마다 자리를 바꿔서 그림은 5초에 한 바퀴예요. 첫 판은 크기가 1/v 로 줄어 대문자 17 LED 에서 0.5 LED 까지 내려갔고, 패널 아래 절반을 작은 글자가 채웠어요. 촘촘함 0.059, 가장자리 0.254 였어요. 1 LED 아래 글자는 덮임이 고르게 퍼져 이웃 LED 차이가 6 아래로 떨어지고, 빈 종이는 차이가 0 이었어요. 종이에 LED 하나 크기의 바둑판 결(±19)을 깔고 크기가 대문자 1 LED 언저리에서 천천히 줄게 바꾸자 0.135 와 0.130 이 됐어요. 작은 글자 띠의 계단은 20~25 에 머물렀어요. 결과 글자 자신의 계단이 반은 더해지고 반은 지워지기 때문이에요. 이웃 대비를 눌러 펴는 곡선을 얹자 오히려 평평한 자리가 늘어 0.124 와 0.240 으로 나빠졌어요. 칸에 들어간 것은 크기 법칙을 등비로 바꾼 뒤예요. 대문자 1.5 LED 를 넘는 줄이 패널의 94% 를 차지하고, 대문자 4 LED 를 넘는 글자는 덮임을 잉크나 종이 쪽으로 밀어 날카롭게 그려서 계단이 200 언저리로 크고 드물어요. 바둑판 결은 글자의 부드러운 계단이 이미 있는 자리에서만 줄여 둘이 합쳐 40 을 넘지 않게 했어요. 그 판이 0.207 과 0.169 였고, 잉크를 0.12 에서 0.075 로 더 어둡게 해 최종 값이 나왔어요. 잰 값은 움직임 1.298, 촘촘함 0.215, 가장자리 0.173, 복잡도 0.745, 채움 0.935, 색 0.148, 모양 바뀜 0.117 이고, 노브는 0.19, 0.21, 0.19, 0.15 예요. 촘촘함이 0.189 를 넘고 가장자리가 0.210 아래라 1,3 칸에 넷째로 서요. 뜻밖이었던 것은 대비를 키웠는데 촘촘함이 내려간 일이에요. 종이를 0.95 로, 잉크를 0.10 으로 바꾸자 촘촘함이 0.207 에서 0.197 로 떨어졌어요. 결의 밝은 쪽이 255 에서 잘려 바둑판 계단이 낮아졌기 때문이에요. 크기가 1 LED 언저리에서 천천히 줄던 중간 판에서는 낱말 사이 빈칸이 줄마다 em 에 비례한 자리에 서서, 왼쪽 아래 모서리로 모이는 부채꼴 강이 회색 결을 갈랐어요. 첫 프레임은 글자 띠를 짓느라 35~45 ms 가 걸려요.
+
+Lab 에서 해 보기: Text 레이어에 Newsreader 로 Catilina 를 size 9, sharp 를 끄고 색 #b0201c 로 x 1 왼쪽 정렬, y 124 에 두고 blend 를 multiply 로 해요. Ratio 0.7 에서 회색으로 닫히는 맨 아래 7줄 위에 붉은 글줄이 앉아서, 실제 세리프 글꼴과 이 패턴이 넓적한 펜으로 그린 로먼을 비슷한 크기에서 견줄 수 있어요. 확대가 돌아도 맨 아래 줄은 거의 그대로라 붉은 글줄이 늘 회색 결 위에 있어요.
+
+기능 감: Text 레이어 크기 하한이 4 LED 라서, 글자가 1 LED 아래로 줄어 회색 결이 되는 것을 Lab 에서 해 볼 수 없었어요. 크기를 0.5 까지 내리고 덮임을 그대로 밝기로 쓰는 길이 있으면 이 패턴의 아래 7줄을 Text 레이어로 바로 견줄 수 있어요. 이번에는 글자 띠를 스크래치 스크립트로 PNG 로 뽑아 보며 d 와 q 의 볼이 줄기에서 떨어진 것을 찾아 고쳤어요.
+
+### Hellschreiber
+
+주제 7 「타이포」의 「글자가 만들어지는 과정」을 무선 전신으로 겨눴어요. 루돌프 헬(Rudolf Hell)이 1929년에 특허를 낸 헬슈라이버(Hellschreiber)는 글자를 부호로 바꾸지 않고 작은 점 격자 그대로 보내요. 펠트헬(Feld-Hell)에서 글자 하나는 7열이고 그 가운데 2열은 비어 있어요. 열마다 점을 아래에서 위로 소리의 켜짐과 꺼짐으로 보내고, 점은 122.5 보(baud), 글자는 초당 2.5 개예요. 받는 쪽은 도는 나선이 움직이는 종이 테이프를 눌러 찍는데, 한 열이 위아래로 두 번 찍혀요. 두 쪽 시계를 맞추는 신호가 없어서 시계가 조금만 달라도 글줄이 테이프를 타고 오르내리지만, 두 벌 가운데 한 벌은 언제나 통째로 읽혀요. 열마다 점 자리는 반 점 14 개예요. 패널은 양식지예요. 1번 줄부터 18줄 칸 일곱에 테이프 띠가 하나씩 붙고, 띠는 16줄이고, 위아래 빈 줄 하나씩 사이에 나선이 찍는 14줄이 7줄 글자 두 벌이에요. 글자는 이 패턴에 그린 굵은 5×7 대문자이고, 테이프 한 열이 LED 한 열이라 글자 하나가 7 LED 예요. 메시지는 다섯이에요. 텔레타이프 시험 문장 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 가 와요. 메시지마다 새 띠에서 시작하고, 띠는 아홉 자를 넘기 전 마지막 낱말 뒤 빈칸에서 잘려서 오른쪽 끝이 들쭉날쭉해요. 띠 아래와 오른쪽에는 그림자가 한 줄씩 져요. 금빛 인쇄 헤드가 띠 끝에서 다음 열을 기다리고, 나선이 테이프에 닿는 두 점이 그 막대를 흰 점으로 올라가요. Speed 2 에서는 펠트헬과 같은 초당 17.5 열이라 아홉 자 띠 하나가 3.6초예요. 처음에는 띠 다섯이 붙은 채로 열리고, 일곱째 칸이 차면 양식지가 0.45초에 한 칸 올라가 맨 위 띠가 나가요. Drift 는 받는 쪽 시계를 4% 빠르게에서 4% 느리게까지 돌려요. 느리면 글줄이 내려가고 빠르면 올라가요. 여는 0.06 에서는 0.24% 느려서 띠 하나에 한 줄쯤 내려가고, 일곱 띠를 지나면 한 벌 높이만큼 내려가 있어요. 1 에서는 25열마다 한 벌씩 떨어져서 글자가 기운 채 아래 벌에서 위 벌로 넘어가요. Noise 는 신호 1 에 얹는 잡음을 0.19 에서 0.56 rms 로 올려요. 0 에서는 빈 테이프의 2% 에 회색 점이 박히고, 1 에서는 4분의 1 에 박히며 잉크의 29% 가 빠져요. 페이딩은 12% 에서 57% 로 깊어지고, 1.5~5 줄을 까맣게 긋는 정전기 잡음(static crash)은 170 열에 하나에서 15 열에 하나로 늘어요. Paper 는 색을 한꺼번에 돌리고, 0 에서는 슬레이트 파랑 양식지에 크림색 테이프가 붙고 잉크는 남색이에요. 첫 판은 한 줄을 세 번 나눠 들어 평균하고 첫 위상을 줄 하나의 0.35 만큼 어긋나게 둬서, 줄마다 반이 회색인 흐린 글자가 됐어요. 잰 값은 움직임 0.456, 촘촘함 0.167, 가장자리 0.638, 복잡도 1.148, 채움 1.000, 색 0.126, 모양 바뀜 0.105 였어요. 줄마다 가운데 한 번만 듣게 하고 첫 위상을 −0.06 으로 당기자 첫 띠가 또렷하게 열렸고, 회색 단계가 줄어 복잡도가 0.895 로 내려왔어요. 잰 값은 움직임 0.478, 촘촘함 0.172, 가장자리 0.635, 복잡도 0.895, 채움 1.000, 색 0.141, 모양 바뀜 0.096 이고, 노브는 0.12, 0.05, 0.12, 0.20 이에요. 생각하지 못한 것은 기계의 기울기였어요. 나선이 한 바퀴 도는 동안 테이프가 한 열 나아가서 진짜 인쇄는 한 벌 높이에 한 열만큼 기운 이탤릭인데, 테이프 한 열이 LED 한 열이면 그 기울기가 한 줄에서 한 LED 꺾이는 턱이 돼요. 위상이 어긋나면 글자 아래쪽 줄이 다음 열에서 와서 한 칸 왼쪽에 찍혀요. 세로획이 1 LED 인 첫 글꼴은 그 턱에서 BROWN 이 BRWNN 처럼 끊겨 읽혔어요. 세로획을 2 LED 로 굵히자 턱 위아래 획이 한 열 겹쳐 이어졌어요. 두 벌은 같은 순간에 찍혀서, 잡음 점 하나도 위아래 벌에 똑같이 두 번 나와요.
+
+Lab 에서 해 보기: Text 레이어에 Silkscreen 으로 QRN 을 써요. size 8 에 sharp 를 켜고 색 #0c0e3d, blend multiply 로 x 60 오른쪽 정렬, y 44 에 두고 효과 twinkle 을 K3 에 걸어요. 셋째 칸의 JUMPS 띠는 짧아서 처음에는 슬레이트 양식지 위에 어두운 낱말로 앉고, 양식지가 올라가 긴 띠가 그 아래로 오면 크림색 테이프 위에 남색 도장처럼 찍혀요. Noise 를 올릴수록 QRN 이 빨리 깜박이고, 레이어 글자는 기울지 않아서 아래에서 미끄러지는 헬 글줄과 바로 견줘져요.
+
+기능 감: Lab 미리보기를 LED 몇 개 크기로 크게 보는 돋보기요. 띠 하나가 14줄에 7줄 글자 두 벌이라, 위상이 어긋날 때 글자가 어느 줄에서 꺾이는지 미리보기 크기로는 보이지 않았어요. 위 두 띠를 10배로 잘라 PNG 로 뽑는 스크립트를 따로 쓰고서야 BROWN 이 BRWNN 으로 읽히는 것을 찾았어요.
+
+### Laguerre Cells
+
+주제 5 「수학 · 추상」으로, 셀 갈래에 파워 다이어그램을 반이산 최적 수송의 풀이로 세웠어요. 61판 README 가 Monge Transport 의 다음 걸음으로 적어 둔 것이에요. 프란츠 아우렌하머(Franz Aurenhammer)가 1987년에 정리한 파워 다이어그램은 점 p 마다 무게 w 를 주고, 평면의 점 x 를 |x − p|² − w 가 가장 작은 점에 붙여요. 에드몽 라게르(Edmond Laguerre)의 이름을 따서 라게르-보로노이 다이어그램이라고도 해요. 두 칸은 곧은 선에서 만나고, w_i 를 Δw 올리면 그 선이 p_i 에서 Δw/(2|p_i − p_j|) 만큼 멀어져요. 무게가 다 같으면 보로노이 다이어그램이에요. 아우렌하머와 호프만, 아로노프(Aurenhammer, Hoffmann, Aronov)는 1998년에, 어떤 점과 어떤 질량을 주든 칸마다 그 질량을 담게 하는 무게가 있고 그 무게가 무게의 볼록 함수의 최솟점이라는 것을 보였어요. 연속 밀도를 점들로 옮기는, 비용이 |x − p|² 인 최적 수송이에요. 그 함수의 기울기는 칸마다 모자란 질량이고, 헤세 행렬은 두 칸이 맞댄 변 위의 밀도를 2|p_i − p_j| 로 나눈 값이에요. 준 기타가와(Jun Kitagawa)와 캉탱 메리고(Quentin Mérigot), 보리스 티베르(Boris Thibert)가 2019년에 이 문제에서 감쇠 뉴턴법이 수렴함을 보였어요. 패널에는 점 24 개를 하나에 24 번씩 던져 가장 먼 자리를 고르는 식으로 흩어요. 밀도는 부드러운 봉우리 셋의 로그 밀도를, 가장 진한 LED 와 가장 옅은 LED 가 12 대 1 이 되게 올린 것이에요. LED 하나가 질량 한 칸이고, 변에서 반 LED 안에 있는 LED 는 변을 넘은 만큼 질량을 두 칸에 나눠요. 그래서 무게를 바꾸면 질량이 매끄럽게 움직이고, 같은 LED 들이 헤세 행렬을 줘요. 매 프레임 켤레 기울기법으로 뉴턴 걸음을 풀고, 무게는 1초에 그 걸음의 1.5 × Speed 몫을 가요. Speed 2 에서는 오차가 0.33 초마다 e 분의 1 로 줄어요. 처음은 무게가 다 0 인 보로노이라서 가장 넘친 칸이 제 몫의 네 배를 담는데, 1.5 초에 오차가 5% 안, 2 초에 2% 안으로 들어와요. 칸은 맞으면 청록이고, 넘치면 보라, 모자라면 초록으로 기울며, 밝기는 그 자리의 밀도예요. 밀도는 6 초 머문 뒤 1.6 초 동안 다음 봉우리로 옮겨 가요. 첫 옮김이 4.4 초에 시작해서 5.5 초에 가장 큰 오차가 142% 까지 오르고, 7 초에 2.4% 로 돌아와요. 첫 판은 무게를 반지름 √(w − 가장 작은 w) 인 원으로 그렸어요. 무게 폭이 4,000 LED² 에 이르러 원이 63 LED 까지 커지고 봉우리 위에서 겹겹이 엉켰어요. 원을 제 칸 안에서만 그려 봤더니 원 대부분이 제 칸보다 커서 거의 보이지 않아, 원을 뺐어요. 봉우리가 3 LED 를 돌며 떠다니게 하자 다 맞은 뒤에도 오차가 4~5% 에 머물렀고 Contrast 1 에서는 11% 였어요. 떠도는 폭을 2 LED 로 줄이고 걸음 몫을 1.25 에서 1.5 로 올려 1~2.3% 가 됐어요. 한 프레임에 무게가 ±40 까지만 움직이게 막았을 때는 어려운 밀도에서 3 초에도 오차가 48% 였어요. 막는 폭을 칸 평균 넓이의 3분의 1 로 넓히자 2 초에 1.4% 예요. 2 ms 에 가깝던 프레임은 봉우리를 가로와 세로 가우스의 곱으로 셈하고 지수를 표에서 읽어 1.2 ms 가 됐어요. 잰 값은 움직임 0.153, 촘촘함 0.036, 가장자리 0.357, 복잡도 1.564, 채움 1.000, 색 0.211, 모양 바뀜 0.187 이고, 노브는 0.19, 0.15, 0.09, 0.07 이에요. 새로 본 것은 점이 제 칸에 있지 않다는 거예요. 보로노이에서는 모든 점이 제 칸 안에 있는데, 질량을 맞추고 나면 점 24 개 가운데 11 개가 남의 칸에 앉아 있고 첫 옮김 뒤에는 17 개예요. 점 64 개에서는 48~53 개예요. 점을 흰 255 로 찍으면 눈이 점을 칸의 중심으로 읽어서 150 으로 낮췄어요.
+
+### Hexachordal Theorem
+
+주제 5 「수학 · 추상」이에요. 열두 음에서 여섯을 고르면 고른 여섯과 남은 여섯은 음정 내용이 같아요. 반음 1개부터 6개까지 어느 거리든 두 집합에서 같은 횟수로 나와요. 밀턴 배빗(Milton Babbitt)이 1950년대에 헥사코드에서 이 성질을 말했고, 데이비드 루윈(David Lewin)이 1959년과 1960년에 『Journal of Music Theory』에 낸 두 짧은 글이 이를 증명하고 한 집합과 그 여집합 사이의 관계로 넓혔어요. 고드프리 투생(Godfried Toussaint)은 『The Geometry of Musical Rhythm』(2013)에서 이것을 리듬으로 읽어요. 12펄스 한 바퀴에 온셋 여섯을 둔 리듬과, 그 쉼표 자리마다 온셋을 둔 나머지 리듬은 거리 막대가 같아요. 패널 위 고리(가운데 20째 줄, 반지름 15.5 LED)에서 첫 리듬이, 아래 고리(가운데 108째 줄)에서 나머지 리듬이 같은 박을 따라 돌아요. 두 리듬은 서로의 쉼표에서 울려서 박마다 꼭 한 고리만 울려요. 고리마다 온셋 둘을 이은 현 15개가 그어지고, 현의 색은 두 온셋이 몇 박 떨어졌는지를 말해요. 온셋이 울리면 부풀며 퍼지는 고리를 내보내고, 그 온셋에서 나간 현 다섯이 밝아져요. 가운데 61~65째 줄에 거리 1~6 의 번호가 서고, 첫 리듬의 쌍은 59째 줄에서 위로, 나머지 리듬의 쌍은 68째 줄에서 아래로 3줄짜리 블록 하나씩 쌓여요. 블록은 제 현과 같이 밝아지고, 막대 끝에는 그 수가 숫자로 적혀서 위아래로 3 1 3 4 3 1 같은 줄이 두 번 읽혀요. 여는 리듬 x x x . . x x . . x . . 은 앨런 포트(Allen Forte)가 1973년에 매긴 번호로 6-Z44, 쇤베르크 헥사코드예요. 나머지 여섯은 그것을 돌리거나 뒤집은 것이 아닌 6-Z19 인데 막대가 같아요. Speed 2 에서 1초에 4박이라 12박 한 바퀴가 3초이고, 바퀴가 돌 때마다 첫 리듬의 온셋 하나와 그 옆 쉼표가 자리를 바꿔요. 두 점은 0.35초에 미끄러지고, 막대는 0.25초에 새 높이로 가는데 위아래가 같이 움직여서 거울이 한 번도 깨지지 않아요. Uneven 은 온셋을 하나씩 나머지 리듬으로 넘겨 5 대 7, 4 대 8, 3 대 9 를 만들어요. 그러면 나머지 리듬의 막대가 넘긴 온셋 하나마다 모든 칸에서 꼭 2 블록, 마지막 6 칸에서만 1 블록 길어지고, 넘친 블록은 흰빛으로 칠해요. 온셋 a 개인 리듬과 그 나머지는 각 거리의 순서쌍 수가 n − 2a 만큼 달라서, 12박에 a 가 6 이면 0 이에요. Pulses 는 고리를 14, 16, 18, 20박으로 늘리고 그때도 반반이면 막대가 같아요. 첫 판은 고리 반지름이 17 LED 였고 잰 값이 움직임 0.174, 촘촘함 0.065, 가장자리 0.905, 복잡도 0.242, 채움 0.180, 색 0.168, 모양 바뀜 0.045, 노브 0.05, 0.03, 0.07, 0.05 였어요. 막대가 가운데에 낮게 깔려 세어 보기 어려웠고 Speed 가 문턱에 있었어요. 고리를 15.5 LED 로 줄여 막대 자리를 넓히고 막대 끝에 수를 적었어요. 울리는 온셋에서 고리 안으로 번지는 빛과, 박을 따라가는 한 박 길이의 꼬리도 더했어요. 위 고리의 박 표시가 -0.5째 줄로 패널 밖에 나가 있어서 고리를 한 줄 내렸어요. 잰 값은 움직임 0.239, 촘촘함 0.073, 가장자리 0.880, 복잡도 0.353, 채움 0.204, 색 0.157, 모양 바뀜 0.055, thirds 17/24/18 이고 노브는 0.05, 0.04, 0.09, 0.06 이에요. 막대가 같은 두 리듬이 꼴까지 같은 경우는 생각보다 적었어요. 12박에서 여섯을 고르는 924 가지를 다 세어 보니 552 가지(60%)가 나머지 여섯과 돌리거나 뒤집어도 겹치지 않는데 막대가 같았고, 16박에서 여덟을 고르는 12,870 가지에서는 10,768 가지(84%)였어요.
+
+### Frenkel-Kontorova
+
+주제 5 「수학 · 추상」으로 프렌켈-콘토로바 모형을 그렸어요. 64판 Kibble-Zurek Ions 뒤 「다음 판 감」에 적힌 것을 받았어요. 야코프 프렌켈(Yakov Frenkel)과 타티야나 콘토로바(Tatiana Kontorova)가 1938년에 소성 변형과 쌍정을 설명하려고 낸 모형으로, 용수철로 이은 공 사슬이 사인 꼴의 주기 퍼텐셜 위에 누워요. 사슬의 평균 간격이 바닥의 주기와 맞지 않으면 사슬은 거의 공 하나에 우물 하나로 눕고, 어긋남은 꼬임(kink) 몇 곳에 모여 거기서 우물 하나만큼 미끄러져요. 패널 맨 아래 15줄이 그 사슬이에요. 바닥은 5.33 LED 마다 우물이 하나씩, 12개가 패널 너비를 한 바퀴 두르는 고리이고, 그 위에 공 14개가 누워서 두 공이 한 우물을 나눠 쓰는 꽉 낀 꼬임이 둘 생겨요. 위 113줄은 기록이에요. 1/12초마다 한 줄씩 쌓이고 가장 오래된 줄이 맨 위라서 시간이 패널을 따라 아래로 흘러요. 줄마다 공의 자리가 세계선으로 찍히고, 그 밑에 결합이 늘거나 준 정도가 띠로 깔려요. 한 우물에 하나씩 누운 곳은 어두운 파랑, 꽉 낀 꼬임은 자홍, 늘어난 꼬임은 초록이에요. 모든 공을 같은 힘으로 밀면 꼬임이 고리를 돌며 지나는 공을 하나씩 한 우물 옆으로 옮겨요. 여는 값 Drive 2 에서는 꼬임이 1초에 22 LED 쯤 오른쪽으로 달려 2.9초에 고리를 돌고, 공은 1.7초마다 한 우물씩 비켜 가요. 기록에서 꼬임은 35줄쯤에 패널 너비를 건너는 비스듬한 자홍 띠예요. Misfit 은 평균 간격을 우물 간격으로 나눈 값이고 공 개수로 반올림돼요. 0.86 은 공 14개, 0.945 는 13개로 꽉 낀 꼬임이 하나예요. 1.03 은 12개라 꼬임이 없고, 사슬 전체가 뜯겨 나가기 전에는 움직이지 않아요. 1.115 는 11개로, 늘어난 꼬임 하나가 힘을 거슬러 1초에 22 LED 로 왼쪽으로 가요. 1.2 는 10개예요. Substrate 는 용수철 세기 1 에 대한 바닥의 깊이 K 로, V = K/4π² (1 − cos 2πx) 이고 그림에서는 3 + 1.25K LED 높이예요. K 가 1 이면 꽉 낀 꼬임이 결합 넷에 퍼지고, 2.5 면 거의 한 결합이 우물 0.58 만큼 줄어들어 Drive 2 가 있어야 움직여요. 3.25 에서는 Drive 2 로 다음 마루를 넘지 못해 기록이 멈춰 서고, 4 에서는 Drive 3 이 있어야 해요. K2 를 누르면 힘이 거꾸로 가서 띠가 V 자로 꺾여요. 첫 판은 4 LED 마다 우물 16개를 두고 공 18개를 얹었어요. K 를 0.3 에서 열고 힘도 K 에 비례하게 줬더니 꼬임이 넓게 퍼져서 사슬이 거의 고르게 보였고, 3.5 LED 마다 선 세계선 사이로 꼬임은 희미한 보라 빗금이었어요. 그때는 사슬이 맨 위에 있고 새 줄이 그 밑으로 들어와서 시간이 위로 흘렀어요. 우물을 12개로 줄이고 K 를 1 에서 열고, 사슬을 바닥에 내려 시간이 아래로 흐르게 한 판을 처음 쟀을 때 움직임 0.928, 촘촘함 0.119, 가장자리 0.506, 복잡도 1.728, 채움 0.477, 색 0.137, 모양 바뀜 0.041 이었어요. 그 뒤 힘을 K 와 떼어 놓자 바닥이 깊을수록 꼬임이 우물에 갇히는 것(파이얼스-나바로 장벽)이 Substrate 노브에 그대로 보였어요. 늘어난 꼬임은 처음에 금빛이었는데 어두운 금빛이 올리브로 읽혀서 초록으로 바꿨어요. 잰 값은 움직임 0.986, 촘촘함 0.125, 가장자리 0.521, 복잡도 1.703, 채움 0.494, 색 0.173, 모양 바뀜 0.038, thirds 49/49/49, 0.4 ms 이고, 노브는 0.09, 0.18, 0.19, 0.15 예요. 새로 본 것은 꼬임이 지나가도 세계선이 곧은 줄로 보인다는 거예요. 꼬임이 지나면 공마다 이웃이 있던 우물로 옮겨 앉아 모든 우물이 다시 차서, 꼬임 띠만 빼면 그림이 앞과 같아요. 공 14개 가운데 첫째와 여덟째를 크림색으로 칠하고서야 세계선이 띠를 지날 때마다 한 우물씩 비켜 가는 계단이 보였어요.
+
+### Granular Leidenfrost
+
+주제 5 「수학 · 추상」과 주제 4 로 입자 갈래에 세운 패턴이에요. 페터르 에스하위스(Peter Eshuis), 코 판 데르 벨레(Ko van der Weele), 데바라즈 판 데르 메이르(Devaraj van der Meer), 데틀레프 로서(Detlef Lohse)는 「Granular Leidenfrost Effect: Experiment and Theory of Floating Particle Clusters」(Physical Review Letters 95, 258001, 2005)에서, 위아래로 흔드는 납작한 상자의 구슬이 흔들기 세기를 넘고 구슬이 넉넉하면 결정처럼 뭉친 덩어리가 되어 아래의 묽고 빠른 구슬 기체 위에 뜨는 것을 보였어요. 뜨거운 판 위의 물방울이 제 증기 위에 뜨는 라이덴프로스트 효과(Johann Gottlob Leidenfrost, 1756)에서 이름을 빌렸고, 흔들기 세기 S 와 층 수 F 의 상도로 실험과 이론을 맞췄어요. 패널은 지름 4 LED 의 원판 320알을 하나하나 부딪쳐요. 한 층에 16알이라 20층이고, 상자는 32알 높이예요. 중력 가속도는 40 LED/s², 알끼리의 반발 계수는 0.88 이에요. 바닥은 59판 Granular Demon 처럼 짧고 빠른 행정의 극한인 톱니로 썼어요. 바닥에 닿는 알을 늘 속도 U 로 쳐 올리고 충격의 15% 까지 옆으로 돌려요. Shaking 2 에서 U 가 초당 104 LED 라 U²/(g·d) 가 68 이에요. 알은 지름보다 조금 작게(반지름 1.6) 그려서 덩어리가 판이 아니라 알로 읽히고, 0.375초로 다듬은 속도 제곱을 바닥 속도에 견준 로그로 색을 매겨요. 찬 알은 청록이고 뜨거운 알은 보라를 지나 연분홍이 되며, 가장 뜨거운 알만 빛 무리를 둘러요. 여는 자리에서는 청록 결정의 밑면이 바닥에서 40 LED 쯤 위에 뜨고 윗면이 30번째 줄 근처예요. 그 아래 40 LED 는 분홍 기체가 차고, 결정의 아래쪽 몇 줄이 보라로 데워져 있어요. Shaking 0.5 에서는 결정이 바닥에 내려앉아 76 LED 깊이의 더미가 되고, 3 에서는 60 LED 위로 떠서 뚜껑에 눌려요. Restitution 0.98 에서는 결정이 녹아 뚜껑 쪽이 진한 기체가 되고, 그 맨 위 알도 바닥 속도의 3분의 1 로 움직여요. 첫 판은 지름 2.5 LED 의 240알에 반발 계수 0.94 였어요. 덩어리 없이 높이 중간이 조금 진한 기체만 생겼고, 8줄 띠마다 21알로 빽빽한 결정의 94알에 한참 못 미쳤어요. 반발 계수를 0.85 로 낮추고 알을 300 으로 늘리자 차가운 덩어리가 16 LED 기체 위에 떴지만, 모두 바닥 48줄 안이라 위 80줄이 비었어요. 알을 지름 4 LED 로 키워 상자를 32알 높이로 줄이자 같은 상태가 패널 높이를 다 썼어요. 잰 값은 움직임 3.031, 촘촘함 0.168, 가장자리 0.654, 복잡도 1.955, 채움 0.641, 색 0.308, 모양 바뀜 0.113 이고 `thirds` 32/84/75, 노브는 0.20, 0.35, 0.35, 0.21 예요. 뜻밖이었던 것은 뚜껑이에요. 흔들기를 아무리 키워도 기체가 되지 않고, 결정이 뜨거운 기체에 밀려 뚜껑 밑에 붙은 라이덴프로스트가 됐어요. 반발 계수 0.94 에서도 320알 결정은 뚜껑에 붙었어요. 이 상자에서 기체로 가는 길은 흔들기가 아니라 알을 덜 비탄성으로 만드는 쪽이었어요.
+
+### Multiplicative Chaos
+
+주제 5 「수학 · 추상」으로 장피에르 카안(Jean-Pierre Kahane)의 가우스 곱셈 카오스를 노이즈 갈래에 세우고, 주제 1 로 Agate, Percolation, Sunglint 셋뿐이던 촘촘함 × 복잡도 4,4 칸을 겨눴어요. 촘촘함이 0.297, 복잡도가 2.172 를 넘는 칸이에요. 56판 Multiplicative Cascade 는 패널을 열세 번 반으로 나눈 만델브로의 이산 캐스케이드였고, 그 README 가 다음으로 카안의 연속판을 짚었어요. 카안은 「Sur le chaos multiplicatif」(Ann. Sci. Math. Québec 9, 1985)에서 거리 r 의 공분산이 log(1/r) 처럼 가는 가우스장 X 로 측도 exp(γX − γ²E[X²]/2)dx 를 만들었어요. 공분산을 그렇게 맞추면 임계값은 γ = √(2d) 이고 평면에서는 2 예요. 측도는 X 가 γ log(1/ε) 언저리인 γ-두꺼운 점 위에 얹히고, 그 점들의 차원 2 − γ²/2 는 γ 가 2 로 가면 0 이 돼요. 이 둘은 레미 로드(Rémi Rhodes)와 뱅상 바르가스(Vincent Vargas)의 개관(Probability Surveys 11, 2014)이 정리한 대로 적었어요. 패널의 X 는 64×128 토러스에서 격자 라플라시안의 고유 모드 8,191 개로 짰어요. 모드의 표준편차를 √(2π/(λN)) 로 두어 공분산이 log(1/r) 꼴이 되게 했고, 재 보니 C(r) − C(2r) 가 r = 1, 2, 4 LED 에서 0.71, 0.71, 0.68 로 log 2 = 0.69 언저리였어요. 모드는 저마다 시간에 매끈하게 만든 오른슈타인-울렌벡 과정으로 떠돌아서, Speed 2 에서 128줄 긴 파동은 8초, 가장 잘은 파동은 1.6초에 제 값을 잊어요. 여는 자리의 장은 LED 의 4분의 1 까지 내려가요. LED 아래 두 옥타브는 분산 1.39 의 정규값을 LED 마다 따로 뽑아 넣어서, 장 전체의 분산 6.37 가운데 그만큼이 LED 마다 독립이에요. 장은 왼쪽 위에서 빛을 받은 깊은 파랑 부조로 그렸어요. 측도는 각 LED 가 프레임 질량에서 차지하는 몫으로 그려서, 고른 몫의 0.14 배부터 장밋빛으로 켜지고 주황과 금빛을 지나 33배에서 흰빛이 돼요. 장 스무 개를 평균하니 γ = 1 에서 LED 의 3분의 1 이 빛나고, 밝은 1% 가 질량의 52% 를 갖고 78 LED 가 절반을 가져요. 1.6 에서는 9% 가 빛나고 6 LED 가 절반을 갖고, 2.4 에서는 한두 LED 가 절반을 가져요. Cutoff 는 장이 내려가는 가장 잘은 크기를 4분의 1 LED 에서 12.5 LED 까지 올려요. 한 LED 에서는 금빛 레이스가 부드러운 구름이 되고, 12.5 에서는 LED 95% 가 흐린 녹슨 빨강으로 고르게 빛나요. 첫 판은 LED 아래 옥타브 없이 장을 부조로 그리고 금빛을 반투명하게 얹었는데, 촘촘함 0.237, 복잡도 2.692 였어요. 격자 장은 이웃 LED 끼리 상관이 0.685 라, 밝기 하나로 칠하면 문턱 하나로 둘로 가르는 가장 거친 칠도 촘촘함이 (1/π)arccos(0.685) = 0.26 이에요. LED 아래 두 옥타브를 넣어 상관을 0.54 로 낮추고 부조의 밝기를 0.02 에서 1 까지 다 쓰자 촘촘함이 0.346 이 됐어요. 양 끝에서 잘리는 LED 가 늘면서 복잡도는 칸 위 끝 2.7352 에 붙어 있던 2.692 에서 2.359 로 내려왔어요. 잰 값은 움직임 0.249, 촘촘함 0.346, 가장자리 0.787, 복잡도 2.359, 채움 0.753, 색 0.431, 모양 바뀜 0.070 이고, 노브는 0.31, 0.21, 0.09, 0.25 예요. 새로 본 것은 8,192 LED 위에서는 질량이 γ = 2 보다 한참 앞에서 얼어붙는다는 거예요. 질량이 앉은 높이는 γ = 1 에서 0.93 E[X²] 로 γE[X²] 를 따르다가 1.3 에서 1.12, 1.6 에서 1.27 로 처지고, 장의 최댓값 1.47 E[X²] 에 가서 붙어요. 격자가 커지면 최댓값은 2 E[X²] 로 가지만, 이 패널에서는 1.47 이 끝이에요.
+
 ## 지도
 
 지도의 자리는 손으로 매긴 점수가 아니라 잰 값이에요. 패턴마다 처음 노브 값으로 Lab 엔진에서 8초를 돌리고, 2초부터 6초 동안의 화면을 재요. LED 하나의 밝기는 세 채널 가운데 가장 밝은 값으로 봐요.
@@ -3861,7 +3940,7 @@ ESP32-S3 로 옮길 때 걸릴 것도 있어요. Reaction Diffusion 은 Node 에
 
 ## 다음 판 감
 
-10월 25일 `dev`(`f72355d`)의 328개에 43판부터 68판까지의 이백예순 개를 더한 588개에서 잰 값이에요. 패턴 바퀴는 주제 안에서 무엇을 할지 고를 때 이 절을 읽고, 한 것은 빼고 새로 본 것을 더해요.
+10월 25일 `dev`(`f72355d`)의 328개에 43판부터 70판까지의 이백여든 개를 더한 608개에서 잰 값이에요. 패턴 바퀴는 주제 안에서 무엇을 할지 고를 때 이 절을 읽고, 한 것은 빼고 새로 본 것을 더해요.
 
 ### 지도의 빈 칸
 
@@ -3957,6 +4036,8 @@ ESP32-S3 로 옮길 때 걸릴 것도 있어요. Reaction Diffusion 은 Node 에
 
 69판은 67판까지 든 578개에 빈 칸도 둘뿐인 칸도 없어서, 셋뿐인 칸 일곱 가운데 같이 돈 68판(#331)이 고른 가장자리 × 촘촘함 1,2 와 복잡도 × 채움 4,2 를 빼고 가장자리 × 복잡도 4,4 와 가장자리 × 촘촘함 2,4 를 겨눴어요. 가장자리 × 복잡도 4,4 는 40 을 넘는 계단의 몫이 0.79 를 넘으면서 복잡도가 2.171 을 넘는 칸이에요. Nine-fold Seal 은 획과 종이를 한 밝기씩으로만 칠하고 안티에일리어싱을 두지 않아서 이웃 사이 밝기 차가 0 이거나 156 이라 가장자리가 1.000 이에요. 복잡도는 가장 밝은 채널을 3 까지만 흔들고 나머지 두 채널을 LED 마다 크게 흔들어 올렸어요. 첫 판은 인주의 G 와 B 를 ±13, 종이를 ±9 흔들어 1.778 이었고, 인주 ±58, 종이 ±31 로 키우자 2.403 이 됐어요. G 와 B 를 따로 흔들면 인주가 주황 점과 분홍 점으로 갈려서 한 값으로 같이 흔들었고, 그 판이 2.379 예요. 종이를 LED 마다 켜 두어 채움이 1.000 인데, 그 축의 끝이 이미 1.0 이라 축을 늘리지 않아요. 가장자리 × 촘촘함 2,4 는 가장자리가 0.21 에서 0.50 사이이면서 촘촘함이 0.297 을 넘는 칸이에요. 굳은 계단은 글자가, 무른 계단은 고랑이 맡아야 해요. Boustrophedon 은 고랑을 한 줄에 24씩 오르내리는 삼각형 단면으로 깎아 이웃 쌍 대부분이 7 에서 40 사이의 무른 계단이고, 3×5 글자의 테두리가 굳은 계단의 몫 0.38 을 정해요. 첫 판은 글자를 185 에서 140 으로 식히고 구름 그림자가 글자까지 덮어 굳은 계단의 평균이 113.5 에 그쳐서 촘촘함이 0.205 였어요. 글자가 제 빛을 내고 구름이 흙만 덮게 하고, 글자를 226 에서 216 으로만 식히고 골 바닥을 6 으로 내리자 평균이 190.7 이 되어 촘촘함 0.321, 가장자리 0.387 로 칸 안에 들었어요. 글꼴과 칸 배치가 가장자리를 정하고 밝기가 촘촘함을 정한 셈이에요. 열 개 다 일곱 축의 끝 안에 있어서 칸 경계는 60판 그대로예요. 68판의 열 개까지 든 598개에서 지도 21장은 다 `none` 이고, 68판이 채운 두 칸까지 셋뿐인 칸은 일곱에서 셋이 됐어요.
 
+70판은 68판까지 든 588개에 같이 돈 69판(#332)의 열 개를 더해 세어도 빈 칸도 둘뿐인 칸도 없었어요. 69판이 고른 가장자리 × 복잡도 4,4 와 가장자리 × 촘촘함 2,4 는 그 열 개로 넷이 되어, 셋뿐인 칸은 가장자리 × 촘촘함 1,3 과 1,4, 촘촘함 × 복잡도 4,4 셋이었고, 그 가운데 가장자리 × 촘촘함 1,3 과 촘촘함 × 복잡도 4,4 를 겨눴어요. 가장자리 × 촘촘함 1,3 은 가장자리가 0.210 아래이면서 촘촘함이 0.189~0.297 인 칸이에요. 이웃 쌍의 80% 쯤이 35 언저리 계단이고 17% 쯤이 140 을 넘는 계단이어야 해요. Quousque Tandem 은 1 LED 아래 크기의 글자를 덮인 넓이로 그린 회색 결로 그 칸을 노렸는데, 넓이대로 그린 회색은 계단 10~25 의 거의 평평한 면이라 첫 판이 촘촘함 0.059, 가장자리 0.254 였어요. 종이에 ±19.5 의 한 LED 바둑판 결을 깔고, 크기를 등비로 줄여 대문자 1.5 LED 를 넘는 줄이 패널의 94% 를 덮게 하자 촘촘함 0.215, 가장자리 0.173 이 됐어요. 칸을 세운 것은 작은 글자가 아니라 종이 결과 드문 큰 가장자리였어요. 촘촘함 × 복잡도 4,4 는 촘촘함이 0.297, 복잡도가 2.172 를 넘는 칸이에요. 이웃 LED 차이가 평균 76 을 넘으면서 deflate 가 줄이지 못해야 해요. Multiplicative Chaos 의 첫 판은 로그 상관장을 LED 하나에 밝기 하나로 칠해 촘촘함 0.237, 복잡도 2.692 였어요. 이웃 LED 끼리 상관이 0.685 라, 문턱 하나로 둘로 가르는 가장 거친 칠도 촘촘함이 0.26 을 넘지 못해요. LED 아래 두 옥타브를 LED 마다 따로 넣자 0.346 과 2.359 가 됐어요. 복잡도는 축 끝 2.735 바로 아래에 있다가 칸 안으로 내려왔어요. 열 개 다 일곱 축의 끝 안에 있어서 칸 경계는 60판 그대로예요. 69판까지 든 598개에 70판 열 개를 더한 608개에서 지도 21장은 다 `none` 이고, 겨눈 두 칸은 둘 다 넷이 됐어요. 셋뿐인 칸은 가장자리 × 촘촘함 1,4 하나가 남았어요.
+
 ### 아직 없는 갈래
 
 `families.json` 의 쉰여섯 갈래에 없는 것 가운데 세운 패널에 맞을 것을 적어 둬요. 29판이 연 위상·매듭 갈래는 Hopf Fibration 과 31판의 Boy's Surface, 33판의 Borromean Rings, 34판의 Lakes of Wada, 36판의 Heawood Torus, 38판의 Sperner's Lemma, 39판의 Borsuk-Ulam, 44판의 Ham Sandwich, 46판의 Reeb Graph, 48판의 Möbius Energy, 49판의 Square Peg, 51판의 Persistence Barcode, 53판의 Belt Trick, 55판의 Universal Cover 예요. 28판이 열려다 접은 갈래라 28판의 Hairy Ball 은 노이즈·흐름에 그대로 있어요. 세잎 매듭은 48판의 Möbius Energy 가 처음 세웠어요. 29판은 화장품 팝업 갈래도 열었어요. 주제 6 의 몫이라 주제 2 로 세지 않았고, Cream Swirl, Serum Gel, Glitter Fall, Loose Powder 넷이 다 들어 있어요. 30판의 Swatch Row, Pearl Sheen, Bi-Phase, Satin Fold 가 그 갈래에 넷을 더했고, 31판의 Lip Gloss, Foam Lather, Setting Mist, Sponge Blend 가 넷을 더 더해 열둘이에요. 32판의 Cushion Mesh, Clay Mask, Sugar Scrub, Chrome Powder 가 넷을 더해 열여섯이고, 33판의 Cleansing Balm, Gold Leaf, Essence Drop, Peel-Off 가 넷을 더해 스물이에요. 34판의 Cat Eye, Velvet Nap, Mood Tint, Hair Gloss 가 넷을 더해 스물넷이고, 35판의 Bath Fizz, Toner Pad, Sheet Mask, Gilded Cream 이 넷을 더해 스물여덟이고, 36판의 Lotion Ribbon, Shimmer Oil, Blooming Gel, Whipped Soap 이 넷을 더해 서른둘이에요. 38판의 Milk Ring, Couette Shimmer, Photochromic, Serum Fingers 가 넷을 더해 서른여섯이에요. 39판의 Soap Film, Blotting Paper, Serum Drip, Crackle Polish 가 넷을 더해, 37판의 넷까지 마흔넷이에요. 41판은 할로윈 갈래를 열었어요. 주제 6 의 몫이라 주제 2 로 세지 않았고, Jack-o'-Lantern, Sheet Ghosts, Spider Drop, Cauldron, Eyes in the Dark 다섯이 들어 있어요. 28판이 연 수론 갈래는 Ford Circles 와 30판의 Three Gaps, 31판의 Gaussian Moat, 32판의 Gilbreath Table, 33판의 Goldbach Comet, 35판의 Kolakoski, 36판의 Elliptic Chords, 39판의 Explicit Formula, 44판의 Bulgarian Solitaire, 48판의 Chebyshev's Bias, 49판의 Curlicue, 51판의 Sato-Tate, 53판의 Gaussian Periods, 55판의 Question Mark Function 이에요. 27판이 연 철도 갈래는 Funicular 하나이고, 필름·영화 갈래는 Horse in Motion 하나예요. 두 갈래는 주제 표가 수학 쪽으로 바뀌기 전에 열었어요. 그 뒤로 ROUND.md 는 사물로 묶는 갈래를 더 열지 않아요. 26판이 연 얼음·극지 갈래는 Iceberg 와 27판의 Sled Dogs 이고, 미생물 갈래는 Dark Field 와 27판의 Mitosis 예요. 25판이 연 농사·밭 갈래는 Rice Terraces 와 26판의 Rice Planting, 27판의 Center Pivot 이고, 화산 갈래는 Eruption 과 26판의 Geyser, 27판의 Lava Lake 예요. 24판이 연 공사·건설 갈래는 Tower Crane 과 25판의 Excavation, 26판의 Implosion 이에요. 24판이 연 도자기 갈래는 Potter's Wheel 과 25판의 Kintsugi, 26판의 Noborigama 예요. 23판이 연 무대·공연 갈래는 Proscenium 과 24판의 Flying Trapeze, 25판의 Marionette, 26판의 Shadow Play 예요. 23판이 연 짐승 갈래는 Giraffe 와 24판의 Emergence, 25판의 Snow Monkeys 예요. 22판이 연 몸 갈래는 Circulation 과 23판의 Axon, 24판의 Breath, 27판의 Fluoroscope 예요. 22판이 연 비행 갈래는 Liftoff 와 23판의 Final Approach, 24판의 Thermal, 25판의 Skydiver 예요. 20판이 연 새 갈래는 Kingfisher 와 21판의 Woodpecker, 22판의 Weaver, 23판의 Skein 이에요. 20판이 연 화학·실험 갈래는 Chromatography 와 21판의 Chemical Garden, 22판의 Flame Test, 23판의 Elephant Toothpaste 예요. 21판이 연 종이 갈래는 Pop-up Book 과 22판의 Senbazuru, 23판의 Hanging Scroll, 26판의 Origami 예요. 21판이 연 운동·경기 갈래는 Lap Pool 과 22판의 Bowling Lane, 23판의 High Dive, 26판의 Pole Vault, 27판의 Climbing Wall 이에요. 위아래로 움직이는 경기는 High Dive 와 Pole Vault 뒤로 27판에 실내 암벽이 섰어요. 19판이 연 부엌 갈래는 Popcorn 과 20판의 Kettle, 21판의 Pancakes 이고, 버섯·균사 갈래는 Foxfire 와 20판의 Veiled Lady, 21판의 Bread Mould 예요. 18판이 연 유리 갈래는 Stained Glass 와 19판의 Smalti, 20판의 Millefiori, 27판의 Glassblower 예요. 광물·결정 갈래는 Bismuth 와 19판의 Dripstone, 20판의 Agate 이고, 놀이공원 갈래는 Drop Tower 와 19판의 Helter Skelter, 20판의 High Striker, 25판의 Ferris Wheel 이에요. 말이 오르내리는 회전목마는 아직 없어요. 17판이 연 전자 회로 갈래는 Circuit Board 와 18판의 Server Rack, 21판의 Nixie 이고, 장난감 갈래는 Marble Run 과 18판의 Peg Light, 21판의 Slinky, 22판의 Pin Art 예요. 16판이 연 바다 갈래는 Abyss 와 17판의 Shoreline, 20판의 Sunglint, 23판의 Bait Ball 이고, 곤충 갈래는 Fireflies 와 17판의 Ant Farm, 20판의 Moth Lamp, 24판의 Waggle Dance 예요. 15판이 연 도시 갈래는 Metro Map 과 16판의 Neon Alley, 17판의 Crossroads, 22판의 Night Flight 예요. 15판이 연 음악 갈래는 Player Piano 와 16판의 Harp, 18판의 Turntables, 24판의 Pipe Organ 이에요. 4판이 연 직물 갈래는 Jacquard Loom 과 15판의 Plait, 19판의 Needlepoint, 23판의 Sequins 이고, 8판이 연 기계 갈래는 Gear Train 과 15판의 Cam Wave, 19판의 Paternoster 예요. 12판이 연 천체 갈래는 Star Trails 와 15판의 Analemma, 16판의 Lunation, 22판의 Galilean Moons 예요. 위성의 궤도는 Galilean Moons 가 그렸고, 해를 도는 행성은 아직 없어요. 리듬·펄스 갈래는 1판의 Euclid Pulse 와 Pulse Bars 뒤로 20판의 Change Ringing, 32판의 Arnold Tongues, 35판의 Chimera State, 38판의 Infinity Series, 41판의 Siteswap, 44판의 Kac Ring, 46판의 Stochastic Resonance 가 섰어요.
@@ -4106,9 +4187,11 @@ Flock, Harmonograph, Big Type 은 처음 화면이 빨강이에요.
 
 69판에서는 Letter Melt 와 Langford Pairs 가 128줄을 써요. Letter Melt 는 낱말이 위 3분의 1에 서고 웅덩이가 바닥에 고이며 그 사이를 방울과 실줄기만 지나가서 thirds 가 27/12/40 이에요. 가운데가 엷은 것은 녹는 2.4초와 붓는 2.9초 동안만 물이 그 자리를 지나서예요. Langford Pairs 는 오른쪽 탑이 128줄을 다 쓰고 왼쪽 선반의 탑도 같은 높이라 39/39/35 예요. 글자 다섯 가운데 Boustrophedon 은 고랑 스무 줄이 밭을 늘 채워 88/91/89 이고, Nine-fold Seal 은 종이를 LED 마다 켜 두어 100/100/100 이에요. Steiner Symmetrization 은 모양이 가운데로 모여 둥글어지니 11/71/14 로 위아래가 가장 엷어요.
 
+70판에서는 Eight Principles of Yong 과 Granular Leidenfrost 가 128줄을 써요. Eight Principles of Yong 은 永 이 4째 줄에서 116째 줄까지 서고 쪽빛 종이까지 켜져서 thirds 가 99/99/99 예요. 종이를 검게 두고 먹과 이름만 재면 20.8/28.6/22.7 이에요. Granular Leidenfrost 는 지름 2.5 LED 알 300개일 때 뜬 덩어리와 그 아래 기체가 다 바닥 48줄 안에 들어가 위 80줄이 비었어요. 알을 지름 4 LED 로 키워 상자를 32알 높이로 줄이자 같은 상태가 패널 높이를 다 써서 32/84/75 가 됐어요. 나머지 여덟 가운데 Quousque Tandem 은 글줄이 패널을 다 채워 91/92/96 이고, Laguerre Cells 와 Hellschreiber 는 바탕이 다 켜져 100/100/100 이에요. Frenkel-Kontorova 는 위 113줄의 시공간 기록이 49/49/49 이고, Hexachordal Theorem 은 위아래 고리와 가운데 막대가 17/24/18 이에요.
+
 ### 낯선 수학
 
-주제 5 로 쓴 수학과 다음에 해 볼 수학이에요. 28판이 처음 열 개를 썼어요. 슈람-뢰브너 진화(Loewner Trace), 포드 원(Ford Circles), 털 난 공 정리(Hairy Ball), 아즈텍 다이아몬드와 북극권(Aztec Diamond), 부니모비치 경기장(Stadium Billiard), 라우지 프랙탈(Rauzy Fractal), 고셋의 4₂₁ 다면체와 E8(Gosset Polytope), 콘웨이의 보고 말하기 수열(Look and Say), 위토프 게임의 그런디 값(Wythoff Nim), 쌍곡 평면의 띠 모형(Hyperbolic Band)이에요. 29판은 여섯을 더했어요. 클라인의 j 불변량(J-Invariant), 호프 올뭉치(Hopf Fibration), 다이슨 브라운 운동(Dyson Gas), 가케야 바늘 문제의 페론 나무(Perron Tree), 임계선 위의 리만 제타 함수(Zeta Loops), 길버트-섀넌-리즈 리플과 베이어-디아코니스의 일곱 번(Seven Shuffles)이에요. 30판도 여섯을 더했어요. 세 간격 정리(Three Gaps), 호프스태터 나비와 TKNN 정수(Hofstadter Butterfly), 노이만의 외부 당구(Outer Billiards), 볼드의 탄도 퇴적과 KPZ 앞면(Ballistic Deposition), 아르놀트의 미앤더(Meander), 브로드벤트와 해머슬리의 스미기(Percolation)예요. 31판도 여섯을 더했어요. 마스킷 조각의 클라인 군 극한 집합(Indra's Pearls), 리틀우드 다항식의 근(Littlewood Roots), 고든의 가우스 해자(Gaussian Moat), 아르놀트의 고양이 사상(Cat Map), 자부스키와 크루스칼의 KdV 솔리톤(KdV Solitons), 보이 곡면(Boy's Surface)이에요. ROUND.md 의 「낯선 수학 예」 여덟 가운데 쓴 것은 슈람-뢰브너 진화와 아즈텍 다이아몬드, 모듈러 형식, 호프 올뭉치, 세 간격 정리, 외부 당구 여섯이었고, 31판이 리틀우드 다항식의 근과 클라인 군의 극한 집합을 써서 여덟을 다 썼어요. 32판도 여섯을 더했어요. 탤벗 효과와 양자 카펫(Talbot Carpet), 길브레스 추측의 표(Gilbreath Table), 원 사상의 아르놀트 혀(Arnold Tongues), 콘웨이와 라딘의 핀휠 타일링(Pinwheel Tiling), 윌킨슨과 윌렘센의 침입 스미기(Invasion Percolation), 울람의 문제와 해머슬리 과정(Hammersley Lines)이에요. 33판도 여섯을 더했어요. 에인절, 홀로이드, 로믹, 비라그의 무작위 정렬 네트워크(Sorting Network), 베르트랑의 역설(Bertrand Paradox), 펜로즈의 비출 수 없는 방(Penrose Room), 당들랭 구(Dandelin Spheres), 테이트의 보로메오 고리(Borromean Rings), 골드바흐 혜성(Goldbach Comet)이에요. 34판도 여섯을 더했어요. 톰슨 문제와 오일러가 남기는 다섯 이웃 열둘(Thomson Problem), 켈빈의 배 물결(Kelvin Wake), 요네야마가 낸 와다의 호수(Lakes of Wada), 샤이데거의 강 그물(Scheidegger Rivers), 모저의 소파 문제와 해머슬리의 소파(Moving Sofa), 크누스의 춤추는 링크로 푼 펜토미노 덮기(Pentomino Cover)예요. 35판도 여섯을 더했어요. 뢸로의 폭이 일정한 곡선(Constant Width), 렌니의 주차 문제(Rényi Parking), 카리의 비주기 왕 타일(Kari-Culik Tiles), 콜라코스키 수열(Kolakoski), 쿠라모토와 바톡토흐의 키메라 상태(Chimera State), 주콥스키 날개(Joukowsky Airfoil)예요. 36판도 여섯을 더했어요. 그레이슨의 정리가 말하는 곡선 단축 흐름(Curve Shortening), 헤우드의 일곱 색 토러스 지도(Heawood Torus), 슈바르츠 랜턴(Schwarz Lantern), 윌브러햄과 깁스의 현상(Gibbs Phenomenon), 타원 곡선의 현과 접선(Elliptic Chords), 지먼의 파국 기계(Catastrophe Machine)예요. 37판도 여섯을 더했어요. 포천의 쓸기 선 알고리즘(Fortune's Sweep), 앙투안의 목걸이(Antoine's Necklace), 카르만 소용돌이 길의 안정성(Kármán Street), 단단한 원판의 헥사틱 상(Hexatic Phase), 존슨-멜 쪽매와 아브라미 법칙(Johnson-Mehl), 쿠라모토-시바신스키 방정식(Kuramoto-Sivashinsky)이에요. 38판도 여섯을 더했어요. 앤더슨 국소화(Anderson Localization), 무어가 찾고 Chenciner 와 Montgomery 가 증명한 세 몸 문제의 8자 해(Figure-Eight Orbit), 예센과 빈트너, 에르되시의 베르누이 합성곱(Bernoulli Convolutions), 브라우어르의 고정점 정리를 증명하는 슈페르너 보조정리(Sperner's Lemma), 에겐베르거와 폴리아의 항아리(Pólya Urn), 뇌르고르의 무한 수열(Infinity Series)이에요. 39판도 여섯을 더했어요. 고든, 웹, 월퍼트의 등스펙트럼 북(Isospectral Drums), 폰 망골트의 꼴로 쓴 리만의 명시 공식(Explicit Formula), 요한 베르누이의 최단 강하선(Brachistochrone), 슈타이너의 포리즘(Steiner Chain), 모런 집단으로 그린 킹먼의 합류(Kingman Coalescent), 보르수크-울람 정리(Borsuk-Ulam)예요. 40판도 여섯을 더했어요. 앨더스의 브라운 연속 랜덤 나무(Continuum Random Tree), 슈뢰딩거의 수소 원자 고유 함수(Hydrogen Orbital), 젤도비치 근사의 팬케이크(Zeldovich Pancakes), 망델브로가 내다보고 롤러, 슈람, 베르너가 증명한 브라운 운동의 바깥 경계(Brownian Frontier), 복소 긴즈부르크-란다우 방정식의 결함 난류(Defect Turbulence), 루퍼트 왕자의 정육면체(Prince Rupert's Cube)예요. 41판은 다섯을 더했어요. 홀과 왜건의 현수선 길과 정다각형 바퀴(Square Wheels), 퐁슬레의 포리즘(Poncelet Porism), 슐레플리의 4차원 정다포체를 자른 단면(Polytope Slices), 클림켁과 티먼, 마그누손의 사이트스왑(Siteswap), Dudeney 의 잡화상 퍼즐과 월리스-보여이-게르비엔 정리(Hinged Dissection)예요. 42판은 다섯을 더했어요. 바른스도르프 규칙으로 도는 기사 여행(Knight's Tour), 페르미와 파스타, 울람, 칭구의 되돌아옴(FPUT Recurrence), 포슬리에-립킨 반전기(Peaucellier Linkage), 몰리의 삼등분선 정리(Morley Triangle), 랄과 마드라스, 소칼의 피벗 알고리즘으로 돌린 자기 회피 걸음(Pivot Walk)이에요. 43판은 다섯을 더했어요. 월리스 워커의 칼레이도사이클(Kaleidocycle), 쌍곡형에서 록소드롬형으로 감기는 뫼비우스 변환의 흐름(Möbius Loxodrome), 터트의 용수철 정리(Tutte Embedding), 디펀트와 크래비츠의 고리 정리를 품은 히토메자시 사시코(Hitomezashi), 룽게 현상과 체비쇼프 점(Runge Phenomenon)이에요. 44판은 다섯을 더했어요. 마크 카츠의 고리 모형(Kac Ring), 스톤과 튜키의 햄 샌드위치 정리(Ham Sandwich), 브란트의 불가리아 솔리테어(Bulgarian Solitaire), 엘스켄스와 프리시의 탄도 소멸(Ballistic Annihilation), 페레그린의 솔리톤(Peregrine Soliton)이에요. 45판은 다섯을 더했어요. 로건-셰프와 베르시크-케로프의 극한 곡선으로 다가가는 영 도형의 플랑셰렐 성장(Plancherel Growth), 도브루신 경계 조건을 건 임계 이징 모형의 SLE(3) 경계(Ising Interface), 프리예제프와 동료들의 오일러 걷개로 쌓는 로터 라우터 응집과 레빈-페레스의 스매시 합(Rotor-Router), 폴리아의 과수원 문제(Pólya's Orchard), 넬슨의 평면 색칠 문제와 아이즈벨의 일곱 색(Hadwiger-Nelson)이에요. 46판은 다섯을 더했어요. 브릴루앙의 구역(Brillouin Zones), 모스 이론과 레브의 그래프(Reeb Graph), 로렌츠 기체와 시나이의 당구(Lorentz Gas), 리언 글래스의 점무늬(Glass Patterns), 벤치와 수테라, 불피아니의 확률 공명(Stochastic Resonance)이에요. 47판은 다섯을 더했어요. 오키프와 홍, 스트로가츠의 스워멀레이터(Swarmalators), 빌스의 외로운 달리기 선수 추측(Lonely Runner), 샤츠의 올로이드와 그 전개도(Oloid), 쾨베의 원 채우기 정리와 콜린스-스티븐슨의 반복(Koebe Packing), 콘웨이의 병사와 황금비 무게(Conway's Soldiers)예요. 48판은 다섯을 더했어요. 오하라의 매듭 뫼비우스 에너지(Möbius Energy), 체비쇼프의 편향과 루빈스타인-사르낙의 밀도(Chebyshev's Bias), 섀든과 레키엔, 마스든의 이중 소용돌이 능선(Double Gyre), 아자리와 프로스트의 깜빡이는 래칫(Flashing Ratchet), 망델브로의 프랙탈 스미기(Fractal Percolation)예요. 49판은 다섯을 더했어요. 뒤러의 전개 문제와 셰퍼드의 추측(Dürer's Unfolding), 베리와 골드버그가 재규격화한 세타 합의 꼬부랑 곡선(Curlicue), 오일러 방정식과 푸앵소의 폴호드로 본 테니스 라켓 정리(Tennis Racket), 켐프의 사슬과 네 색 정리(Kempe Chains), 퇴플리츠의 내접 정사각형 문제와 그린-로브의 직사각형(Square Peg)이에요. 50판은 다섯을 더했어요. 크레이치넌과 배철러의 2차원 난류가 거꾸로 가는 캐스케이드와 맥윌리엄스의 소용돌이(Inverse Cascade), 사포발과 로소, 구예의 확산 앞줄(Diffusion Front), 필리와 마르케티, 케이츠와 타이외르의 운동성 상분리(Motility Clusters), 박과 스네펜의 진화 모형(Bak-Sneppen), 리세의 영원한 가속(Risset Rhythm)이에요. 51판은 다섯을 더했어요. 스미스와 마이어스, 캐플런, 굿먼-스트라우스의 모자 타일과 H/T/P/F 메타타일 치환(Hat Monotile), 반도와 동료들의 최적 속도 모형과 스기야마의 원형 트랙 실험(Phantom Jam), 사토와 테이트의 법칙과 타원곡선의 a_p(Sato-Tate), 칼라비와 야우의 공간에서 핸슨이 잘라 그린 5차 페르마 곡선(Calabi-Yau Quintic), 에델스브루너와 레처, 조모로디언의 지속 호몰로지와 바코드(Persistence Barcode)예요. 52판은 다섯을 더했어요. 슈람과 셰필드가 등고선을 SLE(4) 로 보인 2차원 가우스 자유장(Gaussian Free Field), 당튀와 마즈무다르, 베링거의 광탄성 힘 사슬(Force Chains), 앤스컴의 사중주와 마테이카, 피츠모리스의 같은 통계 담금질(Anscombe's Quartet), 드 브라윈 수열과 BEST 정리(de Bruijn Sequence), 라인스의 베타 평면 띠 제트(Zonal Jets)예요. 53판은 열을 더했어요. 듀크, 가르시아, 루츠가 그린 가우스 주기(Gaussian Periods), 부르가 보인 현수면과 나선면의 휨(Catenoid-Helicoid), 디랙의 벨트 묘기(Belt Trick), 헬름홀츠와 러브의 연기 고리 개구리뜀(Leapfrogging Vortices), 브룩스, 스미스, 스톤, 텃의 정사각형 분할(Squared Rectangle), 포드와 풀커슨의 최대 흐름 최소 절단(Max-Flow Min-Cut), 코스타스 배열(Costas Array), 바라니, 비어든, 칸의 무게중심 분할(Barycentric Subdivision), 무코파디아야와 크네저의 네 꼭짓점 정리(Four-Vertex Theorem), 오일러의 엘라스티카(Euler's Elastica)예요. 54판은 열을 더했어요. 베리의 무작위 파동과 보고몰니, 슈미트가 스미기로 센 마디 영역(Nodal Domains), 피어험버트가 사인 흐름에서 찾은 이상 고유 모드(Strange Eigenmode), 피어시 적분과 베리, 업스틸의 첨점 회절 파국(Pearcey Cusp), 나겔과 바이스의 STIT 모자이크(STIT Tessellation), 레비의 아크사인 법칙(Arcsine Law), 스퇴르메르가 다룬 쌍극자 장 속 대전 입자(Størmer Trap), 게일과 섀플리의 지연 수락(Stable Marriage), 스메일의 말굽(Smale Horseshoe), 울람 수열과 슈타이너베르거가 찾은 숨은 진동수(Ulam Sequence), 위어와 펠런의 거품과 켈빈의 깎은 팔면체(Weaire-Phelan)예요. 55판은 열을 더했어요. 밀러와 셰필드의 허수 기하(Imaginary Geometry), 티소의 지시 타원과 메르카토르 투영(Tissot's Indicatrix), 민코프스키의 물음표 함수(Question Mark Function), 버로스와 휠러의 변환(Burrows-Wheeler), 뷔퐁의 바늘과 바르비에의 국수(Buffon's Noodle), 부자의 리듬 타일링 캐넌(Vuza Canon), 하인과 내시의 헥스와 게일의 헥스 정리(Hex Theorem), 8자 고리의 범피복과 자유군의 케일리 그래프(Universal Cover), 오브친니코프와 젤도비치, 투생과 윌첵의 확산 제한 소멸(Toussaint-Wilczek), 헬름홀츠와 켈빈의 와류 시트와 크라스니의 와동 덩이(Vortex Sheet)예요. 56판은 열을 더했어요. 마테롱의 죽은 잎과 켄들, 퇴네스가 아래에서 본 완전 표본(Dead Leaves), 골롬의 트로미노 깔기(Golomb Trominoes), 윌슨의 고리 지운 걸음과 롤러, 슈람, 베르너의 균등 생성나무 페아노 곡선(Tree Peano Curve), 블로흐와 제너의 진동과 워니어의 사다리(Bloch Oscillations), 앤드루스의 곡선과 아시모프의 그랜드 투어(Andrews Curves), 지니브르와 기르코의 원 법칙과 좀머스, 크리산티, 솜폴린스키, 스타인의 타원 법칙(Elliptic Law), 에르되시의 불일치 문제와 보웨인, 최, 쿤스의 3진 수열(Erdős Discrepancy), 망델브로의 곱셈 폭포와 카안, 페이리에르의 문턱(Multiplicative Cascade), 코르테, 체이킨, 골럽, 파인의 무작위 조직화(Random Organization), 칼루가레아누, 화이트, 풀러의 꼬임과 뒤틀림(Twist and Writhe)이에요. 57판도 열을 더했어요. 블룸의 중심축과 들불 변환(Medial Axis), 스메일과 윌리엄스의 솔레노이드(Solenoid), 솔로몬의 무작위 환경 속 걸음과 시나이의 걸음(Sinai's Walk), 테렐과 펜로즈의 회전(Terrell Rotation), 갈페린의 π 당구(Galperin Billiard), 페르마의 두 제곱수 정리와 자기에의 한 문장 증명(Zagier's Windmills), 스토크스 표류와 게르스트너의 트로코이드 파도(Stokes Drift), 라인하르트부터 맨, 매클라우드맨, 폰 데라우까지의 볼록 오각형 타일링(Pentagon Tilings), 페로와 하위헌스의 트랙트릭스와 자전거 바퀴 자국(Bicycle Tracks), 오스트발트 숙성과 LSW 이론(Ostwald Ripening)이에요. 58판도 열을 더했어요. 야블란과 게르데스의 거울 곡선(Mirror Curves), 가운트와 피셔, 백스터의 딱딱한 정사각형 격자 기체(Hard Squares), 다니엘 베르누이의 매달린 사슬과 베셀 함수 J0(Hanging Chain), 레일리와 테일러의 불안정성(Rayleigh-Taylor), 터키의 반평면 깊이와 라도의 중심점 정리(Tukey Depth), 롤러와 베르너의 브라운 고리 수프(Loop Soup), 카돔체프-페트비아시빌리 방정식과 코다마의 선 솔리톤 웹(KP Web), 크누스가 이름 붙인 베케트-그레이 코드(Beckett-Gray), 파스칼의 신비 육각형과 슈타이너, 커크먼의 점(Hexagrammum Mysticum), 드 스밋과 렌스트라의 판화 화랑 사상(Print Gallery)이에요. 59판도 열을 더했어요. 르장드르와 가우스의 이차 상호 법칙(Quadratic Reciprocity), 위그너 함수와 유르케, 스톨러의 켜 고양이(Wigner Cat), 아비단과 샤미르의 심 카빙(Seam Carving), 슐리히팅과 노르트마르크, 에거스의 알갱이 기체 속 맥스웰의 도깨비(Granular Demon), 클렙시의 대각 3차 곡면과 케일리, 새먼의 직선 27개(Clebsch Surface), 보데르베르크의 나선 타일링(Voderberg Tiling), 자이페르트의 곡면(Seifert Surface), 호크스의 자기 흥분 점과정(Hawkes Process), 코호넨의 자기조직 지도(Kohonen Map), 레일리의 위상자 걸음과 굿맨의 스페클 통계(Laser Speckle)예요. 60판도 열을 더했어요. 마살리아가 짚은 RANDU 의 평면(RANDU Planes), 오일러의 36 장교와 보스, 슈리칸데, 파커의 10차 그레코-라틴 방진(Euler's Officers), 펜로즈와 카터의 등각 콤팩트화 도형(Penrose Diagram), 러더퍼드 산란의 포물선 그림자(Rutherford Shadow), 오일러 나선과 프레넬 적분, 코르뉴의 회절 셈(Cornu Spiral), 리처드슨의 디바이더와 망델브로의 해안선 차원(Richardson Dividers), 에농, 홀, 페익스의 1차원 자기중력 면 모형과 린든-벨의 격렬한 이완(Phase Spiral), 에르되시와 레니의 거대 성분과 아클리옵타스, 드수자, 스펜서의 폭발적 스미기(Giant Component), 허프와 두다, 하트의 직선 찾기(Hough Transform), 조르당의 곡선 정리와 심랏의 교차 세기(Jordan Curve)예요. 61판도 열을 더했어요. 세스나와 다섯 사람의 영온 무작위장 이징 눈사태(Crackling Noise), 몽주의 흙 옮기기와 매캔의 옮김 보간(Monge Transport), 파울의 덫과 마티외 방정식(Paul Trap), 그린힐의 제 무게 기둥(Greenhill Column), 흐바탈의 미술관 정리와 피스크의 세 색 증명(Art Gallery), 홀디치의 고리(Holditch Ring), 톰슨의 꺾인 역선과 헤비사이드의 움직이는 전하(Thomson Kink), 슈나이더와 바이스의 쌍성 렌즈(Binary Lens), 테일러의 되섞기(Taylor Unmixing), 브누아, 칼로, 디에네르 부부의 카나르 폭발(Canard Explosion)이에요. 62판도 열을 더했어요. 아브리코소프와 클라이너, 로스, 오틀러의 소용돌이 격자(Abrikosov Lattice), 울리크니의 청색 잡음과 빈자리와 뭉치 방법(Void and Cluster), 파인먼과 힙스의 체커보드(Feynman Checkerboard), 라도의 바쁜 비버와 마크센, 분트로크의 다섯 상태 챔피언(Busy Beaver), 폭스와 커시너, 비치의 평평한 곡면 위 직선 흐름(Veech Octagon), 리만의 미분 불가능 함수와 거버, 다위스테르마트의 복소 곡선(Riemann's Function), 헤슈와 킨즐레의 한 타일 형(Heesch Tiles), 차크라보르티와 헤이스, 보고시안의 마당 장터 모형(Yard-Sale Model), 베르그렌의 피타고라스 세 수 나무(Berggren Tree), 더브라윈과 람, 렁의 단위근 합과 밀른의 완전히 균형 잡힌 리듬(Balanced Rhythms)이에요. 63판은 다섯을 더했어요. 모팻의 모서리 소용돌이와 다네다의 사진(Moffatt Eddies), 맥스웰의 물고기 눈 렌즈(Maxwell's Fish-Eye), 이지케비치의 스파이크 신경망(Izhikevich Network), 애들러와 하소퍼, 우슬리의 들뜸 집합 오일러 지표(Excursion Sets), 심슨과 블라이스의 역설(Simpson's Paradox)이에요. 64판은 다섯을 더했어요. 암만과 베인커르의 팔각 타일링을 더 브라윈의 다중 격자로 지은 것(Ammann-Beenker), 겔판트, 카프라노프, 젤레빈스키의 아메바와 포르스베리, 파사레, 치흐의 구멍(Polynomial Amoeba), 키블과 주렉의 결함 얼기와 피시먼, 데 키아라, 칼라르코, 모리지의 지그재그 전이(Kibble-Zurek Ions), 야코비의 적분과 힐의 영속도 곡선(Hill's Regions), 스티븐슨과 카피차의 거꾸로 선 진자와 아치슨, 멀린의 인도 밧줄 묘기(Indian Rope Trick)예요. 65판은 다섯을 더했어요. 폰 노이만과 멀린스의 거품 법칙(Foam Coarsening), 베드퍼드와 맥멀런의 자기 아핀 카펫(McMullen Carpet), 클라인의 돛과 라그랑주의 주기 연분수(Klein's Sails), 야코비의 측지선과 샬의 공초점 곡면(Jacobi Geodesics), 하다마르와 리브친스키의 물방울과 코르테스의 정규화 스토크슬렛(Sedimenting Cloud)이에요. 67판은 다섯을 더했어요. 라돈의 변환과 라마찬드란, 락슈미나라야난의 램프 필터(Radon Transform), 아르틴의 브레이드 군과 폭스, 노이워스의 배치 공간(Artin Braids), 월시의 함수계와 실베스터의 행렬, 페일리의 차례(Walsh Functions), 아레프의 깜박이는 소용돌이(Blinking Vortex), 뒤팽의 사이클라이드(Dupin Cyclide)예요. 68판은 다섯을 더했어요. 들로네의 빈 외접원과 로슨의 뒤집기(Delaunay Flips), 모네로-뒤멘의 피보나치 단어 프랙탈(Fibonacci Word), 로즈의 검출 기준(Rose Criterion), 요세푸스 문제와 바셰의 셈 놀이(Josephus Problem), 레비치비타의 평행 이동과 푸코의 진자(Parallel Transport)예요. 69판은 다섯을 더했어요. 랭퍼드의 짝과 데이비스의 존재 조건, 스콜렘의 수열(Langford Pairs), 아하로노프와 봄의 효과와 베리 등의 파면 전위(Aharonov-Bohm), 페니의 놀이와 콘웨이의 선행수(Penney's Game), 휘트니와 그라우스타인의 회전수 정리(Whitney-Graustein), 슈타이너의 대칭화와 그로스의 수렴(Steiner Symmetrization)이에요.
+주제 5 로 쓴 수학과 다음에 해 볼 수학이에요. 28판이 처음 열 개를 썼어요. 슈람-뢰브너 진화(Loewner Trace), 포드 원(Ford Circles), 털 난 공 정리(Hairy Ball), 아즈텍 다이아몬드와 북극권(Aztec Diamond), 부니모비치 경기장(Stadium Billiard), 라우지 프랙탈(Rauzy Fractal), 고셋의 4₂₁ 다면체와 E8(Gosset Polytope), 콘웨이의 보고 말하기 수열(Look and Say), 위토프 게임의 그런디 값(Wythoff Nim), 쌍곡 평면의 띠 모형(Hyperbolic Band)이에요. 29판은 여섯을 더했어요. 클라인의 j 불변량(J-Invariant), 호프 올뭉치(Hopf Fibration), 다이슨 브라운 운동(Dyson Gas), 가케야 바늘 문제의 페론 나무(Perron Tree), 임계선 위의 리만 제타 함수(Zeta Loops), 길버트-섀넌-리즈 리플과 베이어-디아코니스의 일곱 번(Seven Shuffles)이에요. 30판도 여섯을 더했어요. 세 간격 정리(Three Gaps), 호프스태터 나비와 TKNN 정수(Hofstadter Butterfly), 노이만의 외부 당구(Outer Billiards), 볼드의 탄도 퇴적과 KPZ 앞면(Ballistic Deposition), 아르놀트의 미앤더(Meander), 브로드벤트와 해머슬리의 스미기(Percolation)예요. 31판도 여섯을 더했어요. 마스킷 조각의 클라인 군 극한 집합(Indra's Pearls), 리틀우드 다항식의 근(Littlewood Roots), 고든의 가우스 해자(Gaussian Moat), 아르놀트의 고양이 사상(Cat Map), 자부스키와 크루스칼의 KdV 솔리톤(KdV Solitons), 보이 곡면(Boy's Surface)이에요. ROUND.md 의 「낯선 수학 예」 여덟 가운데 쓴 것은 슈람-뢰브너 진화와 아즈텍 다이아몬드, 모듈러 형식, 호프 올뭉치, 세 간격 정리, 외부 당구 여섯이었고, 31판이 리틀우드 다항식의 근과 클라인 군의 극한 집합을 써서 여덟을 다 썼어요. 32판도 여섯을 더했어요. 탤벗 효과와 양자 카펫(Talbot Carpet), 길브레스 추측의 표(Gilbreath Table), 원 사상의 아르놀트 혀(Arnold Tongues), 콘웨이와 라딘의 핀휠 타일링(Pinwheel Tiling), 윌킨슨과 윌렘센의 침입 스미기(Invasion Percolation), 울람의 문제와 해머슬리 과정(Hammersley Lines)이에요. 33판도 여섯을 더했어요. 에인절, 홀로이드, 로믹, 비라그의 무작위 정렬 네트워크(Sorting Network), 베르트랑의 역설(Bertrand Paradox), 펜로즈의 비출 수 없는 방(Penrose Room), 당들랭 구(Dandelin Spheres), 테이트의 보로메오 고리(Borromean Rings), 골드바흐 혜성(Goldbach Comet)이에요. 34판도 여섯을 더했어요. 톰슨 문제와 오일러가 남기는 다섯 이웃 열둘(Thomson Problem), 켈빈의 배 물결(Kelvin Wake), 요네야마가 낸 와다의 호수(Lakes of Wada), 샤이데거의 강 그물(Scheidegger Rivers), 모저의 소파 문제와 해머슬리의 소파(Moving Sofa), 크누스의 춤추는 링크로 푼 펜토미노 덮기(Pentomino Cover)예요. 35판도 여섯을 더했어요. 뢸로의 폭이 일정한 곡선(Constant Width), 렌니의 주차 문제(Rényi Parking), 카리의 비주기 왕 타일(Kari-Culik Tiles), 콜라코스키 수열(Kolakoski), 쿠라모토와 바톡토흐의 키메라 상태(Chimera State), 주콥스키 날개(Joukowsky Airfoil)예요. 36판도 여섯을 더했어요. 그레이슨의 정리가 말하는 곡선 단축 흐름(Curve Shortening), 헤우드의 일곱 색 토러스 지도(Heawood Torus), 슈바르츠 랜턴(Schwarz Lantern), 윌브러햄과 깁스의 현상(Gibbs Phenomenon), 타원 곡선의 현과 접선(Elliptic Chords), 지먼의 파국 기계(Catastrophe Machine)예요. 37판도 여섯을 더했어요. 포천의 쓸기 선 알고리즘(Fortune's Sweep), 앙투안의 목걸이(Antoine's Necklace), 카르만 소용돌이 길의 안정성(Kármán Street), 단단한 원판의 헥사틱 상(Hexatic Phase), 존슨-멜 쪽매와 아브라미 법칙(Johnson-Mehl), 쿠라모토-시바신스키 방정식(Kuramoto-Sivashinsky)이에요. 38판도 여섯을 더했어요. 앤더슨 국소화(Anderson Localization), 무어가 찾고 Chenciner 와 Montgomery 가 증명한 세 몸 문제의 8자 해(Figure-Eight Orbit), 예센과 빈트너, 에르되시의 베르누이 합성곱(Bernoulli Convolutions), 브라우어르의 고정점 정리를 증명하는 슈페르너 보조정리(Sperner's Lemma), 에겐베르거와 폴리아의 항아리(Pólya Urn), 뇌르고르의 무한 수열(Infinity Series)이에요. 39판도 여섯을 더했어요. 고든, 웹, 월퍼트의 등스펙트럼 북(Isospectral Drums), 폰 망골트의 꼴로 쓴 리만의 명시 공식(Explicit Formula), 요한 베르누이의 최단 강하선(Brachistochrone), 슈타이너의 포리즘(Steiner Chain), 모런 집단으로 그린 킹먼의 합류(Kingman Coalescent), 보르수크-울람 정리(Borsuk-Ulam)예요. 40판도 여섯을 더했어요. 앨더스의 브라운 연속 랜덤 나무(Continuum Random Tree), 슈뢰딩거의 수소 원자 고유 함수(Hydrogen Orbital), 젤도비치 근사의 팬케이크(Zeldovich Pancakes), 망델브로가 내다보고 롤러, 슈람, 베르너가 증명한 브라운 운동의 바깥 경계(Brownian Frontier), 복소 긴즈부르크-란다우 방정식의 결함 난류(Defect Turbulence), 루퍼트 왕자의 정육면체(Prince Rupert's Cube)예요. 41판은 다섯을 더했어요. 홀과 왜건의 현수선 길과 정다각형 바퀴(Square Wheels), 퐁슬레의 포리즘(Poncelet Porism), 슐레플리의 4차원 정다포체를 자른 단면(Polytope Slices), 클림켁과 티먼, 마그누손의 사이트스왑(Siteswap), Dudeney 의 잡화상 퍼즐과 월리스-보여이-게르비엔 정리(Hinged Dissection)예요. 42판은 다섯을 더했어요. 바른스도르프 규칙으로 도는 기사 여행(Knight's Tour), 페르미와 파스타, 울람, 칭구의 되돌아옴(FPUT Recurrence), 포슬리에-립킨 반전기(Peaucellier Linkage), 몰리의 삼등분선 정리(Morley Triangle), 랄과 마드라스, 소칼의 피벗 알고리즘으로 돌린 자기 회피 걸음(Pivot Walk)이에요. 43판은 다섯을 더했어요. 월리스 워커의 칼레이도사이클(Kaleidocycle), 쌍곡형에서 록소드롬형으로 감기는 뫼비우스 변환의 흐름(Möbius Loxodrome), 터트의 용수철 정리(Tutte Embedding), 디펀트와 크래비츠의 고리 정리를 품은 히토메자시 사시코(Hitomezashi), 룽게 현상과 체비쇼프 점(Runge Phenomenon)이에요. 44판은 다섯을 더했어요. 마크 카츠의 고리 모형(Kac Ring), 스톤과 튜키의 햄 샌드위치 정리(Ham Sandwich), 브란트의 불가리아 솔리테어(Bulgarian Solitaire), 엘스켄스와 프리시의 탄도 소멸(Ballistic Annihilation), 페레그린의 솔리톤(Peregrine Soliton)이에요. 45판은 다섯을 더했어요. 로건-셰프와 베르시크-케로프의 극한 곡선으로 다가가는 영 도형의 플랑셰렐 성장(Plancherel Growth), 도브루신 경계 조건을 건 임계 이징 모형의 SLE(3) 경계(Ising Interface), 프리예제프와 동료들의 오일러 걷개로 쌓는 로터 라우터 응집과 레빈-페레스의 스매시 합(Rotor-Router), 폴리아의 과수원 문제(Pólya's Orchard), 넬슨의 평면 색칠 문제와 아이즈벨의 일곱 색(Hadwiger-Nelson)이에요. 46판은 다섯을 더했어요. 브릴루앙의 구역(Brillouin Zones), 모스 이론과 레브의 그래프(Reeb Graph), 로렌츠 기체와 시나이의 당구(Lorentz Gas), 리언 글래스의 점무늬(Glass Patterns), 벤치와 수테라, 불피아니의 확률 공명(Stochastic Resonance)이에요. 47판은 다섯을 더했어요. 오키프와 홍, 스트로가츠의 스워멀레이터(Swarmalators), 빌스의 외로운 달리기 선수 추측(Lonely Runner), 샤츠의 올로이드와 그 전개도(Oloid), 쾨베의 원 채우기 정리와 콜린스-스티븐슨의 반복(Koebe Packing), 콘웨이의 병사와 황금비 무게(Conway's Soldiers)예요. 48판은 다섯을 더했어요. 오하라의 매듭 뫼비우스 에너지(Möbius Energy), 체비쇼프의 편향과 루빈스타인-사르낙의 밀도(Chebyshev's Bias), 섀든과 레키엔, 마스든의 이중 소용돌이 능선(Double Gyre), 아자리와 프로스트의 깜빡이는 래칫(Flashing Ratchet), 망델브로의 프랙탈 스미기(Fractal Percolation)예요. 49판은 다섯을 더했어요. 뒤러의 전개 문제와 셰퍼드의 추측(Dürer's Unfolding), 베리와 골드버그가 재규격화한 세타 합의 꼬부랑 곡선(Curlicue), 오일러 방정식과 푸앵소의 폴호드로 본 테니스 라켓 정리(Tennis Racket), 켐프의 사슬과 네 색 정리(Kempe Chains), 퇴플리츠의 내접 정사각형 문제와 그린-로브의 직사각형(Square Peg)이에요. 50판은 다섯을 더했어요. 크레이치넌과 배철러의 2차원 난류가 거꾸로 가는 캐스케이드와 맥윌리엄스의 소용돌이(Inverse Cascade), 사포발과 로소, 구예의 확산 앞줄(Diffusion Front), 필리와 마르케티, 케이츠와 타이외르의 운동성 상분리(Motility Clusters), 박과 스네펜의 진화 모형(Bak-Sneppen), 리세의 영원한 가속(Risset Rhythm)이에요. 51판은 다섯을 더했어요. 스미스와 마이어스, 캐플런, 굿먼-스트라우스의 모자 타일과 H/T/P/F 메타타일 치환(Hat Monotile), 반도와 동료들의 최적 속도 모형과 스기야마의 원형 트랙 실험(Phantom Jam), 사토와 테이트의 법칙과 타원곡선의 a_p(Sato-Tate), 칼라비와 야우의 공간에서 핸슨이 잘라 그린 5차 페르마 곡선(Calabi-Yau Quintic), 에델스브루너와 레처, 조모로디언의 지속 호몰로지와 바코드(Persistence Barcode)예요. 52판은 다섯을 더했어요. 슈람과 셰필드가 등고선을 SLE(4) 로 보인 2차원 가우스 자유장(Gaussian Free Field), 당튀와 마즈무다르, 베링거의 광탄성 힘 사슬(Force Chains), 앤스컴의 사중주와 마테이카, 피츠모리스의 같은 통계 담금질(Anscombe's Quartet), 드 브라윈 수열과 BEST 정리(de Bruijn Sequence), 라인스의 베타 평면 띠 제트(Zonal Jets)예요. 53판은 열을 더했어요. 듀크, 가르시아, 루츠가 그린 가우스 주기(Gaussian Periods), 부르가 보인 현수면과 나선면의 휨(Catenoid-Helicoid), 디랙의 벨트 묘기(Belt Trick), 헬름홀츠와 러브의 연기 고리 개구리뜀(Leapfrogging Vortices), 브룩스, 스미스, 스톤, 텃의 정사각형 분할(Squared Rectangle), 포드와 풀커슨의 최대 흐름 최소 절단(Max-Flow Min-Cut), 코스타스 배열(Costas Array), 바라니, 비어든, 칸의 무게중심 분할(Barycentric Subdivision), 무코파디아야와 크네저의 네 꼭짓점 정리(Four-Vertex Theorem), 오일러의 엘라스티카(Euler's Elastica)예요. 54판은 열을 더했어요. 베리의 무작위 파동과 보고몰니, 슈미트가 스미기로 센 마디 영역(Nodal Domains), 피어험버트가 사인 흐름에서 찾은 이상 고유 모드(Strange Eigenmode), 피어시 적분과 베리, 업스틸의 첨점 회절 파국(Pearcey Cusp), 나겔과 바이스의 STIT 모자이크(STIT Tessellation), 레비의 아크사인 법칙(Arcsine Law), 스퇴르메르가 다룬 쌍극자 장 속 대전 입자(Størmer Trap), 게일과 섀플리의 지연 수락(Stable Marriage), 스메일의 말굽(Smale Horseshoe), 울람 수열과 슈타이너베르거가 찾은 숨은 진동수(Ulam Sequence), 위어와 펠런의 거품과 켈빈의 깎은 팔면체(Weaire-Phelan)예요. 55판은 열을 더했어요. 밀러와 셰필드의 허수 기하(Imaginary Geometry), 티소의 지시 타원과 메르카토르 투영(Tissot's Indicatrix), 민코프스키의 물음표 함수(Question Mark Function), 버로스와 휠러의 변환(Burrows-Wheeler), 뷔퐁의 바늘과 바르비에의 국수(Buffon's Noodle), 부자의 리듬 타일링 캐넌(Vuza Canon), 하인과 내시의 헥스와 게일의 헥스 정리(Hex Theorem), 8자 고리의 범피복과 자유군의 케일리 그래프(Universal Cover), 오브친니코프와 젤도비치, 투생과 윌첵의 확산 제한 소멸(Toussaint-Wilczek), 헬름홀츠와 켈빈의 와류 시트와 크라스니의 와동 덩이(Vortex Sheet)예요. 56판은 열을 더했어요. 마테롱의 죽은 잎과 켄들, 퇴네스가 아래에서 본 완전 표본(Dead Leaves), 골롬의 트로미노 깔기(Golomb Trominoes), 윌슨의 고리 지운 걸음과 롤러, 슈람, 베르너의 균등 생성나무 페아노 곡선(Tree Peano Curve), 블로흐와 제너의 진동과 워니어의 사다리(Bloch Oscillations), 앤드루스의 곡선과 아시모프의 그랜드 투어(Andrews Curves), 지니브르와 기르코의 원 법칙과 좀머스, 크리산티, 솜폴린스키, 스타인의 타원 법칙(Elliptic Law), 에르되시의 불일치 문제와 보웨인, 최, 쿤스의 3진 수열(Erdős Discrepancy), 망델브로의 곱셈 폭포와 카안, 페이리에르의 문턱(Multiplicative Cascade), 코르테, 체이킨, 골럽, 파인의 무작위 조직화(Random Organization), 칼루가레아누, 화이트, 풀러의 꼬임과 뒤틀림(Twist and Writhe)이에요. 57판도 열을 더했어요. 블룸의 중심축과 들불 변환(Medial Axis), 스메일과 윌리엄스의 솔레노이드(Solenoid), 솔로몬의 무작위 환경 속 걸음과 시나이의 걸음(Sinai's Walk), 테렐과 펜로즈의 회전(Terrell Rotation), 갈페린의 π 당구(Galperin Billiard), 페르마의 두 제곱수 정리와 자기에의 한 문장 증명(Zagier's Windmills), 스토크스 표류와 게르스트너의 트로코이드 파도(Stokes Drift), 라인하르트부터 맨, 매클라우드맨, 폰 데라우까지의 볼록 오각형 타일링(Pentagon Tilings), 페로와 하위헌스의 트랙트릭스와 자전거 바퀴 자국(Bicycle Tracks), 오스트발트 숙성과 LSW 이론(Ostwald Ripening)이에요. 58판도 열을 더했어요. 야블란과 게르데스의 거울 곡선(Mirror Curves), 가운트와 피셔, 백스터의 딱딱한 정사각형 격자 기체(Hard Squares), 다니엘 베르누이의 매달린 사슬과 베셀 함수 J0(Hanging Chain), 레일리와 테일러의 불안정성(Rayleigh-Taylor), 터키의 반평면 깊이와 라도의 중심점 정리(Tukey Depth), 롤러와 베르너의 브라운 고리 수프(Loop Soup), 카돔체프-페트비아시빌리 방정식과 코다마의 선 솔리톤 웹(KP Web), 크누스가 이름 붙인 베케트-그레이 코드(Beckett-Gray), 파스칼의 신비 육각형과 슈타이너, 커크먼의 점(Hexagrammum Mysticum), 드 스밋과 렌스트라의 판화 화랑 사상(Print Gallery)이에요. 59판도 열을 더했어요. 르장드르와 가우스의 이차 상호 법칙(Quadratic Reciprocity), 위그너 함수와 유르케, 스톨러의 켜 고양이(Wigner Cat), 아비단과 샤미르의 심 카빙(Seam Carving), 슐리히팅과 노르트마르크, 에거스의 알갱이 기체 속 맥스웰의 도깨비(Granular Demon), 클렙시의 대각 3차 곡면과 케일리, 새먼의 직선 27개(Clebsch Surface), 보데르베르크의 나선 타일링(Voderberg Tiling), 자이페르트의 곡면(Seifert Surface), 호크스의 자기 흥분 점과정(Hawkes Process), 코호넨의 자기조직 지도(Kohonen Map), 레일리의 위상자 걸음과 굿맨의 스페클 통계(Laser Speckle)예요. 60판도 열을 더했어요. 마살리아가 짚은 RANDU 의 평면(RANDU Planes), 오일러의 36 장교와 보스, 슈리칸데, 파커의 10차 그레코-라틴 방진(Euler's Officers), 펜로즈와 카터의 등각 콤팩트화 도형(Penrose Diagram), 러더퍼드 산란의 포물선 그림자(Rutherford Shadow), 오일러 나선과 프레넬 적분, 코르뉴의 회절 셈(Cornu Spiral), 리처드슨의 디바이더와 망델브로의 해안선 차원(Richardson Dividers), 에농, 홀, 페익스의 1차원 자기중력 면 모형과 린든-벨의 격렬한 이완(Phase Spiral), 에르되시와 레니의 거대 성분과 아클리옵타스, 드수자, 스펜서의 폭발적 스미기(Giant Component), 허프와 두다, 하트의 직선 찾기(Hough Transform), 조르당의 곡선 정리와 심랏의 교차 세기(Jordan Curve)예요. 61판도 열을 더했어요. 세스나와 다섯 사람의 영온 무작위장 이징 눈사태(Crackling Noise), 몽주의 흙 옮기기와 매캔의 옮김 보간(Monge Transport), 파울의 덫과 마티외 방정식(Paul Trap), 그린힐의 제 무게 기둥(Greenhill Column), 흐바탈의 미술관 정리와 피스크의 세 색 증명(Art Gallery), 홀디치의 고리(Holditch Ring), 톰슨의 꺾인 역선과 헤비사이드의 움직이는 전하(Thomson Kink), 슈나이더와 바이스의 쌍성 렌즈(Binary Lens), 테일러의 되섞기(Taylor Unmixing), 브누아, 칼로, 디에네르 부부의 카나르 폭발(Canard Explosion)이에요. 62판도 열을 더했어요. 아브리코소프와 클라이너, 로스, 오틀러의 소용돌이 격자(Abrikosov Lattice), 울리크니의 청색 잡음과 빈자리와 뭉치 방법(Void and Cluster), 파인먼과 힙스의 체커보드(Feynman Checkerboard), 라도의 바쁜 비버와 마크센, 분트로크의 다섯 상태 챔피언(Busy Beaver), 폭스와 커시너, 비치의 평평한 곡면 위 직선 흐름(Veech Octagon), 리만의 미분 불가능 함수와 거버, 다위스테르마트의 복소 곡선(Riemann's Function), 헤슈와 킨즐레의 한 타일 형(Heesch Tiles), 차크라보르티와 헤이스, 보고시안의 마당 장터 모형(Yard-Sale Model), 베르그렌의 피타고라스 세 수 나무(Berggren Tree), 더브라윈과 람, 렁의 단위근 합과 밀른의 완전히 균형 잡힌 리듬(Balanced Rhythms)이에요. 63판은 다섯을 더했어요. 모팻의 모서리 소용돌이와 다네다의 사진(Moffatt Eddies), 맥스웰의 물고기 눈 렌즈(Maxwell's Fish-Eye), 이지케비치의 스파이크 신경망(Izhikevich Network), 애들러와 하소퍼, 우슬리의 들뜸 집합 오일러 지표(Excursion Sets), 심슨과 블라이스의 역설(Simpson's Paradox)이에요. 64판은 다섯을 더했어요. 암만과 베인커르의 팔각 타일링을 더 브라윈의 다중 격자로 지은 것(Ammann-Beenker), 겔판트, 카프라노프, 젤레빈스키의 아메바와 포르스베리, 파사레, 치흐의 구멍(Polynomial Amoeba), 키블과 주렉의 결함 얼기와 피시먼, 데 키아라, 칼라르코, 모리지의 지그재그 전이(Kibble-Zurek Ions), 야코비의 적분과 힐의 영속도 곡선(Hill's Regions), 스티븐슨과 카피차의 거꾸로 선 진자와 아치슨, 멀린의 인도 밧줄 묘기(Indian Rope Trick)예요. 65판은 다섯을 더했어요. 폰 노이만과 멀린스의 거품 법칙(Foam Coarsening), 베드퍼드와 맥멀런의 자기 아핀 카펫(McMullen Carpet), 클라인의 돛과 라그랑주의 주기 연분수(Klein's Sails), 야코비의 측지선과 샬의 공초점 곡면(Jacobi Geodesics), 하다마르와 리브친스키의 물방울과 코르테스의 정규화 스토크슬렛(Sedimenting Cloud)이에요. 67판은 다섯을 더했어요. 라돈의 변환과 라마찬드란, 락슈미나라야난의 램프 필터(Radon Transform), 아르틴의 브레이드 군과 폭스, 노이워스의 배치 공간(Artin Braids), 월시의 함수계와 실베스터의 행렬, 페일리의 차례(Walsh Functions), 아레프의 깜박이는 소용돌이(Blinking Vortex), 뒤팽의 사이클라이드(Dupin Cyclide)예요. 68판은 다섯을 더했어요. 들로네의 빈 외접원과 로슨의 뒤집기(Delaunay Flips), 모네로-뒤멘의 피보나치 단어 프랙탈(Fibonacci Word), 로즈의 검출 기준(Rose Criterion), 요세푸스 문제와 바셰의 셈 놀이(Josephus Problem), 레비치비타의 평행 이동과 푸코의 진자(Parallel Transport)예요. 69판은 다섯을 더했어요. 랭퍼드의 짝과 데이비스의 존재 조건, 스콜렘의 수열(Langford Pairs), 아하로노프와 봄의 효과와 베리 등의 파면 전위(Aharonov-Bohm), 페니의 놀이와 콘웨이의 선행수(Penney's Game), 휘트니와 그라우스타인의 회전수 정리(Whitney-Graustein), 슈타이너의 대칭화와 그로스의 수렴(Steiner Symmetrization)이에요. 70판은 다섯을 더했어요. 아우렌하머의 파워 다이어그램과 기타가와, 메리고, 티베르의 뉴턴 수송(Laguerre Cells), 배빗과 루윈의 헥사코드 정리(Hexachordal Theorem), 프렌켈과 콘토로바의 사슬(Frenkel-Kontorova), 에스하위스, 판 데르 벨레, 판 데르 메이르, 로서의 알갱이 라이덴프로스트 효과(Granular Leidenfrost), 카안의 가우스 곱셈 카오스(Multiplicative Chaos)예요.
 
 목록 밖에서 다음에 해 볼 것이에요. 수론 갈래는 32판의 Gilbreath Table 까지 넷이에요. 길브레스 표는 소수 말고 다른 수열로도 세울 수 있어요. 오들리코(1993)에 따르면 2 다음에 간격이 작고 고르게 흩어진 홀수가 오는 수열에서는 1 의 열이 서고, 간격이 크면 깨져요. 간격의 크기를 노브로 걸면 1 의 열이 무너지는 자리가 보여요. 해머슬리 과정의 점 대신 격자 칸마다 지수 분포 무게를 두면 마지막 통과 스미기(로스트, 1981)가 되고, 극한 모양이 쌍곡선에서 (√x+√y)² 의 경계로 바뀌어요.
 
@@ -4196,6 +4279,8 @@ Flock, Harmonograph, Big Type 은 처음 화면이 빨강이에요.
 
 69판에서 본 것이에요. 셈이 정확한 대상은 이번에도 패턴 안에서 먼저 맞춰 봤어요. Langford Pairs 는 코드와 같은 순서로 따로 세어 뒤집은 것을 하나로 친 3, 4, 7, 8, 11, 12 의 배열 수가 1, 1, 26, 150, 17,792, 108,144 였고, 스콜렘 수열은 4, 5, 8, 9, 12 에서 3, 5, 252, 1,328, 227,968 이었어요. Penney's Game 은 콘웨이의 선행수로 셈한 승산이 따로 돌린 20만 판과 0.0013 안에서 맞았고, 패턴을 Speed 3 에서 한 시간 돌린 HHT 대 THH 5,475 판에서 B 가 0.7512 를 가져갔어요. Aharonov-Bohm 은 분수 차수 베셀 함수를 밀러의 역방향 점화식과 노이만의 합으로 구해서, 자속 0 에서 평면파와 1e-14 안으로, 자속 1 에서 1.4e-8 안으로 같아요. 정리가 수를 못 박는 대상은 패널에서 지켜봤어요. Steiner Symmetrization 의 초승달은 황금각 차례의 축 다섯 번에 둘레가 원의 1.520 배에서 1.004 배로 들어왔어요. 황금각 차례가 늘 원으로 간다는 정리는 찾지 못했고, 다섯 모양이 다 1% 안으로 들어오는 것만 봤어요. Whitney-Graustein 은 회전수가 1 에서 0 으로 내려갈 때가 0 에서 1 로 오를 때보다 곡선을 훨씬 세게 비틀어서, 흔들림을 다 꺼도 한 구간이 다른 구간보다 16배 빨리 달려요. 패널의 폭이 정리를 다 담지 못한 곳도 있었어요. Aharonov-Bohm 의 반 양자에서 맨 아랫줄 양 끝의 밀림 차이는 0.5 가 아니라 0.445 바퀴예요. 양 끝이 그림자 선에서 30 LED 인데, 관 뒤 85 LED 에서의 프레넬 폭 √(λx) 가 24 LED 라 회절이 아직 남아서예요.
 
+70판에서 본 것이에요. 이번 다섯은 다 「다음 판 감」이 앞 판의 파일을 짚어 적어 둔 것이라 앞 판 코드를 이어 쓴 것이 많았는데, 이어 쓴 셈이 그대로 맞지는 않았어요. Frenkel-Kontorova 는 64판 Kibble-Zurek Ions 의 감쇠 사슬을 썼어요. 미는 힘을 바닥 깊이 K 에 비례하게 주면 Substrate 노브는 꼬임의 폭만 바꾸고, 힘을 K 와 떼어 놓아야 깊은 바닥에서 꼬임이 갇히는 것이 보였어요. 표시하지 않은 세계선은 꼬임이 지나가도 곧은 줄로 남아서, 공 둘을 크림색으로 칠하고서야 한 우물씩 비켜 가는 계단이 보였어요. Laguerre Cells 는 질량을 맞추고 나면 점 24 개 가운데 11 개가 남의 칸에 앉아요. 점을 흰 255 로 찍으면 눈이 점을 칸의 중심으로 읽어서 150 으로 낮췄어요. Hexachordal Theorem 은 12박에서 여섯을 고르는 924 가지 가운데 552 가지가 나머지 여섯과 돌리거나 뒤집어도 겹치지 않는데 막대가 같았고, 16박에서 여덟을 고르면 12,870 가지 가운데 10,768 가지였어요. Granular Leidenfrost 는 뚜껑 있는 상자에서 아무리 세게 흔들어도 기체가 되지 않고 결정이 뚜껑에 눌려서, 기체 쪽 끝을 반발 계수 노브로 옮겼어요. Multiplicative Chaos 는 8,192 LED 위에서 질량이 γ = 2 보다 한참 앞인 1.3 언저리에서 장의 가장 높은 LED 로 얼어붙었어요. 격자가 커지면 장의 최댓값은 2 E[X²] 로 가지만, 이 패널에서는 1.47 E[X²] 가 끝이에요.
+
 목록 밖에서 31판 뒤에 해 볼 것이에요. 페르미-파스타-울람-칭구의 되돌아옴(1955)은 KdV Solitons 와 같은 뿌리라 같은 판에 두지 않아요.
 
 목록 밖에서 33판 뒤에 해 볼 것이에요. 토카르스키의 방(1995)은 거울로 된 다각형 방에서 한 점의 빛이 다른 한 점에만 닿지 못하는 방이라 Penrose Room 의 광선 추적을 그대로 써요. 프리드먼과 스코라(1987)는 둥근 원 셋으로는 보로메오 고리를 만들 수 없다는 것을 보였는데, 원을 밀어 넣을 때 어디서 부딪히는지가 그림이 돼요. 정렬 네트워크의 시간 t 의 순열을 점으로 찍으면 대각선에서 원판을 지나 반대 대각선으로 도는 점 구름이 돼요. 그 원판이 2007년 논문이 내다본 아르키메데스 법칙이에요. 간격이 2k 인 소수 쌍의 수는 Goldbach Comet 과 같은 FFT 로 세고, k 마다 하디-리틀우드 인수로 갈리는 줄기 그림이 돼요.
@@ -4242,23 +4327,23 @@ Flock, Harmonograph, Big Type 은 처음 화면이 빨강이에요.
 
 목록 밖에서 55판 뒤에 해 볼 것이에요. 같은 각도의 흐름선을 판 여러 점에서 띄우면 만나는 대로 합쳐져 나무가 되고, 그 나무를 따라 도는 곡선이 판을 다 메우는 SLE(16/κ) 예요. 밀러와 셰필드의 『Imaginary geometry IV』(2017)에 있어요. 같은 원들을 원통 대신 원뿔과 방위 투영에 얹으면 왜곡이 한 원이나 한 점 둘레로 모여서, 람베르트가 1772년에 낸 정각 원뿔 투영과 방위 등적 투영을 Tissot's Indicatrix 의 K4 로 오가게 해 볼 만해요. 콘웨이의 상자 함수(1976)는 물음표 함수를 뒤집은 꼴이라 같은 계단을 눕혀 실수 전체로 늘려 볼 수 있고, 슈테른의 이원자 수열(모리츠 슈테른, 1858)도 128줄을 채우는 산맥이 될 만해요. 천과 폭스, 린던의 린던 분해(1958)는 글을 사전순으로 커지지 않는 린던 단어들로 자르는 것이라, 조각마다 색이 다른 띠로 그려 볼 만해요. 크로프턴 공식(모건 크로프턴, 1868)은 Buffon's Noodle 과 같은 셈으로, 무작위 직선이 곡선을 건너는 수로 곡선의 길이를 재요. 리듬 타일링의 다른 끝은 푸글레드의 스펙트럼 추측(벤트 푸글레드, 1974)이고, 타오(2004)가 5차원에서 반례를 찾았어요. 삼각 격자 스미기에서 사각형을 가로지를 확률은 카디의 공식(존 카디, 1992)을 따르고 스미르노프(2001)가 증명해서, Hex Theorem 의 판 모양을 바꾸며 건넌 횟수를 세면 공식의 곡선에 다가가요. 자유군의 부분군은 8자 고리의 유한 피복이고, 스톨링스(1983)의 접기가 생성 낱말의 꽃잎 고리에서 같은 글자의 변을 하나씩 접어 그 피복을 만들어요. A + B → 0 에 입자를 끊임없이 고르게 넣어도 정상 상태에서 영역이 갈라져서(린덴버그, 웨스트, 코펠만, 1988), 영역이 패널 크기까지 퍼진 채 흔들리는 판을 세울 수 있어요. 한 주기에 두 파장을 넣고 반 파장 섭동을 더하면 이웃 나선이 서로 돌다 하나로 합치는 짝짓기(위넌트와 브라우언드, 1974)가 나와요.
 
-목록 밖에서 56판 뒤에 해 볼 것이에요. 잎을 반투명하게 겹치는 투명 죽은 잎 모형(브뤼노 갈른, 얀 구소, 2012)은 잎이 투명해질수록 가우스 장으로 다가가서, Dead Leaves 의 셈에 노브 하나로 두 그림 사이를 오갈 수 있어요. 골롬의 렙타일(1964)로 L 트로미노를 같은 꼴 넷으로 거듭 나누면 의자 타일링이 돼요. 같은 생성나무를 해럴드 템펄리(1974)의 전단사로 도미노 타일링으로 옮겨 그려 볼 만해요. 힘을 교류로 흔들면 세기와 진동수의 비가 J_0 의 영점에 놓일 때 묶음이 퍼지지 않고 제자리에 묶여요. 데이비드 던랩과 V. M. 켄크리(1986)의 동적 국소화예요. 알프레드 인셀버그(1985)의 평행 좌표는 다차원 점을 세로축 여러 개를 잇는 꺾은선으로 그리고, 한 직선 위의 점들은 이웃한 두 축 사이에서 한 점을 지나요. 하타노-넬슨 모형(하타노 나오미치, 데이비드 넬슨, 1996)은 한쪽으로 기운 뜀을 넣은 무질서 사슬이라, 고윳값이 실수축에서 떨어져 나와 고리를 그려요. 리우빌 함수의 합이 2 이상에서 늘 0 이하라는 포여의 추측(조지 포여, 1919)은 C. 브라이언 해즐그로브(1958)가 깼고, 처음 양수가 되는 n = 906,150,257 까지 가는 길을 그려 볼 만해요. 이진 칸 없이 로그 상관 가우스장의 지수로 같은 다중 프랙탈을 만드는 장피에르 카안(1985)의 가우스 곱셈 혼돈도 있어요. 무작위 조직화의 임계점에서는 입자 배치가 초균일해져서(대니얼 헥스너, 도브 레빈, 2015), 큰 상자의 밀도 요동으로 그릴 수 있어요. 미첼 불안정성(존 헨리 미첼, 1889)은 꼬인 탄성 고리가 꼬임이 문턱을 넘을 때까지 납작하게 버티다가 한순간 평면 밖으로 휘는 일이에요.
+목록 밖에서 56판 뒤에 해 볼 것이에요. 잎을 반투명하게 겹치는 투명 죽은 잎 모형(브뤼노 갈른, 얀 구소, 2012)은 잎이 투명해질수록 가우스 장으로 다가가서, Dead Leaves 의 셈에 노브 하나로 두 그림 사이를 오갈 수 있어요. 골롬의 렙타일(1964)로 L 트로미노를 같은 꼴 넷으로 거듭 나누면 의자 타일링이 돼요. 같은 생성나무를 해럴드 템펄리(1974)의 전단사로 도미노 타일링으로 옮겨 그려 볼 만해요. 힘을 교류로 흔들면 세기와 진동수의 비가 J_0 의 영점에 놓일 때 묶음이 퍼지지 않고 제자리에 묶여요. 데이비드 던랩과 V. M. 켄크리(1986)의 동적 국소화예요. 알프레드 인셀버그(1985)의 평행 좌표는 다차원 점을 세로축 여러 개를 잇는 꺾은선으로 그리고, 한 직선 위의 점들은 이웃한 두 축 사이에서 한 점을 지나요. 하타노-넬슨 모형(하타노 나오미치, 데이비드 넬슨, 1996)은 한쪽으로 기운 뜀을 넣은 무질서 사슬이라, 고윳값이 실수축에서 떨어져 나와 고리를 그려요. 리우빌 함수의 합이 2 이상에서 늘 0 이하라는 포여의 추측(조지 포여, 1919)은 C. 브라이언 해즐그로브(1958)가 깼고, 처음 양수가 되는 n = 906,150,257 까지 가는 길을 그려 볼 만해요. 무작위 조직화의 임계점에서는 입자 배치가 초균일해져서(대니얼 헥스너, 도브 레빈, 2015), 큰 상자의 밀도 요동으로 그릴 수 있어요. 미첼 불안정성(존 헨리 미첼, 1889)은 꼬인 탄성 고리가 꼬임이 문턱을 넘을 때까지 납작하게 버티다가 한순간 평면 밖으로 휘는 일이에요.
 
 목록 밖에서 57판 뒤에 해 볼 것이에요. 블룸의 중심축 대신 다각형의 변을 같은 빠르기로 평행하게 밀어 들이는 직선 골격(오스빈 아이히홀처, 프란츠 아우렌하머와 두 사람, 1995)은 포물선 조각 없이 선분만으로 된 나무를 남겨요. θ 를 세 배로 늘리는 3진 솔레노이드는 단면이 세 갈래 칸토어 집합이 되고, 구멍 셋 뚫린 원판 위의 플리킨 끌개(1974)도 같은 관 그림으로 그릴 수 있어요. 장필리프 부쇼(1992)의 덫 모형은 자리마다 무작위 깊이의 덫에서 걷개가 지수 분포 시간만큼 머물다 떠나서, 오래 기다린 걷개일수록 더 오래 머무는 노화가 패널에서 보일 거예요. 갈페린의 두 블록은 꼭지각 arctan √(m/M) 의 쐐기 당구와 같아서, 쐐기를 거울로 펼쳐 공의 길이 곧은 선 하나가 되는 것을 보여 줄 수 있어요. 존 콘웨이의 지형(1997)으로 x² + y² 의 값을 평면을 나누는 나무 위에 펼치면, 두 제곱수의 합으로 쓰이는 수들이 나무를 따라 자라는 것이 보여요. 갑자기 멈춘 전하의 전기력선이 빛의 속도로 퍼지는 껍질에서 꺾이는 J. J. 톰슨(1904)의 그림도 빛의 지연이 주인공이라 세운 패널에 맞고, 에드워드 퍼셀(1965)이 교과서에서 복사를 이 꺾임으로 설명했어요. 스토크스 표류가 바람이 만든 전단과 만나면 물속에 나란한 회전 띠가 서는 랭뮤어 순환(어빙 랭뮤어, 1938; 크레이크와 레이보비치의 식, 1976)을 단면으로 그려 볼 수 있어요. 라이스의 9형도 매개변수 하나로 모양이 바뀌어 1형처럼 모프로 보여 줄 수 있어요. 앞바퀴가 볼록한 닫힌 고리를 돌 때 그 넓이가 πL² 보다 크면 뒷바퀴를 끌어들이는 고리가 생긴다는 멘진의 추측(1906)은 마크 레비와 세르게이 타바치니코프(2009)가 증명해서, 타원 고리의 넓이를 노브에 걸면 뒷바퀴가 감겨 들다 문턱 아래에서 떠도는 것으로 바뀌는 순간이 보일 거예요. LSW 의 극한 분포가 처음 분포의 꼬리 모양에 따라 달라진다는 바르바라 니트하머와 로버트 페고(1999)의 결과는, 처음 반지름 분포의 꼬리를 노브에 걸어 늦은 분포가 LSW 곡선에서 벗어나는 것으로 보여 줄 수 있어요.
 
 목록 밖에서 58판 뒤에 해 볼 것이에요. 새뮤얼 로모나코와 루이스 카우프먼(2008)의 매듭 모자이크는 열한 가지 타일로 n × n 판에 매듭을 깔아서, Mirror Curves 의 판에서 타일을 하나씩 바꿔 끼우며 매듭 종류가 바뀌는 것을 보일 수 있어요. 로드니 백스터(1980)가 정확히 푼 딱딱한 육각형 기체는 임계 활동도가 (11 + 5√5)/2 이고, 질서 상에서 부분격자 셋이 갈려 영역이 세 색으로 읽혀요. 앨프리드 조지 그린힐(1881)의 제 무게로 휘는 기둥은 휘는 높이가 J₋₁/₃ 의 첫 영점으로 정해져서, 키를 노브에 걸면 곧은 기둥이 그 높이를 넘는 순간 휘어 누워요. 로버트 리히트마이어(1960)와 예브게니 메시코프(1969)의 불안정은 충격파가 지나간 경계의 잔물결이 지수가 아니라 시간에 비례해 자라서, Rayleigh-Taylor 의 풀이에 충격 하나를 더하면 돼요. 레지나 리우(1990)의 단체 깊이는 LED 를 품는 데이터 삼각형의 몫으로 칠해서, 터키 깊이와 달리 등고선이 볼록하지 않게 휘는 곳이 생길 수 있어요. 이브 르 장(2010)에 따르면 c = 1 고리 수프가 자리마다 머문 시간은 이산 가우스 자유장 제곱의 반과 분포가 같아서, 고리 대신 머문 시간으로 칠하면 자유장의 제곱이 떠요. 알렉산더 포스트니코프(2006)의 플래빅 그래프는 양의 그라스만 칸을 그림으로 적어서, KP Web 의 웹 옆에 그 칸의 그래프를 나란히 세울 수 있어요. 7비트에서 1 이 셋이나 넷인 상태 70개만 한 비트씩 바꾸며 다 지나는 고리가 있다는 중간 층 정리는 이반 하벨(1983)이 묻고 토르스텐 뮈체(2016)가 증명했어요. 샤를 쥘리앵 브리앙숑(1806)의 정리는 파스칼 정리의 쌍대라, 원뿔곡선에 외접한 육각형의 대각선 셋이 늘 한 점을 지나는 그림이 돼요. 엘빈 크리스토펠(1867)과 헤르만 슈바르츠(1869)의 사상으로 위 반평면의 격자를 다각형 안으로 펴면, 꼭짓점마다 직각이 접히며 모여요. 조지 마살리아(1968)는 선형 합동 생성기의 연속한 세 수가 몇 장의 평면 위에만 놓인다는 것을 보였어요. RANDU 의 점을 정육면체에 찍어 돌리면 한 방향에서 15장의 평면이 한꺼번에 줄을 서요.
 
-목록 밖에서 59판 뒤에 해 볼 것이에요. 고트홀트 아이젠슈타인(1844)은 p/2 × q/2 직사각형의 대각선 아래와 위의 격자점을 세어 상호 법칙을 증명해서, 두 수의 합 (p−1)(q−1)/4 의 홀짝이 부호가 되는 것을 패널에서 셀 수 있어요. 대니얼 고테스만, 알렉세이 키타예프, 존 프레스킬(2001)의 GKP 격자 상태는 위그너 함수가 양과 음의 점으로 바둑판처럼 번갈아 서서, Wigner Cat 의 변환으로 그릴 만해요. 아서 케일리(1869)의 마디 3차 곡면 쪽으로 클렙시 곡면을 바꾸면 직선 27개가 마디 넷으로 모이며 9개로 줄어요. 하인리히 헤슈(1968)의 둘레 수 문제는 한 타일을 같은 타일로 몇 겹까지 감쌀 수 있는지 묻는 것이라, 겹마다 색을 바꿔 쌓아 볼 만해요. 존 밀너(1968)의 올뭉치는 8_19 같은 올뭉치 매듭에서 자이페르트 곡면이 매듭 둘레를 한 바퀴 돌며 여집합을 다 쓸고 지나가는 그림이 돼요. 오가타 요시히코(1988)의 ETAS 모형은 사건에 크기를 붙여 큰 사건이 자식을 많이 낳게 해서, 본진 뒤 여진이 오모리 후사키치(1894)의 법칙대로 잦아드는 것을 보여요. 코호넨 사슬을 고리로 닫아 도시 수십 개에 걸면 리처드 더빈과 데이비드 윌쇼(1987)의 탄성망이 외판원 순회를 찾아가요. 세게 흔든 알갱이 층에서 차가운 덩어리가 뜨거운 기체 위에 뜨는 알갱이 라이덴프로스트 효과(페터 에쉬위스와 세 사람, 2005)도 세운 패널에 맞아요. 루빈스타인, 샤미르, 아비단(2008)의 그래프 컷 심 카빙은 동영상을 줄일 때 시간축을 따라 이음매 면을 잘라 내요.
+목록 밖에서 59판 뒤에 해 볼 것이에요. 고트홀트 아이젠슈타인(1844)은 p/2 × q/2 직사각형의 대각선 아래와 위의 격자점을 세어 상호 법칙을 증명해서, 두 수의 합 (p−1)(q−1)/4 의 홀짝이 부호가 되는 것을 패널에서 셀 수 있어요. 대니얼 고테스만, 알렉세이 키타예프, 존 프레스킬(2001)의 GKP 격자 상태는 위그너 함수가 양과 음의 점으로 바둑판처럼 번갈아 서서, Wigner Cat 의 변환으로 그릴 만해요. 아서 케일리(1869)의 마디 3차 곡면 쪽으로 클렙시 곡면을 바꾸면 직선 27개가 마디 넷으로 모이며 9개로 줄어요. 하인리히 헤슈(1968)의 둘레 수 문제는 한 타일을 같은 타일로 몇 겹까지 감쌀 수 있는지 묻는 것이라, 겹마다 색을 바꿔 쌓아 볼 만해요. 존 밀너(1968)의 올뭉치는 8_19 같은 올뭉치 매듭에서 자이페르트 곡면이 매듭 둘레를 한 바퀴 돌며 여집합을 다 쓸고 지나가는 그림이 돼요. 오가타 요시히코(1988)의 ETAS 모형은 사건에 크기를 붙여 큰 사건이 자식을 많이 낳게 해서, 본진 뒤 여진이 오모리 후사키치(1894)의 법칙대로 잦아드는 것을 보여요. 코호넨 사슬을 고리로 닫아 도시 수십 개에 걸면 리처드 더빈과 데이비드 윌쇼(1987)의 탄성망이 외판원 순회를 찾아가요. 루빈스타인, 샤미르, 아비단(2008)의 그래프 컷 심 카빙은 동영상을 줄일 때 시간축을 따라 이음매 면을 잘라 내요.
 
 목록 밖에서 60판 뒤에 해 볼 것이에요. 10차 직교 라틴 방진은 둘까지 알려졌고 셋이 서로 직교하는 묶음은 아직 아무도 찾지 못했어요. Euler's Officers 의 정확 덮개 탐색을 셋째 방진 쪽으로 돌리면, 두 방진의 가로지르기가 몇 개까지 겹치는지가 그림이 될 만해요. 마틴 크루스칼(1960)과 죄르지 세케레시(1960)의 좌표로 슈바르츠실트 블랙홀을 끝까지 펴면, 펜로즈 도형이 지평선 둘이 엇갈려 나눈 네 구역과 위아래의 특이점 선으로 바뀌어요. Penrose Diagram 의 아크탄젠트 셈을 그대로 쓸 수 있어요. 아르투어 쇤플리스(1906)는 조르당 곡선의 안이 원판과 같은 꼴이라는 것을 보였어요. Jordan Curve 의 안을 원판으로 펴는 등각 사상은 곡선이 구불거릴수록 가지 끝마다 원 둘레의 아주 좁은 호로 몰려요. 에르되시-레니 그래프에서 둘째로 큰 성분은 문턱 n/2 에서 가장 커졌다가 거대 성분에 먹혀 줄어들어서, Giant Component 의 그래프에 둘째 곡선을 겹치면 문턱이 봉우리로 보여요. 로버트 코베유와 로버트 맥퍼슨(1967)의 스펙트럼 검사로 선형 합동 생성기의 평면 간격을 2차원부터 6차원까지 셈하면, RANDU 가 3차원에서 갑자기 무너지는 것이 막대 하나로 보여요.
 
-목록 밖에서 61판 뒤에 해 볼 것이에요. 같은 재료로 가장 높이 서는 기둥은 위로 갈수록 가늘어지는 꼴이라(조지프 켈러와 프리티오프 니오르드손, 1966), Greenhill Column 의 셈에 단면을 하나 더 얹으면 돼요. 모든 모서리가 직각인 갤러리는 경비원 ⌊n/4⌋ 명이면 되고(제프 칸, 마리아 클라웨, 대니얼 클라이트먼, 1983), Art Gallery 의 증명 그림을 사각형 나누기로 바꿔 볼 만해요. 너비가 w 로 일정한 곡선은 둘레가 꼭 πw 라는 바르비에의 정리(조제프에밀 바르비에, 1860)는 Holditch Ring 처럼 꼴이 바뀌어도 같은 양이 남는 그림이 돼요. 원을 도는 전하의 역선은 꺾임이 나선으로 감기는 싱크로트론 그림이 되고(로저 첸, 1972), Thomson Kink 의 셈을 그대로 써요. 점 질량 하나에 바깥 전단을 더한 창-레프스달 렌즈(1979)는 Binary Lens 의 광선 추적으로 네 뾰족점 커스틱을 따로 세울 수 있어요. 접힌 마디 곁의 카나르는 큰 스파이크 사이에 작은 고리를 끼우는 혼합 모드 진동이 돼서(마르틴 베흐젤베르거, 2005), Canard Explosion 의 아래 자취가 그 리듬을 칠 수 있어요. 점 무리를 연속 분포로 옮기는 반이산 수송은 파워 다이어그램의 라게르 칸으로 풀려서(프란츠 아우렌하머, 1987; 캉탱 메리고, 2011), Monge Transport 의 도형을 칸으로 나눠 보일 수 있어요.
+목록 밖에서 61판 뒤에 해 볼 것이에요. 같은 재료로 가장 높이 서는 기둥은 위로 갈수록 가늘어지는 꼴이라(조지프 켈러와 프리티오프 니오르드손, 1966), Greenhill Column 의 셈에 단면을 하나 더 얹으면 돼요. 모든 모서리가 직각인 갤러리는 경비원 ⌊n/4⌋ 명이면 되고(제프 칸, 마리아 클라웨, 대니얼 클라이트먼, 1983), Art Gallery 의 증명 그림을 사각형 나누기로 바꿔 볼 만해요. 너비가 w 로 일정한 곡선은 둘레가 꼭 πw 라는 바르비에의 정리(조제프에밀 바르비에, 1860)는 Holditch Ring 처럼 꼴이 바뀌어도 같은 양이 남는 그림이 돼요. 원을 도는 전하의 역선은 꺾임이 나선으로 감기는 싱크로트론 그림이 되고(로저 첸, 1972), Thomson Kink 의 셈을 그대로 써요. 점 질량 하나에 바깥 전단을 더한 창-레프스달 렌즈(1979)는 Binary Lens 의 광선 추적으로 네 뾰족점 커스틱을 따로 세울 수 있어요. 접힌 마디 곁의 카나르는 큰 스파이크 사이에 작은 고리를 끼우는 혼합 모드 진동이 돼서(마르틴 베흐젤베르거, 2005), Canard Explosion 의 아래 자취가 그 리듬을 칠 수 있어요.
 
-목록 밖에서 62판 뒤에 해 볼 것이에요. 격자가 단단한 판이 아니라 탄성체라서 생기는 트카첸코 물결(Vito Tkachenko, 1966)을 소용돌이 자리를 흔들어 그려 볼 만한데, I. 코딩턴, P. 엥겔스, V. 슈바이크하르트, E. 코넬(2003)이 도는 응축체에서 찍었어요. 고른 회색 하나를 오차 확산(로버트 플로이드와 루이스 스타인버그, 1976)으로 찍을 때 회색 값마다 서는 벌레 무늬를, 같은 몫의 빈자리와 뭉치 문턱과 나란히 볼 만해요. 같은 격자 위 길을 i 없이 크기만으로 더하면 시드니 골드스타인(1951)과 마크 카츠(1974)의 전신 방정식 걸음이 되니, 두 합을 나란히 그리면 위상이 확산을 빛 원뿔 쪽으로 미는 것이 보여요. 에밀 포스트(1921)의 태그 시스템은 낱말 앞에서 세 글자를 지우고 지운 첫 글자가 0 이면 00 을, 1 이면 1101 을 뒤에 붙이는데, 모든 낱말이 끝나는지 아직 아무도 몰라서 낱말을 한 줄씩 시간 아래로 쌓으면 같은 시공간 그림이 될 만해요. 커티스 맥멀런(2003)과 캐리언 칼타(2004)가 찾은 종수 2 의 L자 탁자는 정다각형이 아닌데도 변의 비가 2차 무리수이면 비치의 이분법을 따라서, 같은 닫힘과 채움을 L 모양 하나로 그릴 수 있어요. 스테판 자파르(1996)가 셈한 리만 함수의 다중프랙탈 스펙트럼, 곧 점마다 다른 횔더 지수 α 가 1/2 에서 3/4 사이에 퍼지고 지수가 α 인 점들의 차원이 4α − 2 라는 것을 t 축 위의 색으로 그려 볼 만해요. 평면을 덮지 못하는 도형을 몇 겹까지 둘러쌀 수 있는지 묻는 헤슈 수(하인리히 헤슈, 1968)를, 다섯 겹까지 둘러싸이는 케이시 맨(2004)의 도형으로 그려 볼 만해요. 장필리프 부쇼와 마르크 메자르(2000)의 부의 응축 모형은 곱으로 불어나는 재산에 이웃과 나누는 몫을 더해서, 나누는 몫이 작아지면 꼬리가 파레토 법칙에서 한 사람 몫의 응축으로 넘어가요. 안드레이 마르코프(1880)의 마르코프 세 수 x² + y² + z² = 3xyz 도 (1, 1, 1) 에서 z 를 3xy − z 로 바꾸는 비에타 뛰기로 가지를 치는 나무라서, 같은 꼴의 다리 그림에 그 나무를 올려 볼 만해요. 밀턴 배빗이 1950년대에 쓰고 데이비드 루인(1959)이 증명한 육음 정리를 리듬에 옮기면 12걸음의 여섯 걸음 리듬과 그 여집합은 사이 간격의 목록이 같아서, 둘의 걸음을 나란히 세워 볼 수 있어요.
+목록 밖에서 62판 뒤에 해 볼 것이에요. 격자가 단단한 판이 아니라 탄성체라서 생기는 트카첸코 물결(Vito Tkachenko, 1966)을 소용돌이 자리를 흔들어 그려 볼 만한데, I. 코딩턴, P. 엥겔스, V. 슈바이크하르트, E. 코넬(2003)이 도는 응축체에서 찍었어요. 고른 회색 하나를 오차 확산(로버트 플로이드와 루이스 스타인버그, 1976)으로 찍을 때 회색 값마다 서는 벌레 무늬를, 같은 몫의 빈자리와 뭉치 문턱과 나란히 볼 만해요. 같은 격자 위 길을 i 없이 크기만으로 더하면 시드니 골드스타인(1951)과 마크 카츠(1974)의 전신 방정식 걸음이 되니, 두 합을 나란히 그리면 위상이 확산을 빛 원뿔 쪽으로 미는 것이 보여요. 에밀 포스트(1921)의 태그 시스템은 낱말 앞에서 세 글자를 지우고 지운 첫 글자가 0 이면 00 을, 1 이면 1101 을 뒤에 붙이는데, 모든 낱말이 끝나는지 아직 아무도 몰라서 낱말을 한 줄씩 시간 아래로 쌓으면 같은 시공간 그림이 될 만해요. 커티스 맥멀런(2003)과 캐리언 칼타(2004)가 찾은 종수 2 의 L자 탁자는 정다각형이 아닌데도 변의 비가 2차 무리수이면 비치의 이분법을 따라서, 같은 닫힘과 채움을 L 모양 하나로 그릴 수 있어요. 스테판 자파르(1996)가 셈한 리만 함수의 다중프랙탈 스펙트럼, 곧 점마다 다른 횔더 지수 α 가 1/2 에서 3/4 사이에 퍼지고 지수가 α 인 점들의 차원이 4α − 2 라는 것을 t 축 위의 색으로 그려 볼 만해요. 평면을 덮지 못하는 도형을 몇 겹까지 둘러쌀 수 있는지 묻는 헤슈 수(하인리히 헤슈, 1968)를, 다섯 겹까지 둘러싸이는 케이시 맨(2004)의 도형으로 그려 볼 만해요. 장필리프 부쇼와 마르크 메자르(2000)의 부의 응축 모형은 곱으로 불어나는 재산에 이웃과 나누는 몫을 더해서, 나누는 몫이 작아지면 꼬리가 파레토 법칙에서 한 사람 몫의 응축으로 넘어가요. 안드레이 마르코프(1880)의 마르코프 세 수 x² + y² + z² = 3xyz 도 (1, 1, 1) 에서 z 를 3xy − z 로 바꾸는 비에타 뛰기로 가지를 치는 나무라서, 같은 꼴의 다리 그림에 그 나무를 올려 볼 만해요.
 
 목록 밖에서 63판 뒤에 해 볼 것이에요. G. I. 테일러의 페인트 긁개(1960)는 한쪽 벽이 미끄러지는 쐐기의 스토크스 흐름으로 모팻 해의 출발점이고, 제프리-하멜 흐름(1915, 1917)은 쐐기 안의 방사 흐름이 레이놀즈 수에 따라 가지를 쳐요. 뤼네부르크 렌즈(Rudolf Luneburg, 1944)는 평행광을 맞은편 가장자리 한 점에 모으고, 이튼 렌즈(1952)는 빛을 왔던 길로 되돌려요. 물고기 눈의 r = R 에 거울을 두면(Ulf Leonhardt, 2009) 상이 원 안의 −P 로 와서, 세운 패널 안에 원천과 상이 다 들어와요. 이지케비치 망에 스파이크 시점 의존 가소성(Sen Song, Kenneth Miller, Larry Abbott, 2000)을 걸면 이지케비치(2006)가 polychronization 이라 부른, 몇 ms 씩 어긋난 채 되풀이되는 발화 무리가 래스터에 비스듬히 설 거예요. 테두리가 있는 사각형에서 들뜸 집합을 세면 넓이 항 말고 둘레 항과 오일러 항이 살아나서(Keith Worsley, 1995), 원환면과 나란히 두면 세 항이 갈라지는 게 보여요. 가우스 장의 봉우리 밀도(Michael Longuet-Higgins, 1957)도 같은 줄이에요. 버크슨의 역설(Joseph Berkson, 1946)은 뽑힌 점만 보면 무관한 두 값이 음의 상관을 띠어서, 선택 문턱을 노브에 걸면 Simpson's Paradox 와 다른 쪽에서 상관이 생기고 사라져요.
 
-목록 밖에서 64판 뒤에 해 볼 것이에요. 더 브라윈의 다중 격자(1981)를 30도 간격 여섯 묶음으로 늘리면 마름모가 30, 60, 90 도의 세 꼴인 12겹 타일링이 되고, Ammann-Beenker 의 교차점 열거와 뒤집기 감지를 그대로 써요. 아메바의 등뼈(미카엘 파사레와 한스 룰고르, 2004)는 Polynomial Amoeba 의 행 풀이가 arg w 마다 내는 z 의 근으로 론킨 함수를 줄마다 1차원 적분으로 구하면, 그 함수가 여집합 조각마다 평면인 자리를 이어 그릴 수 있어요. 프렌켈-콘토로바 모형(야코프 프렌켈과 타티야나 콘토로바, 1938)은 Kibble-Zurek Ions 의 감쇠 분자동역학 사슬을 주기 퍼텐셜 위에 눕히면 되고, 꼬임 표시와 갈비 역사로 어긋남이 생기고 움직이는 것을 보일 수 있어요. L1 둘레 랴푸노프 궤도의 안정·불안정 다양체가 이루는 관(왕상 쿤, 마틴 로, 제럴드 마스든, 셰인 로스, 2000)은 Hill's Regions 의 적분기와 야코비 껍질 되돌리기에 주기 궤도 찾기만 더하면 목을 지나는 길로 보여요. 마티외 방정식의 안정 지도(에밀 마티외, 1868)는 Indian Rope Trick 의 RK4 를 떨림 한 주기만 돌려 플로케 행렬의 대각합으로 LED 마다 칠하면, 거꾸로 선 사슬이 서는 혀 모양 영역이 한 장에 보여요.
+목록 밖에서 64판 뒤에 해 볼 것이에요. 더 브라윈의 다중 격자(1981)를 30도 간격 여섯 묶음으로 늘리면 마름모가 30, 60, 90 도의 세 꼴인 12겹 타일링이 되고, Ammann-Beenker 의 교차점 열거와 뒤집기 감지를 그대로 써요. 아메바의 등뼈(미카엘 파사레와 한스 룰고르, 2004)는 Polynomial Amoeba 의 행 풀이가 arg w 마다 내는 z 의 근으로 론킨 함수를 줄마다 1차원 적분으로 구하면, 그 함수가 여집합 조각마다 평면인 자리를 이어 그릴 수 있어요. L1 둘레 랴푸노프 궤도의 안정·불안정 다양체가 이루는 관(왕상 쿤, 마틴 로, 제럴드 마스든, 셰인 로스, 2000)은 Hill's Regions 의 적분기와 야코비 껍질 되돌리기에 주기 궤도 찾기만 더하면 목을 지나는 길로 보여요. 마티외 방정식의 안정 지도(에밀 마티외, 1868)는 Indian Rope Trick 의 RK4 를 떨림 한 주기만 돌려 플로케 행렬의 대각합으로 LED 마다 칠하면, 거꾸로 선 사슬이 서는 혀 모양 영역이 한 장에 보여요.
 
 목록 밖에서 65판 뒤에 해 볼 것이에요. 이차 무리수의 측지선이 위 반평면의 파레이 테셀레이션을 자르는 차례가 연분수를 그대로 적어서(캐럴라인 시리즈, 1985), Klein's Sails 의 행렬 M 을 SL(2,Z) 의 뫼비우스 변환으로 읽으면 닫힌 측지선 하나를 세로 패널에 세울 수 있어요. 타원면에서 배꼽점이 아닌 점의 첫 공액점 자취는 뾰족점이 꼭 넷이에요. 야코비가 강의에 적었고 이토 진이치와 기요하라 가즈요시가 2004년에 증명했어요. Jacobi Geodesics 의 다발에 야코비 장을 같이 적분하면 그 자취가 그대로 그려져요. 스티븐 랠리와 디미트리오스 가추라스(1992)의 카펫은 McMullen Carpet 의 자릿수 따라가기에 칸마다 높이가 다른 줄만 더하면 되고, 리처드 케니언과 유발 페레스(1996)의 자기 아핀 해면은 같은 셈을 세 방향으로 넓힌 거예요. 거품에서는 n 변 칸의 이웃이 평균 5 + 6/n 언저리 변을 가진다는 아보아브-웨어 법칙(D. A. Aboav, 1970; D. Weaire, 1974)을 Foam Coarsening 의 변 수 세기로 볼 수 있어요. 가라앉는 구름에 벽의 상 스토크슬렛(존 블레이크, 1971)을 더하면 바닥에 내려앉는 구름이 돼요.
 
@@ -4270,6 +4355,8 @@ Flock, Harmonograph, Big Type 은 처음 화면이 빨강이에요.
 
 목록 밖에서 69판 뒤에 해 볼 것이에요. 토노무라 아키라(Akira Tonomura) 등이 1986년에 초전도체로 감싼 고리 자석으로 찍은 전자 홀로그램처럼, 고리 안과 밖을 지난 간섭 줄무늬가 반 칸 어긋나는 그림을 Aharonov-Bohm 의 급수로 그려 볼 만해요. 자속관 둘을 반대 자속으로 나란히 두면 두 그림자 선 사이의 띠만 밀린 채 내려와요. 페니의 놀이를 네 번 줄로 넓히면 (x2 의 반대) x1 x2 x3 규칙이 열여섯 가운데 여섯에서 최선이 아니에요. HHTH 에 규칙이 고른 THHT 는 7:5 로 이기지만 HHHT 는 2:1 로 이겨서, 그 어긋남을 노브 하나로 넘겨 보는 판이 돼요. 휘트니가 같은 논문에 적은 공식, 곧 교차점마다 매긴 부호의 합에 ±1 을 더하면 회전수가 된다는 것을 Whitney-Graustein 의 곡선 위에 교차점 표시로 보여 줄 만하고, 블라디미르 아르놀트(Vladimir Arnold)가 1994년에 낸 평면 곡선의 불변량 J+, J−, St 는 곡선이 제 몸에 접하거나 삼중점을 지날 때만 바뀌어서 그 순간을 셀 수 있어요. 한 직선에 대해 거울쌍 두 점 가운데 한쪽만 옮기는 극 대칭화(polarization)는 Steiner Symmetrization 의 빗금 틀에서 현이 미끄러지는 대신 조각이 축 건너편으로 뒤집혀 건너가요. 같은 색 블록을 셋씩 쌓아 이웃한 둘 사이마다 k 블록이 끼게 하는 랭퍼드 문제의 확장은 Langford Pairs 의 탑에 그대로 서고, 도널드 크누스(Donald Knuth)의 춤추는 연결(2000)로 선택지가 가장 적은 칸부터 고르는 탐색을 옆에 두면 두 탐색 나무의 크기를 나란히 잴 수 있어요.
 
+목록 밖에서 70판 뒤에 해 볼 것이에요. 질량을 맞춘 뒤 점을 칸의 질량 중심으로 옮기기를 되풀이하면 용량 제약 점 분포(Michael Balzer, Thomas Schlömer, Oliver Deussen, 2009)가 되고, 이것을 파워 다이어그램 위의 최적 수송으로 다시 쓴 것이 페르난두 지 고이스(Fernando de Goes)와 동료들의 블루 노이즈(2012)예요. Laguerre Cells 의 질량 배분과 뉴턴 걸음에 점을 옮기는 걸음 하나만 더하면 돼요. 포트의 4-Z15 {0,1,4,6} 와 4-Z29 {0,1,3,7} 은 12박에 온셋 넷으로 거리 1~6 이 한 번씩 나오는데, 서로 돌리거나 뒤집은 것이 아니에요. 패터슨(A. L. Patterson)이 1944년 결정학에서 본 호모메트릭 집합을 12박 고리에서 보는 셈이라, Hexachordal Theorem 의 아래 고리에 나머지 대신 Z 짝을 두면 돼요. 세르주 오브리(Serge Aubry)의 해석성 깨짐 전이(1983)는 평균 간격이 황금비인 사슬이 K = 0.9716 을 넘으면 바닥에 갇히는 일이에요. Frenkel-Kontorova 의 고리를 공 34개와 우물 21개처럼 피보나치 수 둘로 짜면, Drive 를 0 가까이 둔 채 K 를 넘길 때 기록이 기울다가 서요. 에스하위스와 동료들은 라이덴프로스트 상태를 더 세게 흔들면 알갱이 대류가 생긴다고 2010년에 보였어요(Physical Review Letters). Granular Leidenfrost 의 뚜껑을 패널 밖으로 올리면 결정이 대류 고리 둘로 갈라지는지 볼 수 있어요. 베르트랑 뒤플랑티에(Bertrand Duplantier)와 스콧 셰필드(Scott Sheffield)는 KPZ 관계(2011)를 세려고 측도가 문턱 아래가 될 때까지 판을 이분 정사각형으로 쪼갰어요. Multiplicative Chaos 의 질량 몫으로 그렇게 쪼개면 두꺼운 점 둘레만 잘게 갈라진 격자가 나와요.
+
 ### 타이포
 
 주제 7 로 해 본 글자 실험과 다음에 해 볼 것이에요. 63판과 64판이 같이 돌며 다섯씩 처음 만들었어요. 63판의 다섯은 한글 자모가 날아와 모아쓰기로 잠기는 조립(Jamo Assembly), 놀턴과 하먼의 기호 모자이크(Type Mosaic), 호프스태터의 트립렛 그림자(Trip-let), 카프리카의 계산 종이(Kaprekar's Routine), 캐럴의 낱말 사다리(Word Ladder)예요.
@@ -4322,6 +4409,14 @@ Flock, Harmonograph, Big Type 은 처음 화면이 빨강이에요.
 
 69판 뒤에 해 볼 것이에요. 7세그먼트를 돌려 한글 자모로 읽는 놀이가 있어요. 2 는 그대로 ㄹ, 돌린 7 은 ㄴ, 0 은 ㅁ, 1 은 ㅣ 로 읽혀서 숫자 몇 개로 「르」나 「니」 같은 음절을 칠 수 있어요. Nine-fold Seal 의 접기 규칙을 백문(白文)으로 뒤집어 글자를 종이색으로 남기고 바탕을 인주로 찍거나, 칸의 마디를 한 가닥 길로 모두 이어 한 음절이 한붓그리기 미로가 되게 해 볼 만해요. 롱고롱고처럼 아래 왼쪽 줄에서 시작해 위로 올라가며 판을 돌려 읽는 쓰기나, 한 단은 내려가고 다음 단은 올라오는 세로 부스트로페돈도 Boustrophedon 의 밭에서 돼요. 같은 64×128 바닥에서 크노테 지도 대신 싱크혼(Sinkhorn) 반복으로 푼 최적 수송 지도를 미리 구워 두면, Focus 를 지나칠 때 두 지도가 남기는 자국을 나란히 세울 수 있어요. 클라베 등의 논문에서 Letter Melt 가 뺀 점탄성 용수철을 더하면 녹은 획이 꿀처럼 실을 끌다가 끊어질 거예요.
 
+70판의 다섯은 매튜 카터가 벨 센테니얼의 이음매에 판 잉크 트랩을 신문 용지의 번짐에 견준 것(Ink Traps), 永 한 글자를 붓이 다섯 획으로 쓰며 여덟 필법을 밝히는 영자팔법(Eight Principles of Yong), 도는 유리 원판의 글자를 섬광으로 필름에 찍는 사진 식자기(Photon Disk), 캐즐런 견본의 키케로 글줄이 1 LED 아래 크기까지 줄어 회색 결이 되는 견본(Quousque Tandem), 무선으로 온 점 격자 글자를 종이 테이프에 두 벌씩 찍는 헬슈라이버(Hellschreiber)예요.
+
+70판에서 본 것이에요. 다섯 다 글자 꼴을 새로 그렸는데, 글자가 LED 몇 개 크기로 줄면 글꼴보다 찍는 방식이 읽힘을 정했어요. Hellschreiber 는 테이프 한 열이 LED 한 열이라 기계의 이탤릭 기울기가 한 줄에서 꺾이는 1 LED 턱이 됐어요. 세로획이 1 LED 인 첫 글꼴은 그 턱에서 BROWN 이 BRWNN 으로 끊겨 읽혀서 세로획을 2 LED 로 굵혔어요. Eight Principles of Yong 의 13×13 한자는 21획인 趯 과 15획인 磔 이 먼저 무너져서 부수 자리와 긴 가로획만 남겼어요. 번짐과 빛도 셈과 달랐어요. Ink Traps 는 잉크를 확산과 문턱으로 번지게 하자 좁은 이음매가 모든 획을 같은 거리만큼 키울 때보다 두 배 멀리 차서, 트랩을 기하로 셈한 깊이의 1.6 배로 팠어요. 트랩은 메워지거나 열려 있거나 둘 중 하나라, 획 가장자리가 0.2 LED 더 나가면 M 의 45° 이음매 홈이 통째로 막혀요. Photon Disk 에서는 패널의 30 fps 가 스트로보가 됐어요. 원판 글리프가 1초에 21개씩 창을 지나면 섬광이 거의 매 프레임 터져서, 도는 원판의 창 안에서 글자가 S, T, U 로 한 칸씩 넘어가는 것처럼 보여요. Quousque Tandem 의 1 LED 아래 글자는 눈에는 회색 결인데 잰 값으로는 계단 10~25 의 거의 평평한 면이었어요. 바탕을 켜 둔 글자 패턴에서는 세로 주제를 재는 thirds 가 말이 없었어요. Eight Principles of Yong 은 쪽빛 종이 때문에 99/99/99 였고, 종이를 검게 두고 재서야 먹의 몫 20.8/28.6/22.7 이 보였어요.
+
+기능 감은 이번에 Lab 안에서 해 볼 수 없던 크기와 모양으로 모였어요. Quousque Tandem 은 Text 레이어 크기 하한이 4 LED 라 글자가 1 LED 아래로 줄어 회색 결이 되는 것을 Lab 에서 해 볼 수 없어서, 크기를 0.5 까지 내리고 덮임을 그대로 밝기로 쓰는 길을 바랐어요. Eight Principles of Yong 은 12~16 LED 한자 픽셀 글꼴을 바랐어요. 사이트 글꼴 넷에는 한자가 없고 system 글꼴은 보는 기기마다 달라요. Photon Disk 는 Text 레이어를 한 점을 중심으로 돌리거나 원 둘레에 앉히는 길을 바랐어요. 67판과 68판이 바란 90도 돌린 글줄을 원으로 넓힌 셈이에요. Ink Traps 는 코드가 Text 레이어의 글자 비트맵을 읽어 Lab 에서 친 낱말을 잉크로 번지게 하기를 바랐어요. 63판부터 여러 판이 바란 길과 같아요. Hellschreiber 는 미리보기를 LED 몇 개 크기로 크게 보는 돋보기를 바랐어요. 글자가 어느 줄에서 꺾이는지 미리보기 크기로는 보이지 않아서, 띠를 10배로 잘라 PNG 로 뽑아 보고서야 BRWNN 을 찾았어요.
+
+70판 뒤에 해 볼 것이에요. 매튜 카터가 1996년 마이크로소프트에 그린 Verdana 는 종이 대신 화면 픽셀에 맞춘 글자라, Ink Traps 의 볼록 조각 글자와 4×4 표본 래스터를 작은 크기로 돌리면 픽셀 격자에 맞춘 획과 맞추지 않은 획을 위아래 견본으로 견줄 수 있어요. 왕희지의 「난정서(蘭亭序)」(353년)에는 之 자가 스무 번 나오고 하나도 같게 쓰지 않았다고 전해요. Eight Principles of Yong 의 붓과 붓털 문턱, 마디 시간표로 之 스무 벌을 세로로 쌓을 수 있어요. 루돌프 헬의 디지셋(Digiset, 1965)은 원판 대신 음극선관이 글자를 주사선으로 그려 필름에 찍었어요. Photon Disk 의 필름 띠와 섬광 자리에 글자를 한 줄씩 긋는 빔을 두면 돼요. 피에르시몽 푸르니에(Pierre-Simon Fournier)의 『Manuel typographique』(1764)는 활자 크기를 포인트로 맞춘 표를 실었어요. Quousque Tandem 의 넓이 합 표로 등비 대신 그 표의 크기들을 짜면 크기 사이가 고르지 않은 견본이 서요. 새뮤얼 모스(Samuel Morse)의 1844년 워싱턴–볼티모어 선은 기록기가 점과 선을 종이 테이프에 눌러 찍었어요. Hellschreiber 의 띠와 양식지, 잡음을 그대로 쓰면 같은 메시지가 점과 선으로 찍힌 띠가 헬의 글자 띠와 나란히 붙어요. 이번에 골랐다가 짜지 않은 것도 있어요. 어도비의 멀티플 마스터(Adobe Multiple Master, 1991)는 굵기와 너비 같은 축의 끝에 마스터 글꼴을 두고 그 사이를 보간해서, 노브 둘을 두 축에 걸면 한 글자가 설계 공간을 미끄러지는 「노브와 글」이 돼요.
+
 ### 화장품 팝업
 
 주제 6 으로 쓴 질감과 다음에 해 볼 질감이에요. 29판이 처음 넷을 썼어요. 팔레트 나이프로 펴 바르는 크림(Cream Swirl), 구슬이 뜬 젤과 빛 그물(Serum Gel), 쏟아져 쌓이는 글리터(Glitter Fall), 퍼프가 눌렀다 든 압축 파우더(Loose Powder)예요. 넷 다 K1 이 색상환 한 바퀴라서, 색을 돌리면 주황과 노랑이 갈색이나 올리브로 보이는 자리가 있었어요. Serum Gel 은 그 둘레에서만 밝기를 0.62 와 0.3 에서 0.92 와 0.68 로 올렸어요. 밝은 바탕은 반짝임을 지웠어요. 200 위에 55 를 더한 반짝임은 거의 안 보여서 Glitter Fall 은 어두운 바탕에 섰고, 흰 바탕과 금색 한 줄은 Loose Powder 의 아래 띠로만 썼어요. 크림과 젤은 가장자리 0.028 과 0.079 로 연구에서 가장 번지는 그림이에요. 그 둘이 가장자리 축의 아래 끝을 옮겨서 지도에 새 빈 칸이 났어요. 크림은 빛만 움직여서는 움직임이 0.019 에 머물렀어요. 결이 깊어야 빛이 돌 때 바뀌는 LED 가 생겨요. 비누막이 터질 때 구멍 가장자리가 테일러와 컬릭의 속도(1959, 1960)로 고르게 벌어지며 물방울 테를 남기는 것은 Soap Film 의 끝을 늘인 그림이에요. 클렌징 오일이 물을 만나 가장자리부터 우윳빛으로 유화되는 것은 Blotting Paper 처럼 LED 마다 한 번만 바뀌는 셈으로 그릴 만해요.
diff --git a/incoming/pattern-study/index.html b/incoming/pattern-study/index.html
index bc9ea741e..93b47f4e0 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":"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":"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":"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":"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":"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":"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":"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":"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":"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":"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":"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":"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":"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":"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":"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":"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":"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":"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":"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":"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":"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":"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":"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":"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-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":"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":"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":"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":"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":"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":"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":"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":"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":"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":"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":"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":"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":"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":"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":"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":"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":"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":"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":"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":"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":"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":"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":"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":"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":"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":"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":"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":"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-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":"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":"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":"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":"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":"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":"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":"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":"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":"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":"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":"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":"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":"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":"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":"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":"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":"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":"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":"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":"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":"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":"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":"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":"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":"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":"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":"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":"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":"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":"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":"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":"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":"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":"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":"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":"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":"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":"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":"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":"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-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":"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":"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":"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":"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":"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-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":"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":"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":"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":"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":"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":"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-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":"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":"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":["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">{"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":"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":"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":"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":"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":"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":"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":"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":"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":"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":"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":"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":"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":"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":"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":"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":"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":"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":"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":"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":"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":"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":"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":"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":"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-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":"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":"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":"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":"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":"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":"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":"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":"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":"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":"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":"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":"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":"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":"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":"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":"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":"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":"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":"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":"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":"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":"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":"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":"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":"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":"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-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":"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":"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":"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":"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":"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":"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":"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":"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":"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":"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":"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":"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":"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":"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":"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":"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":"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":"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":"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":"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":"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":"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":"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":"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":"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":"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":"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":"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":"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":"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":"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":"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":"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":"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":"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":"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":"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":"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-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":"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":"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":"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":"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":"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-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":"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":"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":"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":"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":"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":"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-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":"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":"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":["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">{"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]===`
diff --git a/incoming/pattern-study/patterns/eight-principles-of-yong.js b/incoming/pattern-study/patterns/eight-principles-of-yong.js
new file mode 100644
index 000000000..d5186fd90
--- /dev/null
+++ b/incoming/pattern-study/patterns/eight-principles-of-yong.js
@@ -0,0 +1,302 @@
+// ===== Patternflow pattern =====
+// Title:   Eight Principles of Yong
+// Family:  type
+// 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.
+// Author:  patternflow-lab
+// Date:    2026-10-29
+// SPDX-License-Identifier: CC-BY-SA-4.0
+// 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
+// Round:   70
+// ===============================
+// @matrix 64x128
+// @knobs Hue=0..1, Speed=0.2..3, Brush=-1..1, Ink=-1..1
+//
+// 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.
+// 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.
+// 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).
+// 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.
+
+const W = 64, H = 128, N = W * H;
+const { floor, ceil, min, max, abs, sqrt, sin, cos, exp, PI } = Math;
+const cl = (v, a, b) => (v < a ? a : v > b ? b : v);
+function hsv(h, s, v, out) {
+  h = (h - floor(h)) * 6;
+  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);
+  out[0] = (i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p) * 255;
+  out[1] = (i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p) * 255;
+  out[2] = (i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p) * 255;
+  return out;
+}
+
+// The five strokes of 永 in their order, each a run of knots the brush
+// passes: x, y, brush radius in LEDs, the time to reach the knot from the
+// one before and the time the brush rests there pressing down (in beats, of
+// which Speed 2 plays 1.2 a second), and which of the eight methods the
+// stretch belongs to: 0 側 the dot, 1 勒 the horizontal, 2 努 the vertical,
+// 3 趯 the hook, 4 策 the rising stroke, 5 掠 the long sweep to the left, 6 啄
+// the short peck, 7 磔 the wave to the right. The second stroke carries three
+// methods and the third two, so five strokes hold all eight.
+const STROKES = [
+  [[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]],
+  [[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],
+    [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],
+    [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]],
+  [[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],
+    [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]],
+  [[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]],
+  [[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]],
+];
+
+// The names of the eight methods, drawn for this pattern 13 LEDs square, and
+// where each stands beside its stroke, as diagrams of 永 often set them.
+const NAMES = [
+  ["..#..........", "..#.#####...#", ".#..#...#.#.#", ".#..#####.#.#", "##..#...#.#.#", ".#..#####.#.#", ".#..#...#.#.#", ".#..#####.#.#", ".#...#.#..#.#", ".#..#...#...#", ".#.#.....#..#", ".#..........#", ".#.........##"],
+  [".#.#...#.....", "#######.#....", ".#.#....#....", ".###.#######.", "...#....#...#", ".#####..#...#", ".#.#.#..#...#", ".#####..#...#", "...#...#....#", "#######.....#", "...#...#....#", "...#..#..#..#", "...#.#....##."],
+  ["..#...######.", "..#...#....#.", "#######...#..", ".#..#..#.#...", ".#.#....#....", "..##...#.#...", "##..#.#...##.", ".....#.......", "############.", ".....#.....#.", "....#......#.", "..##.....#.#.", "##........#.."],
+  ["..#...##.##..", "#####..#..#..", "..#...##.##..", ".###...#..#..", ".......#.##..", "#####.#.#....", "..#..#####...", ".##.#.#..#...", "..#...####...", "..##..#..#...", ".#..#.####...", ".#..#.#......", "#....########"],
+  [".#.....#.....", "#####.#####..", "#....#..#....", ".............", "#############", "......#......", ".###########.", ".#....#....#.", ".#....#..###.", "......#......", "....#.#.#....", "..##..#..##..", "##....#....##"],
+  [".#.....#.....", ".#..#######..", "####.........", ".#...#####...", ".#...#...#...", ".###.#...#...", "##...#####...", ".#.....#.....", ".#...#.#.#...", ".#..#..#..#..", ".#.#...#...#.", ".#.....#.....", "##....##....."],
+  [".....########", ".........#...", "........#...#", "####...#...#.", "#..#..#..##..", "#..#....##...", "#..#...#.#...", "#..#..#..##..", "#..#.#..##.#.", "####...#.#..#", "......#..#..#", ".....#...#...", "........##..."],
+  [".......#...#.", "#####.####.##", "..#...#..#.#.", "..#....##..##", ".#.....#...#.", ".####.#...##.", "##..#.#######", ".#..#...###..", ".#..#..#.#.#.", ".####.#..#..#", ".........#...", ".........#...", ".........#..."],
+];
+const SPOT = [[11, 3], [1, 17], [22, 88], [10, 114], [1, 46], [1, 72], [50, 24], [47, 110]];
+
+// Paper: a fixed scatter of short fibres, and a grain per LED that roughens
+// the edge of every stroke.
+const FIB = new Float32Array(N), GRAIN = new Float32Array(N);
+{
+  let s = 12345;
+  const rnd = () => ((s = (s * 1103515245 + 12345) >>> 0) / 4294967296);
+  for (let p = 0; p < N; p++) GRAIN[p] = rnd() * 2 - 1;
+  for (let f = 0; f < 170; f++) {
+    let x = rnd() * W, y = rnd() * H, a = rnd() * PI;
+    const len = 3 + rnd() * 6, v = 0.3 + rnd() * 0.7;
+    for (let k = 0; k < len; k++, a += (rnd() - 0.5) * 0.5) {
+      x += cos(a);
+      y += sin(a);
+      const xi = floor(x), yi = floor(y);
+      if (xi >= 0 && xi < W && yi >= 0 && yi < H) FIB[yi * W + xi] = max(FIB[yi * W + xi], v);
+    }
+  }
+}
+
+// Bristles across the brush, and the beats a finished character holds and
+// takes to fade.
+const NB = 9, HOLD = 2.8, FADE = 1.1;
+
+// Lays the strokes out as a timeline of brush samples a third of an LED
+// apart, with a little of a hand's wobble that differs from one writing to
+// the next.
+function build(S) {
+  const xs = [], ys = [], rs = [], ts = [], ds = [], ms = [], ss = [], ks = [], txs = [], tys = [];
+  const air = [];
+  let t = 0, px = 46, py = -6;
+  STROKES.forEach((knots, k) => {
+    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]]);
+    const dist = sqrt((P[0][0] - px) ** 2 + (P[0][1] - py) ** 2), at = 0.18 + dist / 150;
+    air.push([t, t + at, px, py, P[0][0], P[0][1], P[0][2]]);
+    t += at;
+    let s = 0, lx = P[0][0], ly = P[0][1];
+    const push = (x, y, r, tt, dw, m) => {
+      s += sqrt((x - lx) ** 2 + (y - ly) ** 2);
+      const dx = x - lx, dy = y - ly, L = sqrt(dx * dx + dy * dy);
+      if (L > 1e-3) txs.push(dx / L), tys.push(dy / L);
+      else txs.push(txs.length ? txs[txs.length - 1] : 1), tys.push(tys.length ? tys[tys.length - 1] : 0);
+      xs.push(x), ys.push(y), rs.push(r), ts.push(tt), ds.push(dw), ms.push(m), ss.push(s), ks.push(k);
+      lx = x;
+      ly = y;
+    };
+    push(P[0][0], P[0][1], P[0][2], t, P[0][4], P[0][5]);
+    t += P[0][4];
+    for (let i = 1; i < P.length; i++) {
+      const a = P[max(0, i - 2)], b = P[i - 1], c = P[i], d = P[min(P.length - 1, i + 1)];
+      const L = sqrt((c[0] - b[0]) ** 2 + (c[1] - b[1]) ** 2), n = max(1, ceil(L / 0.33));
+      for (let j = 1; j <= n; j++) {
+        const u = j / n, u2 = u * u, u3 = u2 * u;
+        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);
+        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]);
+      }
+      t += c[3] + c[4];
+    }
+    px = P[P.length - 1][0];
+    py = P[P.length - 1][1];
+  });
+  S.n = xs.length;
+  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);
+  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);
+  S.air = air;
+  S.end = t;
+  // Each stroke's bristles: the ink level at which each one gives out, and
+  // a slow wobble along the stroke so the dry streaks break and rejoin.
+  S.theta = [];
+  S.wf = [];
+  S.wp = [];
+  for (let k = 0; k < 5; k++) {
+    const th = [];
+    for (let b = 0; b < NB; b++) th.push(0.08 + (0.84 * (b + Math.random())) / NB);
+    for (let b = NB - 1; b > 0; b--) {
+      const j = floor(Math.random() * (b + 1));
+      [th[b], th[j]] = [th[j], th[b]];
+    }
+    S.theta.push(th);
+    S.wf.push(Array.from({ length: NB }, () => 0.15 + Math.random() * 0.25));
+    S.wp.push(Array.from({ length: NB }, () => Math.random() * 6.3));
+  }
+  // The time each method starts, for its name.
+  S.mt = new Float32Array(8).fill(1e9);
+  for (let i = 0; i < S.n; i++) if (S.t[i] < S.mt[S.m[i]]) S.mt[S.m[i]] = S.t[i];
+}
+
+function fresh(S) {
+  S.T = 0;
+  S.i = 0;
+  S.dw = -1;
+  S.cov.fill(0);
+  S.bleed.fill(0);
+  S.mid.fill(-1);
+  S.t0.fill(-1);
+  build(S);
+}
+
+export function setup(params) {
+  const S = (params.yong = {
+    cov: new Float32Array(N), bleed: new Float32Array(N), mid: new Int8Array(N), t0: new Float32Array(N),
+    hue: 0, speed: 2, brush: 0, ink: 0.06, started: false,
+  });
+  fresh(S);
+}
+
+// One brush sample pressed into the paper. grow is how far into its rest the
+// brush is, 0 to 1: a resting brush spreads and pools its ink.
+function stamp(S, i, grow) {
+  const k = S.k[i], s = S.s[i], q = S.ink, wet = max(0, q);
+  const rr = S.r[i] * (1 + 0.45 * S.brush) * (1 + 0.12 * wet) * (1 + 0.14 * grow);
+  if (rr < 0.12) return;
+  const rate = 0.0055 * (1 - 0.6 * q) * (q < 0 ? 1 - 0.3 * q : 1);
+  let L = 1.05 + 0.2 * q - s * rate;
+  if (grow > 0) L = max(L, 0.75 + 0.3 * grow);
+  const dens = cl(0.5 + 0.5 * L, 0.45, 1);
+  const hw = 3.2 * wet + 1.4 * grow * (0.25 + wet);
+  const cx = S.x[i], cy = S.y[i], nx = -S.ty[i], ny = S.tx[i];
+  const th = S.theta[k], wf = S.wf[k], wp = S.wp[k];
+  const R = rr + hw + 1;
+  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));
+  for (let y = y0; y <= y1; y++)
+    for (let x = x0; x <= x1; x++) {
+      const dx = x - cx, dy = y - cy, dist = sqrt(dx * dx + dy * dy), p = y * W + x, d = dist - rr;
+      if (S.t0[p] < 0 && d < hw + 0.5) S.t0[p] = S.T;
+      const c = cl(0.6 - d + 0.35 * GRAIN[p], 0, 1);
+      if (c > 0) {
+        const u = (dx * nx + dy * ny) / rr;
+        const b = cl(floor((u + 1) * 0.5 * NB), 0, NB - 1);
+        const dep = cl((max(L, 0.3) + 0.28 * sin(s * wf[b] + wp[b]) - th[b]) * 5, 0, 1);
+        const v = c * dep * dens;
+        if (v > S.cov[p]) {
+          S.cov[p] = v;
+          S.mid[p] = S.m[i];
+        }
+      }
+      if (hw > 0.05 && d > -0.5 && d < hw) {
+        const bv = (0.2 + 0.25 * wet) * cl(1 - (d + 0.6 * GRAIN[p] + 0.5 * FIB[p]) / hw, 0, 1);
+        if (bv > S.bleed[p]) S.bleed[p] = bv;
+      }
+    }
+}
+
+function advance(S, dt) {
+  S.T += dt * S.speed * 0.6;
+  const T = S.T;
+  if (S.dw >= 0) {
+    const g = min(1, (T - S.t[S.dw]) / S.d[S.dw]);
+    stamp(S, S.dw, g);
+    if (g >= 1) S.dw = -1;
+  }
+  while (S.i < S.n && S.t[S.i] <= T) {
+    const i = S.i++;
+    if (S.d[i] > 0) {
+      const g = min(1, (T - S.t[i]) / S.d[i]);
+      stamp(S, i, g);
+      if (g < 1) {
+        S.dw = i;
+        break;
+      }
+    } else stamp(S, i, 0);
+  }
+  if (T > S.end + HOLD + FADE) fresh(S);
+}
+
+export function update(dt, input, params) {
+  if (!params.yong) setup(params);
+  const S = params.yong, k = input.knobValues || [0, 2, 0, 0.06];
+  dt = cl(dt || 0, 0, 0.1);
+  S.hue = cl(k[0], 0, 1);
+  S.speed = cl(k[1], 0.2, 3);
+  S.brush = cl(k[2], -1, 1);
+  S.ink = cl(k[3], -1, 1);
+  if (!S.started) {
+    // A fresh start opens with the dot written and the brush on its way to
+    // the horizontal.
+    S.started = true;
+    for (let j = 0; j < 36; j++) advance(S, 1 / 30 / (S.speed * 0.6));
+  }
+  advance(S, dt);
+}
+
+export function draw(display, params) {
+  const S = params.yong;
+  if (!S) return;
+  const T = S.T, h0 = 0.115 + S.hue;
+  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]);
+  const fade = T > S.end + HOLD ? cl(1 - (T - S.end - HOLD) / FADE, 0, 1) : 1;
+  // While the finished character holds, each method lights in turn.
+  const hiT = T - S.end - 0.3, hiM = hiT >= 0 && hiT < 8 * 0.28 ? floor(hiT / 0.28) : -1, hiA = hiM >= 0 ? sin((PI * (hiT - hiM * 0.28)) / 0.28) : 0;
+  for (let p = 0, y = 0; y < H; y++)
+    for (let x = 0; x < W; x++, p++) {
+      const f = 0.82 + 0.45 * FIB[p] + 0.06 * GRAIN[p];
+      let r = paper[0] * f, g = paper[1] * f, b = paper[2] * f;
+      const t0 = S.t0[p];
+      if (t0 >= 0) {
+        const age = T - t0, cv = S.cov[p], bl = S.bleed[p] * min(1, age / 0.9);
+        const a = max(cv, bl) * fade;
+        if (a > 0) {
+          r += (ink[0] - r) * a;
+          g += (ink[1] - g) * a;
+          b += (ink[2] - b) * a;
+          let wh = 0.5 * exp(-age / 0.35) * cv;
+          if (hiM >= 0 && S.mid[p] === hiM) wh += 0.55 * hiA * cv;
+          wh *= fade;
+          r += (255 - r) * wh;
+          g += (255 - g) * wh;
+          b += (255 - b) * wh;
+        }
+      }
+      display.setPixel(x, y, r, g, b);
+    }
+  // The names, each lighting as its method begins.
+  for (let m = 0; m < 8; m++) {
+    const st = S.mt[m];
+    if (T < st) continue;
+    const age = T - st;
+    let v = (0.62 + 0.38 * exp(-age / 0.6)) * min(1, age / 0.15) * fade;
+    if (m === hiM) v = min(1, v + 0.5 * hiA);
+    const G = NAMES[m], [ox, oy] = SPOT[m];
+    for (let gy = -1; gy <= 13; gy++)
+      for (let gx = -1; gx <= 13; gx++) {
+        const x = ox + gx, y = oy + gy;
+        if (x < 0 || x >= W || y < 0 || y >= H) continue;
+        const on = gy >= 0 && gy < 13 && gx >= 0 && gx < 13 && G[gy][gx] === "#";
+        if (on) display.setPixel(x, y, lab[0] * v + 40 * v * v, lab[1] * v + 40 * v * v, lab[2] * v + 40 * v * v);
+      }
+  }
+  // The brush between strokes, a faint ring where it will come down.
+  for (const a of S.air)
+    if (T >= a[0] && T < a[1]) {
+      const u = (T - a[0]) / (a[1] - a[0]), e = u * u * (3 - 2 * u);
+      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;
+      for (let y = max(0, floor(by - rr - 1)); y <= min(H - 1, ceil(by + rr + 1)); y++)
+        for (let x = max(0, floor(bx - rr - 1)); x <= min(W - 1, ceil(bx + rr + 1)); x++) {
+          const d = abs(sqrt((x - bx) ** 2 + (y - by) ** 2) - rr);
+          if (d < 0.7) display.setPixel(x, y, 60 + ink[0] * 0.25, 60 + ink[1] * 0.25, 60 + ink[2] * 0.25);
+        }
+    }
+}
diff --git a/incoming/pattern-study/patterns/frenkel-kontorova.js b/incoming/pattern-study/patterns/frenkel-kontorova.js
new file mode 100644
index 000000000..e12720ba4
--- /dev/null
+++ b/incoming/pattern-study/patterns/frenkel-kontorova.js
@@ -0,0 +1,222 @@
+// ===== Patternflow pattern =====
+// Title:   Frenkel-Kontorova
+// Family:  sim
+// 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.
+// Author:  patternflow-lab
+// Date:    2026-10-29
+// SPDX-License-Identifier: CC-BY-SA-4.0
+// Lineage: Frenkel-Kontorova model (Yakov Frenkel and Tatiana Kontorova, 1938), the damped chain of Kibble-Zurek Ions (pattern round 64), pattern round 70
+// Round:   70
+// ===============================
+// @matrix 64x128
+// @knobs Hue=0..1, Drive=0..3, Misfit=0.86..1.2, Substrate=1..4
+//
+// 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.
+// 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.
+// 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.
+// 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.
+// Buttons: K2 tap turns the push round, so the kinks turn back and their bands bend into a V.
+
+const W = 64, H = 128;
+const { floor, round, min, max, abs, sqrt, sin, cos, PI } = Math;
+const cl = (v, a, b) => (v < a ? a : v > b ? b : v);
+const TAU = 2 * PI;
+
+// The ring: M wells P LEDs apart round the panel's width. Chain positions
+// are in wells, well j at x = j, drawn at column P j + P/2.
+const M = 12, P = W / M, NMAX = 24;
+// The history: one row every ROW_T seconds in rows 0 to HR - 1, oldest on
+// top and newest at the bottom. The chain view under it: valley floors on
+// row YB.
+const HR = 113, YB = 125, ROW_T = 1 / 12;
+// Simulation: TS time units a second in steps of DT, damping GAMMA.
+const TS = 6, DT = 0.04, GAMMA = 0.3;
+
+function hsv(h, s, v, o) {
+  h = (h - floor(h)) * 6;
+  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);
+  o[0] = i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p;
+  o[1] = i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p;
+  o[2] = i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p;
+  return o;
+}
+
+function gauss() {
+  return (Math.random() + Math.random() + Math.random() - 1.5) * 2;
+}
+
+export function setup(params) {
+  params.s = {
+    n: 0, x: new Float64Array(NMAX), v: new Float64Array(NMAX), f: new Float64Array(NMAX),
+    K: 1, F: 0, dir: 1, temp: 0.001, hue: 0, rowT: 0, head: 0, started: false,
+    hist: new Float32Array(HR * W * 3), strain: new Float32Array(W), sm: new Float32Array(W),
+    rgb: new Float32Array(W * H * 3), c: [0, 0, 0], c2: [0, 0, 0],
+  };
+  return params.s;
+}
+
+function load(S, n) {
+  S.n = n;
+  const a = M / n, off = Math.random();
+  for (let i = 0; i < n; i++) (S.x[i] = off + i * a), (S.v[i] = 0);
+}
+
+function forces(S) {
+  const n = S.n, x = S.x, f = S.f, k = S.K / TAU;
+  for (let i = 0; i < n; i++) {
+    const xl = i > 0 ? x[i - 1] : x[n - 1] - M, xr = i < n - 1 ? x[i + 1] : x[0] + M;
+    f[i] = xr - 2 * x[i] + xl - k * sin(TAU * x[i]) + S.F;
+  }
+}
+
+function step(S, h) {
+  const n = S.n, x = S.x, v = S.v, f = S.f;
+  forces(S);
+  const kick = sqrt(2 * GAMMA * S.temp * h), g = 1 - GAMMA * h;
+  for (let i = 0; i < n; i++) {
+    v[i] = (v[i] + f[i] * h) * g + kick * gauss();
+    x[i] += v[i] * h;
+  }
+  if (x[0] >= M) for (let i = 0; i < n; i++) x[i] -= M;
+  else if (x[0] < 0) for (let i = 0; i < n; i++) x[i] += M;
+}
+
+// Strain of each column: the stretch of the bond over it, in wells, spread
+// over five columns so a kink reads as a band.
+function strainRow(S) {
+  const n = S.n, x = S.x, st = S.strain, sm = S.sm;
+  for (let i = 0; i < n; i++) {
+    const xa = x[i], xb = i < n - 1 ? x[i + 1] : x[0] + M, s = xb - xa - 1;
+    const c0 = P * xa + P / 2, c1 = P * xb + P / 2;
+    for (let c = Math.ceil(c0 - 0.5); c < c1 - 0.5; c++) st[((c % W) + W) % W] = s;
+  }
+  for (let c = 0; c < W; c++)
+    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;
+  return sm;
+}
+
+// The colour of a strain: blue where the chain lies one ball to a well,
+// green where it is stretched, magenta where it is squeezed.
+function strainColour(S, s, v, o) {
+  const a = cl((abs(s) - 0.04) / 0.32, 0, 1);
+  const h = s > 0 ? 0.64 + (0.42 - 0.64) * a : 0.64 + (0.88 - 0.64) * a;
+  return hsv(h + S.hue, 0.55 + 0.35 * a, v, o);
+}
+
+// One row of the history: the strain as a dim band, each ball's worldline
+// over it, and two balls, the first and the middle one, in cream so their
+// steps can be followed down the record.
+function record(S) {
+  S.head = (S.head + 1) % HR;
+  const row = S.head * W * 3, hist = S.hist, sm = strainRow(S), c = S.c;
+  for (let X = 0; X < W; X++) {
+    const s = sm[X], a = cl((abs(s) - 0.04) / 0.32, 0, 1);
+    strainColour(S, s, 0.05 + 0.42 * a * a, c);
+    hist[row + X * 3] = c[0];
+    hist[row + X * 3 + 1] = c[1];
+    hist[row + X * 3 + 2] = c[2];
+  }
+  for (let i = 0; i < S.n; i++) {
+    const px = (((P * S.x[i] + P / 2 - 0.5) % W) + W) % W, X0 = floor(px), fr = px - X0;
+    const s = sm[X0], a = cl((abs(s) - 0.04) / 0.32, 0, 1), tracer = i === 0 || i === S.n >> 1;
+    strainColour(S, s, 1, c);
+    if (tracer) (c[0] = 1), (c[1] = 0.95), (c[2] = 0.8);
+    const v = tracer ? 1 : 0.45 + 0.55 * a;
+    for (const [X, w] of [[X0, 1 - fr], [(X0 + 1) % W, fr]]) {
+      const o = row + X * 3, k = w * v;
+      const m = tracer ? 0 : 0.65 - 0.35 * a;
+      hist[o] = max(hist[o], (m + (1 - m) * c[0]) * k);
+      hist[o + 1] = max(hist[o + 1], (m + (1 - m) * c[1]) * k);
+      hist[o + 2] = max(hist[o + 2], (m + (1 - m) * c[2]) * k);
+    }
+  }
+}
+
+function advance(S, d) {
+  const steps = max(1, round((d * TS) / DT)), h = (d * TS) / steps;
+  for (let k = 0; k < steps; k++) step(S, h);
+  S.rowT += d;
+  while (S.rowT >= ROW_T) {
+    S.rowT -= ROW_T;
+    record(S);
+  }
+}
+
+export function update(dt, input, params) {
+  const S = params.s || setup(params);
+  const kv = input.knobValues || [0, 2, 0.86, 1], d = cl(dt || 0, 0, 0.1);
+  S.hue = kv[0] || 0;
+  S.K = cl(kv[3], 1, 4);
+  if (input.btnPressed && input.btnPressed[1]) S.dir = -S.dir;
+  const dr = cl(kv[1], 0, 3);
+  S.F = (S.dir * (0.04 * dr + 0.1 * dr * dr)) / TAU;
+  const n = cl(round(M / cl(kv[2], 0.86, 1.2)), 10, 14);
+  if (n !== S.n) load(S, n);
+  if (!S.started) {
+    S.started = true;
+    for (let f = 0; f < HR * 3; f++) advance(S, 1 / 30);
+  }
+  advance(S, d);
+}
+
+function surface(S, X) {
+  const u = (X + 0.5) / P - 0.5, A = 3 + 1.25 * S.K;
+  return YB - (A * (1 - cos(TAU * u))) / 2;
+}
+
+function plot(rgb, X, Y, r, g, b, a) {
+  if (Y < 0 || Y >= H || a <= 0) return;
+  X = ((X % W) + W) % W;
+  const o = (Y * W + X) * 3;
+  rgb[o] = max(rgb[o], r * a);
+  rgb[o + 1] = max(rgb[o + 1], g * a);
+  rgb[o + 2] = max(rgb[o + 2], b * a);
+}
+
+export function draw(display, params) {
+  const S = params.s;
+  if (!S || !S.n) return;
+  const rgb = S.rgb, c = S.c, c2 = S.c2, n = S.n, x = S.x;
+  rgb.fill(0);
+  // The floor: a ridge line over a dim fill down to the valley floors.
+  hsv(0.64 + S.hue, 0.55, 1, c2);
+  for (let X = 0; X < W; X++) {
+    const ys = surface(S, X);
+    for (let Y = floor(ys) + 1; Y <= YB + 2; Y++) plot(rgb, X, Y, c2[0], c2[1], c2[2], 0.3 - 0.15 * cl((Y - ys) / 8, 0, 1));
+    plot(rgb, X, floor(ys), c2[0], c2[1], c2[2], 0.55 + 0.45 * (1 - (ys - floor(ys))));
+  }
+  // Bonds between the balls, coloured by their stretch, then the balls.
+  const sm = strainRow(S);
+  const bx = (i) => P * x[i] + P / 2 - 0.5;
+  const by = (X) => surface(S, ((X % W) + W) % W) - 1.8;
+  for (let i = 0; i < n; i++) {
+    const xa = bx(i), xb = i < n - 1 ? bx(i + 1) : bx(0) + W, ya = by(xa), yb = by(xb);
+    strainColour(S, (xb - xa) / P - 1, 1, c);
+    const len = max(2, Math.ceil(abs(xb - xa) + abs(yb - ya)) * 2);
+    for (let k = 0; k <= len; k++) {
+      const t = k / len;
+      plot(rgb, round(xa + (xb - xa) * t), round(ya + (yb - ya) * t), c[0], c[1], c[2], 0.8);
+    }
+  }
+  for (let i = 0; i < n; i++) {
+    const X = bx(i), Y = by(X);
+    strainColour(S, sm[((round(X) % W) + W) % W], 1, c);
+    if (i === 0 || i === n >> 1) (c[0] = 1), (c[1] = 0.95), (c[2] = 0.8);
+    for (let yy = floor(Y - 3); yy <= Math.ceil(Y + 3); yy++)
+      for (let xx = floor(X - 3); xx <= Math.ceil(X + 3); xx++) {
+        const e2 = (xx - X) * (xx - X) + (yy - Y) * (yy - Y), a = cl(2.2 - e2 / 2.4, 0, 1);
+        const w = cl(1 - e2 / 3, 0, 1);
+        plot(rgb, xx, yy, c[0] + (1 - c[0]) * w, c[1] + (1 - c[1]) * w, c[2] + (1 - c[2]) * w, a);
+      }
+  }
+  // The history, oldest row on top.
+  for (let r = 0; r < HR; r++) {
+    const src = ((S.head + 1 + r) % HR) * W * 3, dst = r * W * 3;
+    for (let k = 0; k < W * 3; k++) rgb[dst + k] = S.hist[src + k];
+  }
+  for (let Y = 0; Y < H; Y++)
+    for (let X = 0; X < W; X++) {
+      const o = (Y * W + X) * 3;
+      display.setPixel(X, Y, min(255, rgb[o] * 255) | 0, min(255, rgb[o + 1] * 255) | 0, min(255, rgb[o + 2] * 255) | 0);
+    }
+}
diff --git a/incoming/pattern-study/patterns/granular-leidenfrost.js b/incoming/pattern-study/patterns/granular-leidenfrost.js
new file mode 100644
index 000000000..1b177cde2
--- /dev/null
+++ b/incoming/pattern-study/patterns/granular-leidenfrost.js
@@ -0,0 +1,182 @@
+// ===== Patternflow pattern =====
+// Title:   Granular Leidenfrost
+// Family:  particle
+// 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.
+// Author:  patternflow-lab
+// Date:    2026-10-29
+// SPDX-License-Identifier: CC-BY-SA-4.0
+// 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
+// Round:   70
+// ===============================
+// @matrix 64x128
+// @knobs Hue=0..1, Shaking=0.5..3, Restitution=0.88..0.98, Grains=320..440
+//
+// 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.
+// 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.
+// 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.
+// 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.
+
+const W = 64, H = 128;
+const { floor, ceil, round, min, max, abs, sqrt, exp, log10 } = Math;
+const cl = (v, a, b) => (v < a ? a : v > b ? b : v);
+
+function hsv(h, s, v, out) {
+  h = (h - floor(h)) * 6;
+  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);
+  out[0] = i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p;
+  out[1] = i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p;
+  out[2] = i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p;
+  return out;
+}
+
+// Lengths in LEDs, time in the panel's seconds. z counts up from the floor,
+// the top edge of the bottom row, to the lid, the top edge of row 0. Grains
+// are hard disks of radius R, 16 to a layer across the 64 columns.
+const ZTOP = H - 1, R = 2, D = 2 * R, NMAX = 440;
+const GRAV = 40;
+// The floor is a sawtooth driver in the limit of a small, fast stroke: it
+// stays at z = 0 and always meets a grain moving up at U, so a grain
+// landing at speed v leaves at U + E_FLOOR (U + v), with up to 15% of that
+// impact turned sideways by the floor's roughness.
+const U_PER = 52, E_FLOOR = 0.8, E_WALL = 0.9, ROUGH = 0.15;
+// A substep is at most 1/240 s and short enough that the fastest grain
+// moves at most 1.2 LEDs in it, under a third of its width.
+const SUBSTEP = 1 / 240, REACH = 1.2;
+// Grains are drawn a little smaller than they are, so a packed cluster
+// shows as grains and not as a slab.
+const RD = 1.6;
+
+export function setup(params) {
+  params.s = {
+    n: 0, hue: 0, U: 0, e: 0.88,
+    x: new Float32Array(NMAX), z: new Float32Array(NMAX), vx: new Float32Array(NMAX), vz: new Float32Array(NMAX),
+    heat: new Float32Array(NMAX),
+    head: new Int32Array(16 * 33), next: new Int32Array(NMAX),
+    rgb: new Float32Array(W * H * 3), c: [0, 0, 0],
+  };
+  return params.s;
+}
+
+// A fresh box: 85% of the grains packed in staggered rows from 52 LEDs up,
+// the rest scattered under them as a gas, so the first seconds already
+// show a cluster settling onto its gas rather than a heap waking up.
+function start(S, n) {
+  S.n = n;
+  const per = W / D;
+  let i = 0;
+  for (let r = 0; i < n * 0.85; r++)
+    for (let c = 0; c < per && i < n; c++, i++) {
+      S.x[i] = R + c * D + (r & 1 ? R * 0.5 : 0);
+      S.z[i] = 52 + r * D * 0.9;
+      S.vx[i] = (Math.random() - 0.5) * 4;
+      S.vz[i] = 0;
+    }
+  for (; i < n; i++) {
+    S.x[i] = R + Math.random() * (W - D);
+    S.z[i] = R + Math.random() * 44;
+    S.vx[i] = (Math.random() - 0.5) * 80;
+    S.vz[i] = (Math.random() - 0.5) * 80;
+  }
+  S.heat.fill(0);
+}
+
+// One substep. Grains collide as hard disks with restitution e along the
+// line of centres, found through a grid of cells one grain across; any
+// overlap left is pushed apart along the same line.
+function step(S, h) {
+  const { x, z, vx, vz, head, next, n, U, e } = S;
+  for (let i = 0; i < n; i++) {
+    vz[i] -= GRAV * h;
+    x[i] += vx[i] * h;
+    z[i] += vz[i] * h;
+    if (z[i] < R) {
+      z[i] = R;
+      const s = U - vz[i];
+      if (s > 0) {
+        vz[i] = U + E_FLOOR * s;
+        vx[i] += (Math.random() - 0.5) * 2 * ROUGH * s;
+      }
+    } else if (z[i] > ZTOP - R) {
+      z[i] = ZTOP - R;
+      if (vz[i] > 0) vz[i] = -E_WALL * vz[i];
+    }
+    if (x[i] < R) (x[i] = R), (vx[i] = abs(vx[i]) * E_WALL);
+    else if (x[i] > W - R) (x[i] = W - R), (vx[i] = -abs(vx[i]) * E_WALL);
+  }
+  const CW = W / D, CH = 33;
+  head.fill(-1);
+  for (let i = 0; i < n; i++) {
+    const c = cl(floor(z[i] / D), 0, CH - 1) * CW + cl(floor(x[i] / D), 0, CW - 1);
+    next[i] = head[c];
+    head[c] = i;
+  }
+  for (let i = 0; i < n; i++) {
+    const cx = cl(floor(x[i] / D), 0, CW - 1), cz = cl(floor(z[i] / D), 0, CH - 1);
+    for (let gz = max(0, cz - 1); gz <= min(CH - 1, cz + 1); gz++)
+      for (let gx = max(0, cx - 1); gx <= min(CW - 1, cx + 1); gx++)
+        for (let j = head[gz * CW + gx]; j >= 0; j = next[j]) {
+          if (j <= i) continue;
+          const dx = x[j] - x[i], dz = z[j] - z[i], d2 = dx * dx + dz * dz;
+          if (d2 >= D * D || d2 < 1e-9) continue;
+          const d = sqrt(d2), nx = dx / d, nz = dz / d;
+          const vn = (vx[j] - vx[i]) * nx + (vz[j] - vz[i]) * nz;
+          if (vn < 0) {
+            const J = (-(1 + e) * vn) / 2;
+            vx[i] -= J * nx;
+            vz[i] -= J * nz;
+            vx[j] += J * nx;
+            vz[j] += J * nz;
+          }
+          const o = (D - d) / 2;
+          x[i] -= o * nx;
+          z[i] -= o * nz;
+          x[j] += o * nx;
+          z[j] += o * nz;
+        }
+  }
+}
+
+export function update(dt, input, params) {
+  const S = params.s || setup(params);
+  const kv = input.knobValues || [0, 2, 0.88, 320], d = cl(dt || 0, 0, 0.1);
+  S.hue = kv[0] || 0;
+  S.U = U_PER * cl(kv[1] ?? 2, 0.5, 3);
+  S.e = cl(kv[2] ?? 0.88, 0.88, 0.98);
+  const n = round(cl(kv[3] ?? 320, 320, 440) / 10) * 10;
+  if (n !== S.n) start(S, n);
+  let vm = 0;
+  for (let i = 0; i < S.n; i++) vm = max(vm, S.vx[i] * S.vx[i] + S.vz[i] * S.vz[i]);
+  const sub = min(48, max(1, ceil(d / SUBSTEP), ceil((d * (sqrt(vm) + 3 * S.U)) / REACH)));
+  for (let k = 0; k < sub; k++) step(S, d / sub);
+  // Each grain's heat, its squared speed smoothed over 0.375 s.
+  const a = 1 - exp(-d / 0.375);
+  for (let i = 0; i < S.n; i++) S.heat[i] += a * (S.vx[i] * S.vx[i] + S.vz[i] * S.vz[i] - S.heat[i]);
+}
+
+export function draw(display, params) {
+  const S = params.s;
+  if (!S || !S.n) return;
+  const rgb = S.rgb, c = S.c, U2 = S.U * S.U;
+  rgb.fill(0);
+  for (let i = 0; i < S.n; i++) {
+    // Heat on a log scale against the floor's speed: 0 for a grain moving
+    // at 1/18 of U or slower, 1 for one moving at U.
+    const heat = cl(log10(max(1e-6, S.heat[i] / U2)) / 2.5 + 1, 0, 1);
+    hsv(0.55 + S.hue + 0.38 * heat, 0.85 - 0.35 * heat, 1, c);
+    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;
+    for (let y = max(0, floor(py - rr)); y <= min(H - 1, floor(py + rr)); y++)
+      for (let x = max(0, floor(px - rr)); x <= min(W - 1, floor(px + rr)); x++) {
+        const dd = sqrt((x + 0.5 - px) ** 2 + (y + 0.5 - py) ** 2);
+        const v = body * cl(RD + 0.5 - dd, 0, 1) + gl * exp(-max(0, dd - RD) / 1.4), o = (y * W + x) * 3;
+        rgb[o] += c[0] * v;
+        rgb[o + 1] += c[1] * v;
+        rgb[o + 2] += c[2] * v;
+      }
+  }
+  // The floor, the bottom row, brighter the faster it strikes.
+  const fl = 0.25 + (0.2 * S.U) / (3 * U_PER);
+  for (let x = 0, o = (H - 1) * W * 3; x < W; x++, o += 3) (rgb[o] += fl * 0.9), (rgb[o + 1] += fl * 0.9), (rgb[o + 2] += fl);
+  for (let y = 0, o = 0; y < H; y++)
+    for (let x = 0; x < 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);
+}
diff --git a/incoming/pattern-study/patterns/hellschreiber.js b/incoming/pattern-study/patterns/hellschreiber.js
new file mode 100644
index 000000000..d68890411
--- /dev/null
+++ b/incoming/pattern-study/patterns/hellschreiber.js
@@ -0,0 +1,262 @@
+// ===== Patternflow pattern =====
+// Title:   Hellschreiber
+// Family:  type
+// 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.
+// Author:  patternflow-lab
+// Date:    2026-10-29
+// SPDX-License-Identifier: CC-BY-SA-4.0
+// 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
+// Round:   70
+// ===============================
+// @matrix 64x128
+// @knobs Paper=0..1, Speed=0.2..3, Noise=0..1, Drift=-1..1
+//
+// 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.
+// 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.
+// 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.
+// 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.
+
+const W = 64, H = 128;
+const { floor, min, max, sqrt, sin, log, cos, PI } = Math;
+const cl = (v, a, b) => (v < a ? a : v > b ? b : v);
+function hsv(h, s, v) {
+  h = (h - floor(h)) * 6;
+  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);
+  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];
+}
+
+// ---- The face: 5 columns by 7 rows, rows from the top, drawn bold for
+// this pattern, the letters and figures the messages use. Feld-Hell sends a
+// letter as 7 columns, the glyph's 5 and 2 blank; a space here is 7 blank
+// columns. The upright strokes are two columns wide, so when the receiver
+// is out of phase and a glyph's lower rows land one column to the left of
+// its upper rows (the print's own slant, on a tape one LED a column), the
+// stroke still joins.
+const FACE = {
+  A: ".###.##.####.#########.####.####.##", B: "####.##.####.######.##.####.######.", C: ".######...##...##...##...##....####",
+  D: "####.##.####.####.####.####.######.", E: "#######...##...####.##...##...#####", F: "#######...##...####.##...##...##...",
+  G: ".######...##...##.####.####.##.####", H: "##.####.####.#########.####.####.##", I: "####..##...##...##...##...##..####.",
+  J: "..###...##...##...##...####.##.###.", K: "##..###.######.###..####.##.####..#", L: "##...##...##...##...##...##...#####",
+  M: "#...###.########.#.##...##...##...#", N: "#...###..####.##.####..###...##...#", O: ".###.##.####.####.####.####.##.###.",
+  P: "####.##.####.######.##...##...##...", Q: ".###.##.####.####.#########.#..##.#", R: "####.##.####.######.####.##.####.##",
+  S: ".######...##....###....##...######.", T: "#####.##...##...##...##...##...##..", U: "##.####.####.####.####.####.##.###.",
+  V: "##.####.####.####.####.##.###...#..", W: "#...##...##.#.##.#.########.###...#", X: "##.####.##.###...#...###.##.####.##",
+  Y: "##.####.##.###..##...##...##...##..", Z: "#####...##..##..##..##...##...#####", 1: ".##..###...##...##...##...##..####.",
+  2: ".###.##.##...##..##..##..##...#####", 5: "#######...####....##...####.##.###.", 7: "#####...##..##..##...##...##...##..",
+  9: ".###.##.####.##.####...##..##..##..", ".": "..........................##...##..", "-": "...............####................",
+};
+
+// Each glyph as 5 column masks, bit r the row r counted from the bottom,
+// since every column is sent from the bottom up.
+const GLYPH = {};
+for (const k in FACE) {
+  const f = FACE[k], cols = [];
+  for (let c = 0; c < 5; c++) {
+    let m = 0;
+    for (let r = 0; r < 7; r++) if (f[(6 - r) * 5 + c] === "#") m |= 1 << r;
+    cols.push(m);
+  }
+  GLYPH[k] = cols;
+}
+
+// ---- What is sent: the teleprinter test line, then the machine's own
+// numbers. A message starts a fresh strip of tape; inside one, a strip holds
+// whole words up to 9 letters and is cut in the space after the last.
+const 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"];
+const CAP = 9;
+// The column stream of one round of the messages, and the plan of strips
+// as [first column, end column) in it: one blank column of tape before the
+// first glyph, one after the last. Messages are 14 blank columns apart.
+const COLS = [], PLAN = [];
+for (const msg of MESSAGES) {
+  const words = msg.split(" ");
+  let line = [];
+  const flush = () => {
+    if (!line.length) return;
+    const start = COLS.length;
+    line.forEach((w, i) => {
+      if (i) for (let c = 0; c < 7; c++) COLS.push(0);
+      for (const ch of w) {
+        for (const m of GLYPH[ch]) COLS.push(m);
+        COLS.push(0, 0);
+      }
+    });
+    PLAN.push([start - 1, COLS.length - 1]);
+    for (let c = 0; c < 5; c++) COLS.push(0);
+    line = [];
+  };
+  for (const w of words) {
+    const n = line.reduce((a, x) => a + x.length + 1, 0) + w.length;
+    if (n > CAP) flush();
+    line.push(w);
+  }
+  flush();
+  for (let c = 0; c < 7; c++) COLS.push(0);
+}
+const L = COLS.length;
+
+// ---- The form: seven slots of 18 rows from row 1, each a strip of tape 16
+// rows high (a blank row, the 14 rows the helix prints, a blank row) and a
+// gap of 2 rows of form.
+const SLOT = 18, TAPE = 16, SLOTS = 7;
+// Feld-Hell turns 17.5 columns a second, 2.5 letters of 7 columns.
+const COLS_PER_S = 17.5;
+
+const hash = (a, b) => {
+  let h = Math.imul(a, 374761393) + Math.imul(b, 668265263);
+  h = Math.imul(h ^ (h >>> 13), 1274126177);
+  return ((h ^ (h >>> 16)) >>> 0) / 4294967296;
+};
+function gauss() {
+  return sqrt(-2 * log(1 - Math.random())) * cos(2 * PI * Math.random());
+}
+
+function newStrip(S) {
+  const [a, b] = PLAN[S.pi];
+  const base = S.cyc * L;
+  // The receiver keeps turning while the tape that is cut away runs out.
+  while (S.phi < base + a) S.phi += S.rho;
+  S.strips.push({ id: S.made, x0: 1 + floor(hash(S.made, 7) * 3), end: base + b, len: 0, ink: new Float32Array(W * 7) });
+  S.made++;
+}
+
+// One turn of the helix: one column of tape, the signal from sender time
+// phi to phi + rho, its 7 rows printed twice, one copy above the other.
+// Row y of the column is what the helix hears a fraction (y + 1/2) / 7 of
+// the way through the turn; when rho is not 1 that drifts through the
+// sender's rows from turn to turn.
+function turn(S) {
+  const st = S.strips[S.strips.length - 1], rho = S.rho, k = st.len;
+  for (let y = 0; y < 7; y++) {
+    const t = S.phi + (rho * (y + 0.5)) / 7, c = floor(t), r = floor((t - c) * 7);
+    const bit = (COLS[((c % L) + L) % L] >> r) & 1;
+    // Fading: a slow swell of two periods, 140 and 53 columns.
+    const fade = 1 - S.depth * (0.5 + 0.5 * sin((2 * PI * t) / 140 + 1.3 * sin((2 * PI * t) / 53)));
+    let a = bit * fade + S.sigma * gauss();
+    if (t >= S.c0 && t < S.c1) a += S.ca;
+    st.ink[k * 7 + y] = cl((a - 0.3) / 0.45, 0, 1);
+  }
+  // A static crash: a burst of 1.5 to 5 rows, somewhere in the next turn.
+  if (Math.random() < S.crash) {
+    S.c0 = S.phi + rho * (1 + Math.random());
+    S.c1 = S.c0 + 0.2 + 0.5 * Math.random();
+    S.ca = 0.8 + 0.6 * Math.random();
+  }
+  st.len++;
+  S.phi += rho;
+  // The strip is cut one blank column after its last glyph, or at the edge.
+  if (S.phi >= st.end || st.x0 + st.len >= W - 1) {
+    if (++S.pi === PLAN.length) (S.pi = 0), S.cyc++;
+    newStrip(S);
+  }
+}
+
+export function setup(params) {
+  params.s = {
+    strips: [], made: 0, pi: 0, cyc: 0, phi: PLAN[0][0] - 0.06, rho: 1, acc: 0, scroll: 0, ready: false,
+    hue: 0, speed: 2, sigma: 0.2, crash: 0.01, depth: 0.1, c0: -1, c1: -1, ca: 0,
+    buf: new Float32Array(W * H * 3),
+  };
+  newStrip(params.s);
+  return params.s;
+}
+
+function knobs(S, k) {
+  S.hue = k[0] || 0;
+  S.speed = cl(k[1] ?? 2, 0.2, 3);
+  const n = cl(k[2] || 0, 0, 1), dr = cl(k[3] ?? 0.06, -1, 1);
+  S.sigma = 0.19 + 0.37 * n;
+  S.crash = 0.006 + 0.06 * n;
+  S.depth = 0.12 + 0.45 * n;
+  // The receiver's turn against the sender's column: up to 4% slow or fast.
+  S.rho = 1 + 0.04 * dr;
+}
+
+export function update(dt, input, params) {
+  const S = params.s || setup(params);
+  const d = cl(dt || 0, 0, 0.1);
+  knobs(S, input.knobValues || [0, 2, 0, 0.06]);
+  if (!S.ready) {
+    // The form opens with five strips already pasted.
+    S.ready = true;
+    while (S.strips.length < 6) turn(S);
+  }
+  S.acc += (d * COLS_PER_S * S.speed) / 2;
+  while (S.acc >= 1) {
+    S.acc -= 1;
+    turn(S);
+  }
+  // When the seventh slot is full the form slides up a slot in 0.45 s and
+  // the top strip leaves it.
+  const target = max(0, S.strips.length - SLOTS);
+  S.scroll = min(target, S.scroll + d * 2.2 * max(1, S.speed / 2));
+  while (S.scroll >= 1) {
+    S.strips.shift();
+    S.scroll -= 1;
+  }
+}
+
+export function draw(display, params) {
+  const S = params.s;
+  if (!S) return;
+  const h = S.hue, buf = S.buf;
+  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);
+  const HD = hsv(0.12 + h, 0.55, 1);
+  // The form, with a ruled line in the middle of each gap.
+  const off = S.scroll * SLOT;
+  for (let y = 0; y < H; y++) {
+    const ry = (((y + off - 17.5) % SLOT) + SLOT) % SLOT;
+    const C = ry < 1 ? R : F;
+    for (let x = 0; x < W; x++) {
+      const p = (y * W + x) * 3;
+      buf[p] = C[0];
+      buf[p + 1] = C[1];
+      buf[p + 2] = C[2];
+    }
+  }
+  const last = S.strips.length - 1;
+  S.strips.forEach((st, j) => {
+    const Y = Math.round(1 + SLOT * (j - S.scroll));
+    if (Y > H || Y + TAPE + 1 < 0) return;
+    const x1 = st.x0 + st.len;
+    // Shadow under and right of the pasted strip.
+    for (let y = Y + 1; y <= Y + TAPE; y++)
+      for (let x = st.x0 + 1; x <= x1; x++) {
+        if (y < 0 || y >= H || x >= W) continue;
+        if (y === Y + TAPE || x === x1) {
+          const p = (y * W + x) * 3;
+          buf[p] *= 0.55;
+          buf[p + 1] *= 0.55;
+          buf[p + 2] *= 0.55;
+        }
+      }
+    for (let y = Y; y < Y + TAPE; y++) {
+      if (y < 0 || y >= H) continue;
+      const pr = Y + 14 - y, row = pr >= 0 && pr < 14 ? pr % 7 : -1;
+      for (let x = st.x0; x < x1; x++) {
+        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);
+        const p = (y * W + x) * 3;
+        buf[p] = P[0] * f * (1 - ink) + I[0] * ink;
+        buf[p + 1] = P[1] * f * (1 - ink) + I[1] * ink;
+        buf[p + 2] = P[2] * f * (1 - ink) + I[2] * ink;
+      }
+    }
+    if (j === last) {
+      // The print head at the next column: a bar over the tape, and the two
+      // points where the helix touches it, one turn's progress up the copy.
+      const hx = min(W - 1, x1), ph = floor(S.acc * 7);
+      for (let y = Y - 1; y <= Y + TAPE; y++) {
+        if (y < 0 || y >= H) continue;
+        const p = (y * W + hx) * 3, dot = y === Y + 14 - ph || y === Y + 7 - ph;
+        buf[p] = dot ? 1 : HD[0];
+        buf[p + 1] = dot ? 1 : HD[1];
+        buf[p + 2] = dot ? 1 : HD[2];
+      }
+    }
+  });
+  for (let y = 0; y < H; y++)
+    for (let x = 0; x < W; x++) {
+      const p = (y * W + x) * 3;
+      display.setPixel(x, y, (255 * buf[p]) | 0, (255 * buf[p + 1]) | 0, (255 * buf[p + 2]) | 0);
+    }
+}
diff --git a/incoming/pattern-study/patterns/hexachordal-theorem.js b/incoming/pattern-study/patterns/hexachordal-theorem.js
new file mode 100644
index 000000000..fe69df044
--- /dev/null
+++ b/incoming/pattern-study/patterns/hexachordal-theorem.js
@@ -0,0 +1,298 @@
+// ===== Patternflow pattern =====
+// Title:   Hexachordal Theorem
+// Family:  rhythm
+// 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.
+// Author:  patternflow-lab
+// Date:    2026-10-29
+// SPDX-License-Identifier: CC-BY-SA-4.0
+// 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
+// Round:   70
+// ===============================
+// @matrix 64x128
+// @knobs Hue=0..1, Speed=0.2..3, Pulses=12..20, Uneven=0..3
+//
+// 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.
+// 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.
+// 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.
+// 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.
+
+const W = 64, H = 128, N = W * H;
+const { floor, round, min, max, abs, sqrt, sin, cos, exp, PI } = Math;
+const cl = (v, a, b) => (v < a ? a : v > b ? b : v);
+function hsv(h, s, v) {
+  h = (h - floor(h)) * 6;
+  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);
+  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];
+}
+
+// The first rhythm plays in the ring at the top, its complement in the ring
+// at the bottom, and between them each distance between two onsets of a
+// rhythm is a block in a bar: the first rhythm's bars stand up from the
+// middle row, the complement's hang down.
+const RING = [[32, 20], [32, 108]], R = 15.5, UP = 59, DOWN = 68;
+
+const DIG = ["111101101101111", "010110010010111", "111001111100111", "111001111001111", "101101111001001", "111100111001111", "111100111101111", "111001001001001", "111101111101111", "111101111001111"];
+
+// The interval vector: how many pairs of onsets lie each distance apart
+// round the cycle, distance being the shorter way, 1 to n/2. who is 1 for
+// the first rhythm, 0 for its complement.
+function pairsOf(memb, n, who) {
+  const m = n / 2, by = [];
+  for (let d = 0; d <= m; d++) by.push([]);
+  for (let i = 0; i < n; i++)
+    if (memb[i] === who)
+      for (let j = i + 1; j < n; j++)
+        if (memb[j] === who) {
+          const d = min(j - i, n - j + i);
+          by[d].push([i, j]);
+        }
+  return by;
+}
+
+function rebuild(S) {
+  const n = S.n, m = n / 2, a = m - S.k;
+  S.memb = new Int8Array(n);
+  if (n === 12 && S.k === 0 && !S.opened) {
+    // The opening hexachord, x x x . . x x . . x . . as a rhythm. Its
+    // complement is no turn or mirror image of it, and has the same bars.
+    for (const s of [0, 1, 2, 5, 6, 9]) S.memb[s] = 1;
+    S.opened = true;
+  } else {
+    const idx = Array.from({ length: n }, (_, i) => i);
+    for (let i = n - 1; i > 0; i--) {
+      const j = floor(Math.random() * (i + 1));
+      [idx[i], idx[j]] = [idx[j], idx[i]];
+    }
+    for (let i = 0; i < a; i++) S.memb[idx[i]] = 1;
+  }
+  S.off = new Float32Array(n);
+  S.mt = new Float32Array(n).fill(-9);
+  S.flip = new Float32Array(n).fill(-9);
+  S.fl = new Float32Array(n);
+  S.last = -1;
+  count(S);
+  S.dA = S.vA.slice();
+  S.dB = S.vB.slice();
+}
+
+function count(S) {
+  S.pA = pairsOf(S.memb, S.n, 1);
+  S.pB = pairsOf(S.memb, S.n, 0);
+  S.vA = S.pA.map((l) => l.length);
+  S.vB = S.pB.map((l) => l.length);
+}
+
+// One move a cycle: an onset of the first rhythm and the rest beside it
+// change places, so one onset of each rhythm steps one pulse. The move that
+// changes the bars is taken where there is one, and never the one that
+// would undo the move before.
+function move(S) {
+  const n = S.n, cand = [];
+  for (let i = 0; i < n; i++)
+    if (S.memb[i] === 1)
+      for (const j of [(i + 1) % n, (i + n - 1) % 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]);
+  if (!cand.length) return;
+  const before = S.vA.join();
+  const changing = cand.filter(([i, j]) => {
+    S.memb[i] = 0, S.memb[j] = 1;
+    const v = pairsOf(S.memb, n, 1).map((l) => l.length).join();
+    S.memb[i] = 1, S.memb[j] = 0;
+    return v !== before;
+  });
+  const pool = changing.length ? changing : cand;
+  const [i, j] = pool[floor(Math.random() * pool.length)];
+  S.memb[i] = 0;
+  S.memb[j] = 1;
+  // The dots slide the short way round, one pulse.
+  const dj = (i - j + n) % n === 1 ? 1 : -1;
+  S.off[j] = dj;
+  S.off[i] = -dj;
+  S.mt[i] = S.mt[j] = S.time;
+  S.last = 1;
+  S.lastA = j;
+  S.lastB = i;
+  count(S);
+}
+
+// Uneven moves onsets from the first rhythm to its complement, one change
+// of colour each.
+function balance(S) {
+  const n = S.n, want = n / 2 - S.k;
+  let a = 0;
+  for (let i = 0; i < n; i++) a += S.memb[i];
+  while (a !== want) {
+    const from = a > want ? 1 : 0, opts = [];
+    for (let i = 0; i < n; i++) if (S.memb[i] === from) opts.push(i);
+    const s = opts[floor(Math.random() * opts.length)];
+    S.memb[s] = 1 - from;
+    S.flip[s] = S.time;
+    a += from ? -1 : 1;
+  }
+  count(S);
+}
+
+export function setup(params) {
+  params.hx = { n: 0, k: -1, P: 0, pulse: -1, time: 0, opened: false, buf: new Float32Array(N * 3) };
+}
+
+export function update(dt, input, params) {
+  if (!params.hx) setup(params);
+  const S = params.hx, kv = input.knobValues || [0, 2, 12, 0.06];
+  dt = cl(dt || 0, 0, 0.1);
+  S.hue = cl(kv[0], 0, 1);
+  S.speed = cl(kv[1], 0.2, 3);
+  const n = 2 * round(cl(kv[2], 12, 20) / 2), k = round(cl(kv[3], 0, 3));
+  if (n !== S.n) {
+    S.n = n;
+    S.k = k;
+    rebuild(S);
+  } else if (k !== S.k) {
+    S.k = k;
+    balance(S);
+  }
+  S.time += dt;
+  S.P += dt * S.speed * 2;
+  const pulse = floor(S.P);
+  if (pulse !== S.pulse) {
+    S.pulse = pulse;
+    const s = pulse % S.n;
+    if (s === 0 && pulse > 0) move(S);
+    S.fl[s] = 1;
+  }
+  const decay = exp(-dt / cl(0.85 / (S.speed * 2), 0.14, 0.7)), ease = 1 - exp(-dt / 0.25);
+  for (let i = 0; i < S.n; i++) S.fl[i] *= decay;
+  for (let d = 0; d < S.vA.length; d++) {
+    S.dA[d] += (S.vA[d] - S.dA[d]) * ease;
+    S.dB[d] += (S.vB[d] - S.dB[d]) * ease;
+  }
+}
+
+function plot(buf, x, y, c, a) {
+  x = round(x);
+  y = round(y);
+  if (x < 0 || x >= W || y < 0 || y >= H || a <= 0) return;
+  const p = (y * W + x) * 3;
+  if (c[0] * a > buf[p]) buf[p] = c[0] * a;
+  if (c[1] * a > buf[p + 1]) buf[p + 1] = c[1] * a;
+  if (c[2] * a > buf[p + 2]) buf[p + 2] = c[2] * a;
+}
+
+function line(buf, x0, y0, x1, y1, c, a) {
+  const n = max(1, Math.ceil(max(abs(x1 - x0), abs(y1 - y0)) * 1.5));
+  for (let i = 0; i <= n; i++) plot(buf, x0 + ((x1 - x0) * i) / n, y0 + ((y1 - y0) * i) / n, c, a);
+}
+
+function disc(buf, cx, cy, r, c, a) {
+  for (let y = floor(cy - r - 1); y <= cy + r + 1; y++)
+    for (let x = floor(cx - r - 1); x <= cx + r + 1; x++) {
+      const d = sqrt((x - cx) ** 2 + (y - cy) ** 2);
+      plot(buf, x, y, c, a * cl(r + 0.5 - d, 0, 1));
+    }
+}
+
+function ring(buf, cx, cy, r, c, a) {
+  const n = max(24, floor(r * 7));
+  for (let i = 0; i < n; i++) plot(buf, cx + r * cos((2 * PI * i) / n), cy + r * sin((2 * PI * i) / n), c, a);
+}
+
+function digit(buf, x, y, v, c, a) {
+  const s = String(v);
+  let w = 0;
+  for (const ch of s) w += ch === "1" && s.length > 1 ? 2 : 4;
+  let cx = x - floor((w - 1) / 2);
+  for (const ch of s) {
+    const g = DIG[+ch], narrow = ch === "1" && s.length > 1;
+    for (let r = 0; r < 5; r++)
+      for (let q = 0; q < 3; q++) if (g[r * 3 + q] === "1" && !(narrow && q !== 1)) plot(buf, cx + q - (narrow ? 1 : 0), y + r, c, a);
+    cx += narrow ? 2 : 4;
+  }
+}
+
+export function draw(display, params) {
+  const S = params.hx;
+  if (!S || !S.memb) return;
+  const buf = S.buf, n = S.n, m = n / 2, h0 = S.hue, t = S.time;
+  buf.fill(0);
+  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);
+  const cls = [];
+  for (let d = 0; d <= m; d++) cls.push(hsv(h0 + 0.15 + (0.77 * (d - 1)) / max(1, m - 1), 0.78, 1));
+  // Where each step's dot is drawn: a dot that has just moved slides there
+  // over 0.35 s.
+  const pos = (s, which) => {
+    const u = cl((t - S.mt[s]) / 0.35, 0, 1), e = u * u * (3 - 2 * u), q = s + S.off[s] * (1 - e);
+    const a = -PI / 2 + (2 * PI * q) / n, C = RING[which];
+    return [C[0] + R * cos(a), C[1] + R * sin(a)];
+  };
+  const head = S.P - floor(S.P / n) * n;
+  for (let w = 0; w < 2; w++) {
+    const who = w === 0 ? 1 : 0, C = RING[w], P = w === 0 ? S.pA : S.pB, col = w === 0 ? cA : cB;
+    // A soft light spreads from an onset as it sounds, so the beat answers
+    // between the two rings from across the room.
+    for (let s = 0; s < n; s++)
+      if (S.memb[s] === who && S.fl[s] > 0.04) {
+        const [x, y] = pos(s, w), f = S.fl[s];
+        for (let yy = max(0, floor(y - 13)); yy <= min(H - 1, y + 13); yy++)
+          for (let xx = max(0, floor(x - 13)); xx < min(W, x + 13); xx++) {
+            const d2 = (xx - x) ** 2 + (yy - y) ** 2;
+            if (d2 < 169) plot(buf, xx, yy, col, 0.3 * f * exp(-d2 / 45));
+          }
+      }
+    ring(buf, C[0], C[1], R, grey, 1);
+    // Every pair of onsets is a chord, coloured by its distance, and lights
+    // when either end of it sounds; the rest of the ring's chords brighten a
+    // little with it, so the ring that is playing reads at a glance.
+    let rf = 0;
+    for (let s = 0; s < n; s++) if (S.memb[s] === who && S.fl[s] > rf) rf = S.fl[s];
+    for (let d = 1; d <= m; d++)
+      for (const [i, j] of P[d]) {
+        const [x0, y0] = pos(i, w), [x1, y1] = pos(j, w), f = max(S.fl[i], S.fl[j]);
+        line(buf, x0, y0, x1, y1, cls[d], 0.26 + 0.2 * rf + 0.54 * f);
+      }
+    for (let s = 0; s < n; s++) {
+      const [x, y] = pos(s, w), fu = cl((t - S.flip[s]) / 0.4, 0, 1);
+      if (S.memb[s] === who) {
+        const f = S.fl[s];
+        disc(buf, x, y, 2.1 + 1.2 * f, col, (0.62 + 0.38 * f) * (0.3 + 0.7 * fu));
+        if (f > 0.05) ring(buf, x, y, 3 + 7 * (1 - f), col, 0.8 * f);
+      } else plot(buf, x, y, grey, 1.6);
+    }
+    // The beat, going round both rings at once with a tail one pulse long.
+    for (let j = 0; j <= 16; j++) {
+      const a = -PI / 2 + (2 * PI * (head - j / 16)) / n;
+      plot(buf, C[0] + (R + 3) * cos(a), C[1] + (R + 3) * sin(a), [255, 255, 255], 0.9 * (1 - j / 17));
+    }
+    {
+      const a = -PI / 2 + (2 * PI * head) / n;
+      disc(buf, C[0] + (R + 3) * cos(a), C[1] + (R + 3) * sin(a), 0.9, [255, 255, 255], 0.9);
+    }
+  }
+  // The bars. Each block is one pair of onsets, the pairs of a distance
+  // stacked in order of their first onset; a block lights with its chord.
+  const slot = floor(62 / m), bw = slot - 2, x00 = floor((W - slot * m) / 2) + floor((slot - bw) / 2);
+  const hu = max(1, min(3, floor(19 / (m + S.k))));
+  for (let d = 1; d <= m; d++) {
+    const x0 = x00 + (d - 1) * slot;
+    digit(buf, x0 + floor((bw - 1) / 2), 61, d, grey, 1.9);
+    for (let w = 0; w < 2; w++) {
+      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];
+      for (let b = 0; b < Math.ceil(v - 0.02); b++) {
+        const part = min(1, v - b), pr = P[b], f = pr ? max(S.fl[pr[0]], S.fl[pr[1]]) : 0;
+        // Where one rhythm has more pairs than the other, the extra blocks
+        // are drawn pale: with Uneven at k they come to 2k in every column
+        // but the last, where they are k.
+        const extra = b >= other - 0.02, c = extra ? hsv(h0 + 0.6, 0.12, 1) : cls[d];
+        const rows = hu >= 2 ? hu - 1 : 1;
+        for (let r = 0; r < rows * part; r++) {
+          const y = w === 0 ? UP - b * hu - r : DOWN + b * hu + r;
+          for (let x = x0; x < x0 + bw; x++) plot(buf, x, y, c, (extra ? 0.55 : 0.5) + 0.5 * f);
+        }
+      }
+      // The count itself at the end of the bar, the interval vector read
+      // off one digit a column.
+      const tip = max(0, v) * hu, cnt = w === 0 ? S.vA[d] : S.vB[d];
+      digit(buf, x0 + floor((bw - 1) / 2), w === 0 ? round(UP - tip - 5) : round(DOWN + tip + 1), cnt, cls[d], 0.55);
+    }
+  }
+  for (let p = 0, i = 0; p < N; p++, i += 3) display.setPixel(p % W, (p / W) | 0, 3 + buf[i], 4 + buf[i + 1], 10 + buf[i + 2]);
+}
diff --git a/incoming/pattern-study/patterns/ink-traps.js b/incoming/pattern-study/patterns/ink-traps.js
new file mode 100644
index 000000000..2d5826d23
--- /dev/null
+++ b/incoming/pattern-study/patterns/ink-traps.js
@@ -0,0 +1,309 @@
+// ===== Patternflow pattern =====
+// Title:   Ink Traps
+// Family:  type
+// 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.
+// Author:  patternflow-lab
+// Date:    2026-10-29
+// SPDX-License-Identifier: CC-BY-SA-4.0
+// 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
+// Round:   70
+// ===============================
+// @matrix 64x128
+// @knobs Hue=0..1, Speed=0.2..3, Letters=0..2, Spread=-1..1
+//
+// 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.
+// 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.
+// 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.
+// 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.
+
+// Bell Centennial (Matthew Carter for AT&T, 1978) was cut for 6 point type
+// printed fast on newsprint. Ink spreads into newsprint, and where two
+// strokes meet at a sharp angle the paper between them is near ink on both
+// sides, so the joint fills first and the letter clogs. Carter cut notches
+// into those joints, ink traps, so that the spreading ink fills the notch
+// and the joint comes out the way it was drawn. At display size the traps
+// show; at 6 point they fill.
+//
+// Here the panel is a magnifier, and the letters are plain straight-sided
+// capitals drawn for it, not Bell Centennial's own. The ink is a
+// concentration that diffuses into the paper, faster along the fibres,
+// which lie along the rows, and the paper turns dark wherever the
+// concentration passes 0.12. The variance of
+// the spread grows in proportion to the time, so the edge of a stroke moves
+// out as the square root of the time, the way a liquid wicks into a porous
+// sheet (Washburn, 1921). A straight edge moves out about 1.18 standard
+// deviations; a sharp corner fills further, since both strokes feed it.
+//
+// Each trap is the joint's own wedge pushed back into the ink by
+// D = 1.6 * (edge advance) / sin(half the angle), its sides then running
+// back to the drawn edges over the same length D. If every edge moved out
+// by the same distance, a factor of 1 would print the joint exactly where
+// it was drawn. Diffusion fills a sharp corner further than that, and 1.6
+// was found by printing the eleven joints of M, W, N and A at the opening
+// spread: at 1 every trap fills shut and the joint prints like the plain
+// one, 12 LEDs out on the M; at 1.4 some print within 1.5 LEDs and some
+// fill shut; at 1.6 all eleven print within a LED of the drawn vertex,
+// against 3.4 to 13.3 LEDs out for the plain letter; at 1.8 the notches
+// stay open 1 to 4 LEDs deep.
+
+const W = 64, H = 128, N = W * H;
+const { floor, min, max, abs, sin, cos, tan, exp, round, hypot, PI } = Math;
+const cl = (v, a, b) => (v < a ? a : v > b ? b : v);
+function hsv(h, s, v) {
+  h = (h - floor(h)) * 6;
+  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);
+  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];
+}
+
+// ---- The letters, drawn as convex pieces in a box 50 LEDs wide and 58
+// tall, x to the right and y down: R is a rectangle, P any convex polygon.
+const GW = 50, GH = 58, GX = 7, GY = [2, 68];
+const P = (...c) => {
+  const p = [];
+  for (let i = 0; i < c.length; i += 2) p.push([c[i], c[i + 1]]);
+  let a = 0;
+  for (let i = 0; i < p.length; i++) {
+    const [x0, y0] = p[i], [x1, y1] = p[(i + 1) % p.length];
+    a += x0 * y1 - x1 * y0;
+  }
+  return { p, o: a > 0 ? 1 : -1 };
+};
+const R = (x0, y0, x1, y1) => P(x0, y0, x1, y0, x1, y1, x0, y1);
+const GLYPHS = {
+  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)],
+  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: [R(0, 0, 10, 58), R(40, 0, 50, 58), P(0, 0, 12, 0, 50, 58, 38, 58)],
+  V: [P(0, 0, 11, 0, 30.5, 58, 19.5, 58), P(39, 0, 50, 0, 30.5, 58, 19.5, 58)],
+  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)],
+  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)],
+  X: [P(0, 0, 11, 0, 50, 58, 39, 58), P(39, 0, 50, 0, 11, 58, 0, 58)],
+  Y: [P(0, 0, 11, 0, 30, 32, 20, 32), P(39, 0, 50, 0, 30, 32, 20, 32), R(20, 30, 30, 58)],
+  Z: [R(0, 0, 50, 10), R(0, 48, 50, 58), P(36, 10, 50, 10, 14, 48, 0, 48)],
+  4: [R(31, 0, 41, 58), P(28, 0, 41, 0, 13, 37, 0, 37), R(0, 35, 50, 44)],
+  7: [R(0, 0, 50, 10), P(43, 0, 55, 0, 26, 58, 14, 58)],
+  1: [R(26, 0, 37, 58), P(31, 0, 31, 11, 13, 22, 9, 15)],
+};
+const SETS = [["M", "W", "N", "V"], ["K", "A", "X", "Y", "Z"], ["4", "7", "1"]];
+
+function inPoly(q, x, y) {
+  const p = q.p, n = p.length;
+  for (let i = 0; i < n; i++) {
+    const [x0, y0] = p[i], [x1, y1] = p[(i + 1) % n];
+    if (q.o * ((x1 - x0) * (y - y0) - (y1 - y0) * (x - x0)) < -1e-9) return false;
+  }
+  return true;
+}
+function ink(g, x, y) {
+  if (x < 0 || x > GW || y < 0 || y > GH) return false;
+  for (const q of g) if (inPoly(q, x, y)) return true;
+  return false;
+}
+
+// The joints: where an edge of one piece crosses an edge of another on the
+// outline of the letter and the paper between them is a wedge narrower than
+// 84 degrees.
+function crotches(g) {
+  const out = [];
+  for (let i = 0; i < g.length; i++)
+    for (let j = i + 1; j < g.length; j++)
+      for (let a = 0; a < g[i].p.length; a++)
+        for (let b = 0; b < g[j].p.length; b++) {
+          const [ax, ay] = g[i].p[a], [ax1, ay1] = g[i].p[(a + 1) % g[i].p.length];
+          const [bx, by] = g[j].p[b], [bx1, by1] = g[j].p[(b + 1) % g[j].p.length];
+          const dax = ax1 - ax, day = ay1 - ay, dbx = bx1 - bx, dby = by1 - by;
+          const den = dax * dby - day * dbx;
+          if (abs(den) < 1e-9) continue;
+          const t = ((bx - ax) * dby - (by - ay) * dbx) / den, s = ((bx - ax) * day - (by - ay) * dax) / den;
+          if (t < -1e-6 || t > 1 + 1e-6 || s < -1e-6 || s > 1 + 1e-6) continue;
+          const vx = ax + t * dax, vy = ay + t * day;
+          if (vx < 0.5 || vx > GW - 0.5 || vy < 0.5 || vy > GH - 0.5) continue;
+          let paper = 0, sx = 0, sy = 0;
+          for (let k = 0; k < 96; k++) {
+            const th = ((k + 0.5) / 96) * 2 * PI, cx = cos(th), cy = sin(th);
+            if (!ink(g, vx + 1.5 * cx, vy + 1.5 * cy)) paper++, (sx += cx), (sy += cy);
+          }
+          const deg = (paper / 96) * 360;
+          if (deg < 8 || deg > 84) continue;
+          if (out.some((c) => abs(c.x - vx) + abs(c.y - vy) < 1.5)) continue;
+          const l = hypot(sx, sy);
+          out.push({ x: vx, y: vy, bx: sx / l, by: sy / l, a: (deg * PI) / 180 });
+        }
+  return out;
+}
+
+// ---- Paper: hash value noise, stretched along the rows the way newsprint
+// fibres lie along the web.
+const hash = (a, b, c) => {
+  let h = (a * 374761393 + b * 668265263 + c * 1013904223) | 0;
+  h = Math.imul(h ^ (h >>> 13), 1274126177);
+  h = Math.imul(h ^ (h >>> 16), 2246822519);
+  return ((h ^ (h >>> 13)) >>> 0) / 4294967296;
+};
+function vn(x, y, k) {
+  const x0 = floor(x), y0 = floor(y), fx = x - x0, fy = y - y0;
+  const sx = fx * fx * (3 - 2 * fx), sy = fy * fy * (3 - 2 * fy);
+  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);
+  return a + (b - a) * sx + (c - a) * sy + (a - b - c + d) * sx * sy;
+}
+const K0 = 0.16;
+function makeSheet(seed) {
+  const F = new Float32Array(N), kh = new Float32Array(N), kv = new Float32Array(N);
+  for (let y = 0; y < H; y++)
+    for (let x = 0; x < 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);
+  let mh = 0, mv = 0;
+  for (let y = 0; y < H; y++)
+    for (let x = 0; x < W; x++) {
+      const i = y * W + x;
+      kh[i] = x < W - 1 ? K0 * 1.15 * (0.55 + 0.45 * (F[i] + F[i + 1])) : 0;
+      kv[i] = y < H - 1 ? K0 * 0.85 * (0.55 + 0.45 * (F[i] + F[i + W])) : 0;
+      mh += kh[i];
+      mv += kv[i];
+    }
+  return { F, kh, kv, step: (mh + mv) / N };
+}
+
+// ---- Timing at Speed 2, in seconds. The ink: the standard deviation of
+// the spread the traps are cut for (1.28 LEDs, an edge advance of 1.5), the
+// concentration at which paper turns dark, and how many standard
+// deviations a straight edge moves out at that concentration.
+const T_SOAK = 3, T_HOLD = 2.6, T_FEED = 0.8;
+const TRAPK = 1.6, SIGN = 1.28, TAU = 0.12, ZT = 1.175;
+
+export function setup(params) {
+  const s = (params.s = {});
+  s.sheets = [makeSheet(11), makeSheet(23)];
+  s.u = new Float32Array(N);
+  s.du = new Float32Array(N);
+  s.cr = {};
+  s.set = -1;
+  s.li = 0;
+  s.p = 0;
+  s.phase = 0;
+  s.age = 0;
+  s.done = 0;
+  s.struck = false;
+}
+
+function strike(s, ch) {
+  const g = GLYPHS[ch];
+  if (!s.cr[ch])
+    s.cr[ch] = crotches(g).map((c) => {
+      const D = (TRAPK * ZT * SIGN) / sin(c.a / 2);
+      return { ...c, t: tan(c.a / 2), D, Lr: D };
+    });
+  const cr = s.cr[ch], u = s.u;
+  u.fill(0);
+  for (let half = 0; half < 2; half++) {
+    const oy = GY[half];
+    for (let y = 0; y < GH + 1; y++)
+      for (let x = 0; x < GW + 1; x++) {
+        let c = 0;
+        for (let j = 0; j < 4; j++)
+          for (let i = 0; i < 4; i++) {
+            const px = x + (i + 0.5) / 4, py = y + (j + 0.5) / 4;
+            if (!ink(g, px, py)) continue;
+            let trap = false;
+            if (half === 0)
+              for (const t of cr) {
+                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);
+                if (A > 0 && A < t.D + t.Lr && w < A * t.t - t.D * t.t * max(0, (A - t.D) / t.Lr)) {
+                  trap = true;
+                  break;
+                }
+              }
+            if (!trap) c++;
+          }
+        const X = GX + x, Y = oy + y;
+        if (X < W && Y < H) u[Y * W + X] = c / 16;
+      }
+  }
+  s.done = 0;
+  s.age = 0;
+  s.struck = true;
+}
+
+function diffuse(s, f) {
+  const { u, du } = s, sh = s.sheets[s.p], kh = sh.kh, kv = sh.kv;
+  du.fill(0);
+  for (let i = 0; i < N; i++) {
+    const a = u[i];
+    if (kh[i]) {
+      const q = kh[i] * (u[i + 1] - a) * f;
+      du[i] += q;
+      du[i + 1] -= q;
+    }
+    if (kv[i]) {
+      const q = kv[i] * (u[i + W] - a) * f;
+      du[i] += q;
+      du[i + W] -= q;
+    }
+  }
+  for (let i = 0; i < N; i++) u[i] += du[i];
+}
+
+export function update(dt, input, params) {
+  if (!params.s) setup(params);
+  const s = params.s, k = input.knobValues || [0, 2, 0, 0.06];
+  dt = cl(dt || 0, 0, 0.1);
+  s.hue = k[0] || 0;
+  const rate = cl(k[1], 0.2, 3) / 2;
+  const set = round(cl(k[2] || 0, 0, 2));
+  const k4 = cl(k[3] || 0, -1, 1) - 0.06, sig = SIGN * exp(k4 * (k4 < 0 ? 1 : 0.56));
+  if (!s.struck) {
+    s.set = set;
+    strike(s, SETS[set][0]);
+  }
+  if (set !== s.set && s.phase === 0) {
+    s.set = set;
+    s.li = -1;
+    s.phase = 1;
+    s.feed = 0;
+  }
+  if (s.phase === 0) {
+    s.age += dt * rate;
+    const want = sig * sig * min(1, s.age / T_SOAK), st = s.sheets[s.p].step;
+    let need = want - s.done, n = 0;
+    while (need > 1e-4 && n < 16) {
+      const f = min(1, need / st);
+      diffuse(s, f);
+      s.done += f * st;
+      need -= f * st;
+      n++;
+    }
+    // A sheet soaked past what the knob now asks for cannot unsoak: feed
+    // a fresh one.
+    if (s.age > T_SOAK + T_HOLD || (s.age > 0.3 && sig * sig < 0.7 * s.done)) (s.phase = 1), (s.feed = 0);
+  } else {
+    s.feed += (dt * rate) / T_FEED;
+    if (s.feed >= 1) {
+      s.phase = 0;
+      s.p ^= 1;
+      const L = SETS[s.set];
+      s.li = (s.li + 1) % L.length;
+      strike(s, L[s.li]);
+    }
+  }
+}
+
+export function draw(display, params) {
+  const s = params.s;
+  if (!s || !s.struck) return;
+  const paper = hsv(0.14 + s.hue, 0.62, 182), INK = [4, 4, 8];
+  const e = s.phase === 1 ? s.feed * s.feed * (3 - 2 * s.feed) : 0, off = round(e * H);
+  const A = s.sheets[s.p], B = s.sheets[s.p ^ 1], u = s.u;
+  for (let y = 0; y < H; y++) {
+    const sy = y + off, old = sy < H, row = old ? sy : sy - H, F = old ? A.F : B.F;
+    const seam = s.phase === 1 && (sy === H - 1 || sy === H) ? 0.6 : 1;
+    for (let x = 0; x < W; x++) {
+      const i = row * W + x, f = F[i];
+      const pb = (0.93 + 0.12 * (f - 0.5)) * seam;
+      let d = 0;
+      if (old) {
+        const v = u[i] + 0.04 * (f - 0.5);
+        d = cl((v - (TAU - 0.05)) / 0.1, 0, 1);
+        d = d * d * (3 - 2 * d);
+      }
+      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));
+    }
+  }
+}
diff --git a/incoming/pattern-study/patterns/laguerre-cells.js b/incoming/pattern-study/patterns/laguerre-cells.js
new file mode 100644
index 000000000..7cc0651c9
--- /dev/null
+++ b/incoming/pattern-study/patterns/laguerre-cells.js
@@ -0,0 +1,318 @@
+// ===== Patternflow pattern =====
+// Title:   Laguerre Cells
+// Family:  cells
+// 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.
+// Author:  patternflow-lab
+// Date:    2026-10-29
+// SPDX-License-Identifier: CC-BY-SA-4.0
+// 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
+// Round:   70
+// ===============================
+// @matrix 64x128
+// @knobs Hue=0..1, Speed=0.2..3, Cells=24..64, Contrast=-1..1
+//
+// 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.
+// 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.
+// 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.
+// 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.
+
+// A power diagram gives each site p_i a weight w_i and each point x to the
+// site with the least power |x - p_i|^2 - w_i. Two cells meet on a straight
+// line, where the powers are equal, and raising w_i pushes that line away
+// from p_i by (dw)/(2|p_i - p_j|). With all weights equal it is the Voronoi
+// diagram. Aurenhammer, Hoffmann and Aronov showed that for any sites and
+// any masses there are weights that give every cell its mass, the minimum
+// of a convex function of the weights; that is the semi-discrete optimal
+// transport of the density onto the sites with the cost |x - p|^2.
+//
+// The gradient of the dual is each cell's missing mass, m - mass_i, and its
+// Hessian the matrix of edges: for cells i and j, the density along their
+// common edge over 2|p_i - p_j|. An LED within half an LED of an edge
+// splits its mass between the two cells by how far it lies across, which
+// makes the mass move smoothly with the weights and gives those edge sums.
+// Each frame conjugate gradients solve the Newton step and the weights take
+// a share of it, so the errors fall smoothly enough to watch.
+//
+// A cell need not hold its own site. On this panel with 24 sites, 11 lie
+// outside their settled cells at the opening density and 17 after the
+// first change; with 64 sites it is 48 to 53.
+
+const W = 64, H = 128, N = W * H;
+const { floor, min, max, abs, sqrt, exp, cos, sin, round, PI } = Math;
+const cl = (v, a, b) => (v < a ? a : v > b ? b : v);
+function hsv(h, s, v, o, k) {
+  h = (h - floor(h)) * 6;
+  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);
+  o[k] = i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p;
+  o[k + 1] = i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p;
+  o[k + 2] = i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p;
+}
+
+const MAXC = 64;
+// Blocks of 8 by 8 LEDs, each with the sites that can own or border one of
+// its LEDs.
+const B = 8, BX = W / B, BY = H / B;
+// Seconds at Speed 2: a density holds, then turns into the next.
+const T_HOLD = 6, T_MORPH = 1.6, T_FIRST = 4.4;
+
+function newSites(s, n) {
+  s.n = n;
+  const X = s.px, Y = s.py;
+  // Best candidate: each new site the farthest of 24 tries from the others.
+  for (let i = 0; i < n; i++) {
+    let bx = 0, by = 0, bd = -1;
+    for (let t = 0; t < 24; t++) {
+      const x = 2 + Math.random() * (W - 4), y = 2 + Math.random() * (H - 4);
+      let d = 1e9;
+      for (let j = 0; j < i; j++) d = min(d, (x - X[j]) ** 2 + (y - Y[j]) ** 2);
+      if (d > bd) (bd = d), (bx = x), (by = y);
+    }
+    X[i] = bx;
+    Y[i] = by;
+  }
+  s.w.fill(0);
+}
+
+// A density: three soft bumps, a log-density f from 0 to 1 that the
+// Contrast knob raises to a ratio of densest to thinnest.
+function newBumps() {
+  const b = [];
+  for (let k = 0; k < 3; k++)
+    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 });
+  return b;
+}
+
+export function setup(params) {
+  const s = (params.s = {});
+  s.px = new Float64Array(MAXC);
+  s.py = new Float64Array(MAXC);
+  s.w = new Float64Array(MAXC);
+  s.mass = new Float64Array(MAXC);
+  s.err = new Float64Array(MAXC);
+  s.Hm = new Float64Array(MAXC * MAXC);
+  s.rho = new Float32Array(N);
+  s.f = new Float32Array(N);
+  s.own = new Uint8Array(N);
+  s.line = new Float32Array(N);
+  s.cand = new Uint8Array(BX * BY * MAXC);
+  s.cnt = new Uint8Array(BX * BY);
+  s.cg = [new Float64Array(MAXC), new Float64Array(MAXC), new Float64Array(MAXC), new Float64Array(MAXC), new Float64Array(MAXC)];
+  s.n = 0;
+  s.A = newBumps();
+  s.Bm = newBumps();
+  s.clock = 0;
+  s.next = T_FIRST;
+  s.morph = -1;
+  s.t = 0;
+}
+
+function density(s, lnR) {
+  const { rho, f } = s, A = s.A, Bm = s.Bm;
+  const m = s.morph < 0 ? 0 : s.morph * s.morph * (3 - 2 * s.morph);
+  const bs = A.map((a, k) => {
+    const b = Bm[k], dr = 2;
+    return {
+      x: a.x + (b.x - a.x) * m + dr * cos(s.t * 0.3 + a.ph),
+      y: a.y + (b.y - a.y) * m + dr * sin(s.t * 0.22 + a.ph),
+      r: a.r + (b.r - a.r) * m,
+      a: a.a + (b.a - a.a) * m,
+    };
+  });
+  // Each bump is a product of a row and a column Gaussian, and exp(lnR f)
+  // is read from a table of 1025 steps.
+  const gx = s.gx || (s.gx = new Float32Array(3 * W)), gy = s.gy || (s.gy = new Float32Array(3 * H));
+  bs.forEach((b, k) => {
+    const q = 1 / (2 * b.r * b.r);
+    for (let x = 0; x < W; x++) gx[k * W + x] = b.a * exp(-((x + 0.5 - b.x) ** 2) * q);
+    for (let y = 0; y < H; y++) gy[k * H + y] = exp(-((y + 0.5 - b.y) ** 2) * q);
+  });
+  const lut = s.lut || (s.lut = new Float32Array(1025));
+  for (let j = 0; j <= 1024; j++) lut[j] = exp((lnR * j) / 1024);
+  let tot = 0;
+  for (let y = 0; y < H; y++) {
+    const a0 = gy[y], a1 = gy[H + y], a2 = gy[2 * H + y];
+    for (let x = 0; x < W; x++) {
+      const v = min(1, a0 * gx[x] + a1 * gx[W + x] + a2 * gx[2 * W + x]), i = y * W + x;
+      f[i] = v;
+      tot += rho[i] = lut[round(v * 1024)];
+    }
+  }
+  return tot;
+}
+
+// Power distance |x - p|^2 - w for every LED: the owner, the runner-up and
+// how far the LED is from their common edge, in LEDs. An LED within half an
+// LED of the edge splits its mass between the two, so a cell's mass moves
+// smoothly with the weights, and the same LEDs give the derivatives.
+function assign(s) {
+  const { px, py, w, n, cand, cnt, rho, own, line, mass, Hm } = s;
+  let wmax = -1e9;
+  for (let i = 0; i < n; i++) wmax = max(wmax, w[i]);
+  const r = B * 0.7072;
+  for (let by = 0; by < BY; by++)
+    for (let bx = 0; bx < BX; bx++) {
+      const cx = bx * B + B / 2, cy = by * B + B / 2, blk = by * BX + bx;
+      let U = 1e18;
+      const dc = s.cg[4];
+      for (let i = 0; i < n; i++) {
+        const d = sqrt((px[i] - cx) ** 2 + (py[i] - cy) ** 2);
+        dc[i] = d;
+        U = min(U, (d + r) ** 2 - w[i]);
+      }
+      const reach = sqrt(max(0, U + wmax));
+      let c = 0;
+      for (let i = 0; i < n; i++) {
+        const lb = max(0, dc[i] - r) ** 2 - w[i];
+        if (lb - U < 2 * (reach + dc[i] + r) + 1) cand[blk * MAXC + c++] = i;
+      }
+      cnt[blk] = c;
+    }
+  mass.fill(0, 0, n);
+  Hm.fill(0, 0, MAXC * MAXC);
+  for (let y = 0; y < H; y++)
+    for (let x = 0; x < W; x++) {
+      const blk = (y >> 3) * BX + (x >> 3), c = cnt[blk], o = blk * MAXC;
+      const X = x + 0.5, Y = y + 0.5;
+      let b1 = 0, b2 = 0, d1 = 1e18, d2 = 1e18;
+      for (let k = 0; k < c; k++) {
+        const i = cand[o + k], d = (X - px[i]) ** 2 + (Y - py[i]) ** 2 - w[i];
+        if (d < d1) (d2 = d1), (b2 = b1), (d1 = d), (b1 = i);
+        else if (d < d2) (d2 = d), (b2 = i);
+      }
+      const p = y * W + x, q = rho[p];
+      own[p] = b1;
+      let gap = 99;
+      if (c > 1) {
+        const sep = 2 * sqrt((px[b1] - px[b2]) ** 2 + (py[b1] - py[b2]) ** 2);
+        gap = (d2 - d1) / sep;
+        if (gap < 0.5) {
+          const sh = 0.5 + gap, h = q / sep;
+          mass[b1] += q * sh;
+          mass[b2] += q * (1 - sh);
+          Hm[b1 * MAXC + b1] += h;
+          Hm[b2 * MAXC + b2] += h;
+          Hm[b1 * MAXC + b2] -= h;
+          Hm[b2 * MAXC + b1] -= h;
+        } else mass[b1] += q;
+      } else mass[b1] += q;
+      line[p] = gap;
+    }
+}
+
+// Newton on the Kantorovich dual: the gradient is each cell's missing mass,
+// the Hessian the matrix of edge densities just gathered. Conjugate
+// gradients solve H d = (m - mass); the weights move a damped share of d.
+function newton(s, m, step) {
+  const { n, Hm, w, mass, err } = s;
+  const [r, z, p, Ap] = s.cg;
+  let typ = 0, cntH = 0;
+  for (let i = 0; i < n; i++) if (Hm[i * MAXC + i] > 0) (typ += Hm[i * MAXC + i]), cntH++;
+  typ = cntH ? typ / cntH : 1;
+  const eps = 1e-4 * typ;
+  for (let i = 0; i < n; i++) {
+    err[i] = mass[i] / m - 1;
+    r[i] = m - mass[i];
+    // A cell with no edge in use yet gets a diagonal, so it grows back.
+    if (Hm[i * MAXC + i] <= 0) Hm[i * MAXC + i] = 0.3 * typ;
+  }
+  const dw = s.dw || (s.dw = new Float64Array(MAXC));
+  dw.fill(0, 0, n);
+  const pre = (i) => 1 / (Hm[i * MAXC + i] + eps);
+  // The matrix as lists of each cell's neighbours, about six apiece.
+  const nb = s.nb || (s.nb = new Uint8Array(MAXC * MAXC)), nc = s.nc || (s.nc = new Uint8Array(MAXC));
+  for (let i = 0; i < n; i++) {
+    let c = 0;
+    for (let j = 0; j < n; j++) if (Hm[i * MAXC + j] !== 0) nb[i * MAXC + c++] = j;
+    nc[i] = c;
+  }
+  let rz = 0;
+  for (let i = 0; i < n; i++) (z[i] = r[i] * pre(i)), (p[i] = z[i]), (rz += r[i] * z[i]);
+  const r0 = rz;
+  for (let it = 0; it < 60 && rz > 1e-10 * r0; it++) {
+    let pAp = 0;
+    for (let i = 0; i < n; i++) {
+      let v = eps * p[i];
+      const row = i * MAXC;
+      for (let k = 0; k < nc[i]; k++) {
+        const j = nb[row + k];
+        v += Hm[row + j] * p[j];
+      }
+      Ap[i] = v;
+      pAp += p[i] * v;
+    }
+    if (pAp <= 0) break;
+    const al = rz / pAp;
+    let rz2 = 0;
+    for (let i = 0; i < n; i++) {
+      dw[i] += al * p[i];
+      r[i] -= al * Ap[i];
+      z[i] = r[i] * pre(i);
+      rz2 += r[i] * z[i];
+    }
+    const be = rz2 / rz;
+    rz = rz2;
+    for (let i = 0; i < n; i++) p[i] = z[i] + be * p[i];
+  }
+  // No weight moves more than a third of a cell's mean area in one frame.
+  const lim = N / n / 3;
+  let mean = 0;
+  for (let i = 0; i < n; i++) {
+    w[i] += cl(step * dw[i], -lim, lim);
+    mean += w[i];
+  }
+  mean /= n;
+  for (let i = 0; i < n; i++) w[i] -= mean;
+}
+
+export function update(dt, input, params) {
+  if (!params.s) setup(params);
+  const s = params.s, k = input.knobValues || [0, 2, 24, 0.06];
+  dt = cl(dt || 0, 0, 0.1);
+  s.hue = k[0] || 0;
+  const sp = cl(k[1], 0.2, 3), rate = sp / 2;
+  const n = round(cl(k[2], 24, 64));
+  const lnR = 2.4 + 1.3 * cl(k[3] || 0, -1, 1);
+  if (n !== s.n) newSites(s, n);
+  s.t += dt * rate;
+  // The density holds, then turns into the next one.
+  s.clock += dt * rate;
+  if (s.morph < 0 && s.clock >= s.next) s.morph = 0;
+  if (s.morph >= 0) {
+    s.morph += (dt * rate) / T_MORPH;
+    if (s.morph >= 1) {
+      s.A = s.Bm;
+      s.Bm = newBumps();
+      s.morph = -1;
+      s.next = s.clock + T_HOLD;
+    }
+  }
+  const tot = density(s, lnR);
+  assign(s);
+  newton(s, tot / n, min(1, 1.5 * sp * dt));
+}
+
+export function draw(display, params) {
+  const s = params.s;
+  if (!s || !s.n) return;
+  const { n, own, line, f, err, px, py } = s;
+  const col = s.col || (s.col = new Float64Array(MAXC * 3));
+  const h0 = 0.5 + s.hue;
+  for (let i = 0; i < n; i++) {
+    const e = cl(err[i] * 3, -1, 1);
+    hsv(h0 + 0.24 * e, 0.55 + 0.3 * abs(e), 1, col, i * 3);
+  }
+  const F = s.F || (s.F = new Float32Array(N * 3));
+  for (let p = 0; p < N; p++) {
+    const i = own[p], v = 55 + 150 * f[p], g = line[p], L = g < 1 ? 1 - g : 0;
+    const o = p * 3, c = i * 3;
+    F[o] = col[c] * v * (1 - L) + 215 * L;
+    F[o + 1] = col[c + 1] * v * (1 - L) + 215 * L;
+    F[o + 2] = col[c + 2] * v * (1 - L) + 215 * L;
+  }
+  // The sites, dim: most of them end up outside their own cells.
+  for (let i = 0; i < n; i++) {
+    const o = (floor(py[i]) * W + floor(px[i])) * 3;
+    F[o] = F[o + 1] = F[o + 2] = 150;
+  }
+  for (let p = 0; p < 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])));
+}
diff --git a/incoming/pattern-study/patterns/multiplicative-chaos.js b/incoming/pattern-study/patterns/multiplicative-chaos.js
new file mode 100644
index 000000000..1b25b50bc
--- /dev/null
+++ b/incoming/pattern-study/patterns/multiplicative-chaos.js
@@ -0,0 +1,262 @@
+// ===== Patternflow pattern =====
+// Title:   Multiplicative Chaos
+// Family:  noise
+// 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.
+// Author:  patternflow-lab
+// Date:    2026-10-29
+// SPDX-License-Identifier: CC-BY-SA-4.0
+// 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
+// Round:   70
+// ===============================
+// @matrix 64x128
+// @knobs Hue=0..1, Speed=0.2..3, Gamma=1..2.5, Cutoff=0..1
+//
+// 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.
+// 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.
+// 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.
+// 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.
+
+const W = 64, H = 128, N = W * H;
+const { floor, min, max, sqrt, exp, log, cos, sin, PI } = Math;
+const cl = (v, a, b) => (v < a ? a : v > b ? b : v);
+
+// ---- FFT, radix 2, in place, on rows of 64 and columns of 128.
+const CT = new Float64Array(64), ST = new Float64Array(64);
+for (let i = 0; i < 64; i++) (CT[i] = cos((2 * PI * i) / 128)), (ST[i] = sin((2 * PI * i) / 128));
+function revTable(n) {
+  const r = new Int32Array(n), b = Math.log2(n);
+  for (let i = 0; i < n; i++) {
+    let v = 0;
+    for (let k = 0; k < b; k++) if (i & (1 << k)) v |= 1 << (b - 1 - k);
+    r[i] = v;
+  }
+  return r;
+}
+const REV64 = revTable(64), REV128 = revTable(128);
+function fft(re, im, n, off, step, rev) {
+  for (let i = 0; i < n; i++) {
+    const j = rev[i];
+    if (j > i) {
+      const a = off + i * step, b = off + j * step;
+      let t = re[a];
+      re[a] = re[b];
+      re[b] = t;
+      t = im[a];
+      im[a] = im[b];
+      im[b] = t;
+    }
+  }
+  for (let len = 2; len <= n; len <<= 1) {
+    const half = len >> 1, ts = 128 / len;
+    for (let s = 0; s < n; s += len)
+      for (let k = 0; k < half; k++) {
+        const wr = CT[k * ts], wi = ST[k * ts];
+        const a = off + (s + k) * step, b = a + half * step;
+        const xr = re[b] * wr - im[b] * wi, xi = re[b] * wi + im[b] * wr;
+        re[b] = re[a] - xr;
+        im[b] = im[a] - xi;
+        re[a] += xr;
+        im[a] += xi;
+      }
+  }
+}
+function fft2(re, im) {
+  for (let y = 0; y < H; y++) fft(re, im, W, y * W, 1, REV64);
+  for (let x = 0; x < W; x++) fft(re, im, H, x, W, REV128);
+}
+
+// ---- The field's modes on the 64 x 128 torus, so it wraps round left to
+// right and top to bottom. Mode (m, n) has the eigenvalue LA of minus the
+// lattice Laplacian and standard deviation sqrt(2 pi / (LA N)), the
+// discrete Gaussian free field scaled so its covariance goes as log(1 / r):
+// C(r) - C(2r) comes to 0.71, 0.71 and 0.68 for r = 1, 2 and 4 LEDs against
+// log 2 = 0.69, and E[X^2] to 4.99. In that normalisation the critical gamma
+// is sqrt(2d) = 2. The modes are complex, so one transform gives two
+// independent fields, its real and imaginary parts; the real one is drawn.
+const LA = new Float64Array(N), AMP = new Float64Array(N), TAU = new Float64Array(N);
+for (let n = 0; n < H; n++)
+  for (let m = 0; m < W; m++) {
+    const i = n * W + m, l = 4 - 2 * cos((2 * PI * m) / W) - 2 * cos((2 * PI * n) / H);
+    LA[i] = l;
+    AMP[i] = i ? sqrt((2 * PI) / (l * N)) : 0;
+  }
+// Each mode's time constant against the longest wave's: the finest lattice
+// mode turns over five times as fast, and so do the octaves below the LED.
+const LMIN = 4 - 2 * cos((2 * PI) / H) - 2;
+for (let i = 1; i < N; i++) TAU[i] = (LMIN / LA[i]) ** 0.2;
+const TAUF = (LMIN / 8) ** 0.2;
+
+function hsv(h, s, v, o) {
+  h = (h - floor(h)) * 6;
+  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);
+  o[0] = i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p;
+  o[1] = i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p;
+  o[2] = i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p;
+  return o;
+}
+
+// Standard normal deviates, drawn once and then picked at random. The table
+// is moved to mean 0 and variance 1: a table mean of 0.01 picked 8,192
+// times a frame would add up, through every mode at once, into a bump.
+const NT = new Float64Array(8192);
+function fillNormals() {
+  let m = 0, v = 0;
+  for (let i = 0; i < 8192; i += 2) {
+    const a = sqrt(-2 * log(1 - Math.random())), b = 2 * PI * Math.random();
+    NT[i] = a * cos(b);
+    NT[i + 1] = a * sin(b);
+    m += NT[i] + NT[i + 1];
+  }
+  m /= 8192;
+  for (let i = 0; i < 8192; i++) v += (NT[i] -= m) ** 2;
+  v = sqrt(v / 8192);
+  for (let i = 0; i < 8192; i++) NT[i] /= v;
+}
+const gauss = () => NT[(Math.random() * 8192) | 0];
+
+export function setup(params) {
+  fillNormals();
+  const S = (params.s = {
+    hue: 0, speed: 2, gam: 1, cut: 0, eps: -1, qd: -1, vl: 1, vf: 0,
+    zr: new Float64Array(N), zi: new Float64Array(N), ar: new Float64Array(N), ai: new Float64Array(N),
+    fz: new Float64Array(N), fa: new Float64Array(N),
+    Q: new Float64Array(N), Z: new Float64Array(N), R: new Float64Array(N), F: new Float64Array(N),
+    re: new Float64Array(N), im: new Float64Array(N), X: new Float64Array(N),
+    rel: new Float64Array(RT * 3), glo: new Float64Array(GT * 4), th: -1,
+  });
+  // Each mode starts in its stationary law: the filtered value has variance
+  // 2/3 and covariance 2/3 with the process it filters.
+  const start = (z, a) => {
+    for (let i = 0; i < N; i++) {
+      z[i] = gauss();
+      a[i] = (2 / 3) * z[i] + 0.4714 * gauss();
+    }
+  };
+  start(S.zr, S.ar);
+  start(S.zi, S.ai);
+  start(S.fz, S.fa);
+  return S;
+}
+
+export function update(dt, input, params) {
+  const S = params.s || setup(params);
+  const k = input.knobValues || [0, 2, 1, 0.06], d = cl(dt || 0, 0, 0.1);
+  S.hue = k[0] || 0;
+  S.speed = cl(k[1] ?? 2, 0.2, 3);
+  S.gam = cl(k[2] ?? 1, 0, 3);
+  S.cut = cl(k[3] ?? 0.06, 0, 1);
+  // The cutoff epsilon in LEDs. Below one LED the lattice modes are all kept
+  // and the octaves between epsilon and the LED, log(1 / epsilon) of
+  // variance, are drawn as an independent normal at each LED: at a quarter
+  // of an LED they carry 1.39 of the field's 6.37. Above it the lattice
+  // modes are blurred by a Gaussian of width epsilon.
+  const eps = 2 ** (6 * (S.cut - 0.06) - 2);
+  if (eps !== S.eps) {
+    S.eps = eps;
+    const e2 = max(0, eps * eps - 1 / 16);
+    let v = 0;
+    for (let i = 1; i < N; i++) {
+      const f = exp((-LA[i] * e2) / 2);
+      S.F[i] = AMP[i] * f * sqrt(1.5);
+      v += (AMP[i] * f) ** 2;
+    }
+    S.vl = v;
+    S.vf = max(0, log(1 / eps));
+  }
+  // Ornstein-Uhlenbeck steps seen through an exponential filter of half the
+  // time constant, which smooths each path in time; the filter leaves 2/3 of
+  // the variance, which F gives back. The longest wave's time constant is
+  // 8 s at Speed 2.
+  const qd = (d * S.speed) / (8 * 2);
+  if (qd !== S.qd) {
+    S.qd = qd;
+    for (let i = 1; i < N; i++) {
+      const q = exp(-qd / TAU[i]);
+      S.Q[i] = q;
+      S.Z[i] = sqrt(1 - q * q);
+      S.R[i] = q * q;
+    }
+    const q = exp(-qd / TAUF);
+    S.fq = q;
+    S.fzz = sqrt(1 - q * q);
+    S.fr = q * q;
+  }
+  const { zr, zi, ar, ai, Q, Z, R, F, re, im, fz, fa, X } = S;
+  for (let i = 1; i < N; i++) {
+    zr[i] = zr[i] * Q[i] + Z[i] * gauss();
+    zi[i] = zi[i] * Q[i] + Z[i] * gauss();
+    ar[i] = ar[i] * R[i] + zr[i] * (1 - R[i]);
+    ai[i] = ai[i] * R[i] + zi[i] * (1 - R[i]);
+    re[i] = ar[i] * F[i];
+    im[i] = ai[i] * F[i];
+  }
+  re[0] = im[0] = 0;
+  fft2(re, im);
+  const sf = sqrt(S.vf * 1.5), fq = S.fq, fzz = S.fzz, fr = S.fr;
+  for (let i = 0; i < N; i++) {
+    fz[i] = fz[i] * fq + fzz * gauss();
+    fa[i] = fa[i] * fr + fz[i] * (1 - fr);
+    X[i] = re[i] + sf * fa[i];
+  }
+}
+
+// ---- Drawing. The relief: the field's height t = X / sd tints and lifts
+// it, and its slope toward the upper left (the sum of the two central
+// differences, halved) shades it. The glow: lm, the log of the LED's share
+// of the frame's mass against an even share, read from LO (e^-2, 0.14 of an
+// even share) to HI (e^3.5, 33 times one).
+const KS = 0.4, KB = 0.16, LO = -2, HI = 3.5;
+// Relief colours over t from -3 to 3 in 64 steps; glow colours, with the
+// glow's own weight a and what is left of the relief k, over 256 steps.
+const RT = 64, GT = 256;
+function tables(S) {
+  const c = [0, 0, 0];
+  for (let j = 0; j < RT; j++) {
+    hsv(0.64 + S.hue - 0.03 * ((6 * j) / (RT - 1) - 3), 0.85, 1, c);
+    S.rel[j * 3] = c[0];
+    S.rel[j * 3 + 1] = c[1];
+    S.rel[j * 3 + 2] = c[2];
+  }
+  for (let j = 0; j < GT; j++) {
+    const w = j / (GT - 1), a = min(1, 0.25 + 1.2 * w);
+    hsv(0.93 + S.hue + 0.22 * min(1, w * 1.25), 1 - w ** 4, 0.45 + 0.55 * w, c);
+    S.glo[j * 4] = 255 * a * c[0];
+    S.glo[j * 4 + 1] = 255 * a * c[1];
+    S.glo[j * 4 + 2] = 255 * a * c[2];
+    S.glo[j * 4 + 3] = 1 - 0.85 * a;
+  }
+  S.th = S.hue;
+}
+
+export function draw(display, params) {
+  const S = params.s;
+  if (!S) return;
+  if (S.th !== S.hue) tables(S);
+  const X = S.X, g = S.gam, rel = S.rel, glo = S.glo, isd = 1 / sqrt(S.vl + S.vf), ts = (RT - 1) / 6;
+  // Each LED's share of the frame's mass: the log of the mean density is
+  // taken off, summed from the largest value down so it cannot overflow.
+  // The constant -g^2 E[X^2] / 2 of the chaos cancels in the share.
+  let mx = -1e9;
+  for (let i = 0; i < N; i++) if (X[i] > mx) mx = X[i];
+  let sum = 0;
+  for (let i = 0; i < N; i++) sum += exp(g * (X[i] - mx));
+  const off = g * mx + log(sum / N), gw = (GT - 1) / (HI - LO);
+  for (let y = 0; y < H; y++) {
+    const r0 = y * W, ru = ((y + H - 1) & 127) * W, rd = ((y + 1) & 127) * W;
+    for (let x = 0; x < W; x++) {
+      const p = r0 + x, v = X[p];
+      const sh = (X[r0 + ((x + W - 1) & 63)] - X[r0 + ((x + 1) & 63)] + X[ru + x] - X[rd + x]) * 0.5;
+      const t = v * isd, tj = cl(((t + 3) * ts) | 0, 0, RT - 1) * 3;
+      const val = 255 * cl(0.38 + KB * t + KS * sh, 0.02, 1);
+      let r = rel[tj] * val, gg = rel[tj + 1] * val, b = rel[tj + 2] * val;
+      const lm = g * v - off;
+      if (lm > LO) {
+        const q = min(GT - 1, ((lm - LO) * gw) | 0) * 4, k = glo[q + 3];
+        r = r * k + glo[q];
+        gg = gg * k + glo[q + 1];
+        b = b * k + glo[q + 2];
+      }
+      display.setPixel(x, y, r > 255 ? 255 : r | 0, gg > 255 ? 255 : gg | 0, b > 255 ? 255 : b | 0);
+    }
+  }
+}
diff --git a/incoming/pattern-study/patterns/photon-disk.js b/incoming/pattern-study/patterns/photon-disk.js
new file mode 100644
index 000000000..73f836ee4
--- /dev/null
+++ b/incoming/pattern-study/patterns/photon-disk.js
@@ -0,0 +1,397 @@
+// ===== Patternflow pattern =====
+// Title:   Photon Disk
+// Family:  type
+// 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.
+// Author:  patternflow-lab
+// Date:    2026-10-29
+// SPDX-License-Identifier: CC-BY-SA-4.0
+// 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
+// Round:   70
+// ===============================
+// @matrix 64x128
+// @knobs Hue=0..1, Speed=0.2..3, Text=0..3, Lens=1..2.25
+//
+// 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.
+// 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.
+// 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.
+// 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.
+
+const W = 64, H = 128;
+const { floor, ceil, round, min, max, abs, sqrt, sin, cos, exp, atan2, PI } = Math;
+const cl = (v, a, b) => (v < a ? a : v > b ? b : v);
+const TAU = 2 * PI;
+
+// 5 x 7 capitals, figures and four marks, drawn for this pattern, row by row
+// from the top.
+const GLYPHS = {
+  A: ".###. #...# #...# ##### #...# #...# #...#", B: "####. #...# #...# ####. #...# #...# ####.", C: ".###. #...# #.... #.... #.... #...# .###.",
+  D: "####. #...# #...# #...# #...# #...# ####.", E: "##### #.... #.... ####. #.... #.... #####", F: "##### #.... #.... ####. #.... #.... #....",
+  G: ".###. #...# #.... #.### #...# #...# .####", H: "#...# #...# #...# ##### #...# #...# #...#", I: ".###. ..#.. ..#.. ..#.. ..#.. ..#.. .###.",
+  J: "..### ...#. ...#. ...#. ...#. #..#. .##..", K: "#...# #..#. #.#.. ##... #.#.. #..#. #...#", L: "#.... #.... #.... #.... #.... #.... #####",
+  M: "#...# ##.## #.#.# #.#.# #...# #...# #...#", N: "#...# #...# ##..# #.#.# #..## #...# #...#", O: ".###. #...# #...# #...# #...# #...# .###.",
+  P: "####. #...# #...# ####. #.... #.... #....", Q: ".###. #...# #...# #...# #.#.# #..#. .##.#", R: "####. #...# #...# ####. #.#.. #..#. #...#",
+  S: ".#### #.... #.... .###. ....# ....# ####.", T: "##### ..#.. ..#.. ..#.. ..#.. ..#.. ..#..", U: "#...# #...# #...# #...# #...# #...# .###.",
+  V: "#...# #...# #...# #...# #...# .#.#. ..#..", W: "#...# #...# #...# #.#.# #.#.# #.#.# .#.#.", X: "#...# #...# .#.#. ..#.. .#.#. #...# #...#",
+  Y: "#...# #...# .#.#. ..#.. ..#.. ..#.. ..#..", Z: "##### ....# ...#. ..#.. .#... #.... #####", 0: ".###. #...# #..## #.#.# ##..# #...# .###.",
+  1: "..#.. .##.. ..#.. ..#.. ..#.. ..#.. .###.", 2: ".###. #...# ....# ...#. ..#.. .#... #####", 3: "##### ...#. ..#.. ...#. ....# #...# .###.",
+  4: "...#. ..##. .#.#. #..#. ##### ...#. ...#.", 5: "##### #.... ####. ....# ....# #...# .###.", 6: "..##. .#... #.... ####. #...# #...# .###.",
+  7: "##### ....# ...#. ..#.. .#... .#... .#...", 8: ".###. #...# #...# .###. #...# #...# .###.", 9: ".###. #...# #...# .#### ....# ...#. .##..",
+  ".": "..... ..... ..... ..... ..... .##.. .##..", ",": "..... ..... ..... ..... .##.. ..#.. .#...",
+  "&": ".##.. #..#. #.#.. .#... #.#.# #..#. .##.#", "-": "..... ..... ..... ##### ..... ..... .....",
+};
+const FONT = {};
+for (const k in GLYPHS) {
+  const s = GLYPHS[k].replace(/ /g, ""), b = new Uint8Array(35);
+  for (let i = 0; i < 35; i++) b[i] = s[i] === "#" ? 1 : 0;
+  FONT[k] = b;
+}
+
+// The disk: centre and radius in LED units, two rings of glyphs with their
+// tops to the rim, the outer one the 26 capitals at radius 26 and the inner
+// one the figures and marks at radius 15. The window is at twelve o'clock.
+const CX = 31.5, CY = 95.5, RD = 31.5, HUB = 8;
+const RINGS = [
+  { chars: "ABCDEFGHIJKLMNOPQRSTUVWXYZ", rc: 26 },
+  { chars: "0123456789.,&-", rc: 15 },
+];
+const WHERE = {};
+RINGS.forEach((ring, r) => {
+  ring.n = ring.chars.length;
+  ring.g = [...ring.chars].map((ch, j) => ((WHERE[ch] = [r, j]), FONT[ch]));
+});
+
+// The film: a strip across the top 45 rows; the line being set has its foot
+// on row GB, between columns X0 and X0 + LW.
+const FY1 = 44, GB = 41, X0 = 5, LW = 54;
+
+// The texts; the specimen of the disk's glyphs breaks its lines without a
+// hyphen.
+const TEXTS = [
+  "THE WONDERFUL WORLD OF INSECTS",
+  "THE QUICK BROWN FOX JUMPS OVER THE LAZY DOG.",
+  "ABCDEFGHIJKLMNOPQRSTUVWXYZ 0123456789.,&-",
+  "R. HIGONNET & L. MOYROUD 1946",
+];
+const SPECIMEN = 2;
+
+function hsv(h, s, v, o) {
+  h = (h - floor(h)) * 6;
+  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);
+  o[0] = i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p;
+  o[1] = i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p;
+  o[2] = i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p;
+  return o;
+}
+
+// Every pixel of the disk with its radius, its angle in radians clockwise
+// from twelve o'clock, and which ring it can show.
+const DISK = (() => {
+  const idx = [], ang = [], rad = [], ring = [];
+  for (let y = 64; y < H; y++)
+    for (let x = 0; x < W; x++) {
+      const dx = x + 0.5 - CX, dy = y + 0.5 - CY, r = sqrt(dx * dx + dy * dy);
+      if (r > RD + 0.5) continue;
+      let a = atan2(dx, -dy);
+      if (a < 0) a += TAU;
+      idx.push(y * W + x), ang.push(a), rad.push(r);
+      ring.push(abs(r - RINGS[0].rc) < 4.4 ? 0 : abs(r - RINGS[1].rc) < 4.4 ? 1 : -1);
+    }
+  return { idx: Int32Array.from(idx), ang: Float32Array.from(ang), rad: Float32Array.from(rad), ring: Int8Array.from(ring) };
+})();
+
+// Glyph value at (col, row) in its own pixels, bilinear between the cells.
+function sample(g, col, row) {
+  if (col <= -1 || col >= 5 || row <= -1 || row >= 7) return 0;
+  const c0 = floor(col), r0 = floor(row), fc = col - c0, fr = row - r0;
+  let v = 0;
+  for (let k = 0; k < 4; k++) {
+    const c = c0 + (k & 1), r = r0 + (k >> 1);
+    if (c < 0 || c > 4 || r < 0 || r > 6 || !g[r * 5 + c]) continue;
+    v += (k & 1 ? fc : 1 - fc) * (k >> 1 ? fr : 1 - fr);
+  }
+  return v;
+}
+
+// The glyph of ring r seen at a pixel of radius rr and disk angle b. The
+// angle off the glyph's centre line is under 0.23 radians, so sin and cos
+// are their first two terms.
+function diskGlyph(r, rr, b) {
+  const ring = RINGS[r], n = ring.n, jf = (b * n) / TAU, j = round(jf), d = ((jf - j) * TAU) / n, d2 = d * d;
+  const u = rr * d * (1 - d2 / 6), v = rr * (1 - d2 / 2) - ring.rc;
+  let k = j % n;
+  if (k < 0) k += n;
+  return sample(ring.g[k], u + 2, 3 - v);
+}
+
+// A glyph at magnification m as coverage of the LEDs it falls on, 3 x 3
+// samples to an LED, kept once made.
+const SCALED = {};
+function scaled(ch, m) {
+  const key = ch + m;
+  if (SCALED[key]) return SCALED[key];
+  const g = FONT[ch], w = ceil(5 * m), h = ceil(7 * m), cov = new Float32Array(w * h);
+  for (let py = 0; py < h; py++)
+    for (let px = 0; px < w; px++) {
+      let c = 0;
+      for (let sy = 0; sy < 3; sy++)
+        for (let sx = 0; sx < 3; sx++) {
+          const gx = floor((px + (sx + 0.5) / 3) / m), gy = floor((py + (sy + 0.5) / 3) / m);
+          if (gx < 5 && gy < 7 && g[gy * 5 + gx]) c++;
+        }
+      cov[py * w + px] = c / 9;
+    }
+  return (SCALED[key] = { w, h, cov });
+}
+
+// Lay a text out at magnification m: lines centred on the film, a word too
+// long for a line broken with a hyphen.
+function layout(text, m, plain) {
+  const adv = 6 * m, per = max(2, floor((LW + m) / adv)), lines = [], cut = plain ? per : per - 1, hy = plain ? "" : "-";
+  let cur = "";
+  for (let word of text.split(" ")) {
+    while (word.length > per && !cur) lines.push(word.slice(0, cut) + hy), (word = word.slice(cut));
+    if (!cur) cur = word;
+    else if (cur.length + 1 + word.length <= per) cur += " " + word;
+    else {
+      lines.push(cur), (cur = "");
+      while (word.length > per) lines.push(word.slice(0, cut) + hy), (word = word.slice(cut));
+      cur = word;
+    }
+  }
+  if (cur) lines.push(cur);
+  const out = [];
+  lines.forEach((line, k) => {
+    const x = round(X0 + (LW - (line.length * adv - m)) / 2);
+    [...line].forEach((ch, i) => out.push({ ch, line: k, x: x + i * adv }));
+  });
+  return { chars: out, lines: lines.length };
+}
+
+export function setup(params) {
+  params.s = {
+    t: 0, phi: 0, prev: 0, hue: 0, speed: 2, text: 0, m: 1, job: null, jobs: 0, ci: 0, cur: 0,
+    state: "seek", wait: 0, film: 0, filmTo: 0, pen: X0, penTo: X0,
+    lit: [], flash: null, started: false, rgb: new Float32Array(W * H * 3),
+    c: [0, 0, 0], c2: [0, 0, 0], c3: [0, 0, 0],
+  };
+  return params.s;
+}
+
+function lp(m) {
+  return ceil(7 * m) + 3;
+}
+
+// Start the job over two blank lines on: a new layout at the knobs' size.
+function begin(S) {
+  S.job = layout(TEXTS[S.text], S.m, S.text === SPECIMEN);
+  S.ci = 0;
+  S.cur = 0;
+  S.jobs++;
+  S.filmTo += 2 * lp(S.m);
+  S.state = "wait";
+  S.wait = 0.4 * sqrt(2 / S.speed);
+}
+
+function advance(S, d) {
+  S.t += d;
+  S.prev = S.phi;
+  S.phi += d * TAU * 0.4 * S.speed;
+  const slow = sqrt(2 / S.speed);
+  // The film and the carriage ease to where they are sent.
+  S.film += (S.filmTo - S.film) * min(1, d / (0.09 * slow));
+  S.pen += (S.penTo - S.pen) * min(1, d / 0.025);
+  if (S.state === "wait") {
+    if ((S.wait -= d) > 0) return;
+    S.state = "seek";
+  }
+  if (S.state === "hold") {
+    if ((S.wait -= d) <= 0) begin(S);
+    return;
+  }
+  const job = S.job;
+  if (S.ci >= job.chars.length) {
+    S.state = "hold";
+    S.wait = 1.6 * slow;
+    return;
+  }
+  const c = job.chars[S.ci];
+  if (c.line !== S.cur) {
+    // A new line: the film feeds up and the carriage goes back.
+    S.filmTo += (c.line - S.cur) * lp(S.m);
+    S.cur = c.line;
+    S.penTo = c.x;
+    S.state = "wait";
+    S.wait = 0.32 * slow;
+    return;
+  }
+  S.penTo = c.x;
+  if (c.ch === " ") {
+    S.ci++;
+    return;
+  }
+  // The disk turns anticlockwise, phi radians so far, so glyph j stands at
+  // 2 pi j / n - phi clockwise from twelve and the letter after A comes
+  // to the window next.
+  const [r, j] = WHERE[c.ch], n = RINGS[r].n, off = (TAU * j) / n;
+  const a0 = (S.prev - off) / TAU, a1 = (S.phi - off) / TAU;
+  if (floor(a1) > floor(a0)) {
+    // The glyph crossed the window during this step: flash.
+    const at = floor(a1) * TAU + off;
+    S.flash = { t: S.t, r, j, phi: at, x: c.x, m: S.m };
+    S.lit.push({ ch: c.ch, x: c.x, fy: S.filmTo, m: S.m, t: S.t });
+    if (S.lit.length > 120) S.lit.shift();
+    S.ci++;
+    S.state = "wait";
+    S.wait = 0.01;
+  }
+}
+
+export function update(dt, input, params) {
+  const S = params.s || setup(params);
+  const kv = input.knobValues || [0, 2, 0, 1], d = cl(dt || 0, 0, 0.1);
+  S.hue = kv[0] || 0;
+  S.speed = cl(kv[1], 0.2, 3);
+  const text = cl(round(kv[2]), 0, 3), m = round(cl(kv[3], 1, 2.25) * 4) / 4;
+  if (!S.job || text !== S.text || m !== S.m) {
+    S.text = text, S.m = m;
+    begin(S);
+  }
+  if (!S.started) {
+    // Run the first copy through unseen, so the film opens with it set and
+    // the second copy a few letters in.
+    S.started = true;
+    for (let f = 0; f < 2400 && !(S.jobs > 1 && S.ci > 6); f++) advance(S, 1 / 30);
+  }
+  advance(S, d);
+}
+
+function add(rgb, x, y, r, g, b, a) {
+  if (x < 0 || x >= W || y < 0 || y >= H || a <= 0) return;
+  const o = (y * W + x) * 3;
+  rgb[o] += r * a, rgb[o + 1] += g * a, rgb[o + 2] += b * a;
+}
+
+export function draw(display, params) {
+  const S = params.s;
+  if (!S || !S.job) return;
+  const rgb = S.rgb, c = S.c, c2 = S.c2, c3 = S.c3, t = S.t;
+  rgb.fill(0);
+  const light = hsv(0.55 + S.hue, 0.75, 1, c);
+
+  // The film: a dark strip with lighter edges.
+  const base = hsv(0.07, 0.45, 0.11, c2);
+  for (let y = 0; y <= FY1; y++)
+    for (let x = 1; x < W - 1; x++) {
+      const edge = x === 1 || x === W - 2 ? 1.8 : 1;
+      add(rgb, x, y, base[0], base[1], base[2], edge);
+    }
+  // Exposed letters: white when the flash lands, cooling to the light.
+  for (const L of S.lit) {
+    const G = scaled(L.ch, L.m), top = round(GB - (S.film - L.fy) - 7 * L.m + 1);
+    if (top + G.h < 0 || top > FY1) continue;
+    const w = exp(-(t - L.t) / 0.35);
+    const r0 = light[0] + (1 - light[0]) * w, g0 = light[1] + (1 - light[1]) * w, b0 = light[2] + (1 - light[2]) * w;
+    for (let py = 0; py < G.h; py++) {
+      const y = top + py;
+      if (y < 0 || y > FY1) continue;
+      for (let px = 0; px < G.w; px++) {
+        const a = G.cov[py * G.w + px];
+        if (a) add(rgb, L.x + px, y, r0, g0, b0, a * 0.9);
+      }
+    }
+  }
+
+  // The disk.
+  // Each frame shows the disk over half the frame's turn, like a shutter
+  // open half the time.
+  const n = DISK.idx.length, span = 0.5 * (S.phi - S.prev), ns = cl(ceil((abs(span) * 28) / 1.2), 1, 6);
+  const glass = hsv(0.6 + S.hue, 0.3, 0.12, c3);
+  for (let q = 0; q < n; q++) {
+    const p = DISK.idx[q], rr = DISK.rad[q], a = DISK.ang[q], ring = DISK.ring[q];
+    let r = glass[0], g = glass[1], b = glass[2];
+    if (rr > RD - 1) (r = 0.3), (g = 0.31), (b = 0.33);
+    else if (rr < HUB) {
+      // The hub, with three bolts that turn with the disk.
+      let bolt = 0;
+      for (let k = 0; k < 3; k++) {
+        const ba = (k * TAU) / 3 - S.phi, bx = CX + 4.6 * sin(ba), by = CY - 4.6 * cos(ba);
+        const x = (p % W) + 0.5, y = floor(p / W) + 0.5, e = (x - bx) * (x - bx) + (y - by) * (y - by);
+        bolt = max(bolt, cl(1.6 - e, 0, 1));
+      }
+      const v = 0.32 - 0.22 * bolt;
+      (r = v), (g = v * 1.02), (b = v * 1.06);
+    } else if (ring >= 0) {
+      let s = 0;
+      for (let k = 0; k < ns; k++) s += diskGlyph(ring, rr, a + S.phi - (span * (k + 0.5)) / ns);
+      s /= ns;
+      r += s * (0.1 + 0.32 * light[0]), g += s * (0.1 + 0.32 * light[1]), b += s * (0.1 + 0.32 * light[2]);
+    }
+    rgb[p * 3] += r, rgb[p * 3 + 1] += g, rgb[p * 3 + 2] += b;
+  }
+
+  // The flash: the glyph at the window frozen white, a glow round it, and
+  // its light through the lens to the film.
+  const F = S.flash;
+  if (F) {
+    const age = t - F.t, e = exp(-age / 0.07), eb = exp(-age / 0.12);
+    if (e > 0.01) {
+      const rc = RINGS[F.r].rc, oy = CY - rc;
+      for (let y = floor(oy - 9); y <= ceil(oy + 9); y++)
+        for (let x = 22; x < 42; x++) {
+          const dx = x + 0.5 - CX, dy = y + 0.5 - CY, rr = sqrt(dx * dx + dy * dy);
+          let a = atan2(dx, -dy);
+          if (a < 0) a += TAU;
+          const nn = RINGS[F.r].n, b = a + F.phi, jj = ((round((b * nn) / TAU) % nn) + nn) % nn;
+          const gv = abs(rr - rc) < 4.4 && jj === F.j ? diskGlyph(F.r, rr, b) : 0;
+          const halo = exp(-(dx * dx + (y + 0.5 - oy) ** 2) / 22) * 0.35;
+          add(rgb, x, y, 1, 1, 1, gv * e * 1.2);
+          add(rgb, x, y, light[0], light[1], light[2], halo * e);
+        }
+    }
+    if (eb > 0.01) {
+      // Object 5 LEDs wide at the window, lens of half-width 7.5 where it
+      // gives magnification m for the outer ring, image 5m wide with its
+      // foot on the gate.
+      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;
+      const ly = o0 - (o0 - iy) / (1 + m), ox = CX;
+      for (let y = floor(iy); y <= ceil(oy); y++) {
+        const yc = y + 0.5;
+        let cx, hw;
+        if (yc >= ly) {
+          const u = (yc - ly) / (oy - ly);
+          (cx = ox), (hw = 7.5 + (2.5 - 7.5) * u);
+        } else {
+          const u = (ly - yc) / (ly - iy);
+          (cx = ox + (ix - ox) * u), (hw = 7.5 + (2.5 * m - 7.5) * u);
+        }
+        for (let x = floor(cx - hw - 1); x <= ceil(cx + hw + 1); x++) {
+          const a = cl(hw + 0.5 - abs(x + 0.5 - cx), 0, 1);
+          add(rgb, x, y, light[0], light[1], light[2], a * eb * 0.45);
+        }
+      }
+    }
+  }
+
+  // The lens, at the height that gives the knob's magnification for the
+  // outer ring, and the carriage mark under the line.
+  {
+    const m = S.m, oy = CY - RINGS[0].rc, iy = GB + 1 - 3.5 * m, ly = oy - (oy - iy) / (1 + m);
+    const glow = F ? exp(-(t - F.t) / 0.12) : 0;
+    for (let x = 23; x <= 40; x++) {
+      const u = (x + 0.5 - CX) / 8.5, hh = 1.6 * sqrt(max(0, 1 - u * u));
+      if (hh <= 0) continue;
+      for (let y = floor(ly - hh); y <= ceil(ly + hh); y++) {
+        const a = cl(hh + 0.5 - abs(y + 0.5 - ly), 0, 1);
+        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);
+      }
+    }
+    const px = round(S.pen);
+    for (let x = px; x < px + 5 * m; x++) add(rgb, x, GB + 2, light[0], light[1], light[2], 0.45);
+  }
+
+  for (let y = 0; y < H; y++)
+    for (let x = 0; x < W; x++) {
+      const k = (y * W + x) * 3;
+      display.setPixel(x, y, min(255, rgb[k] * 255) | 0, min(255, rgb[k + 1] * 255) | 0, min(255, rgb[k + 2] * 255) | 0);
+    }
+}
diff --git a/incoming/pattern-study/patterns/quousque-tandem.js b/incoming/pattern-study/patterns/quousque-tandem.js
new file mode 100644
index 000000000..bb089a3c4
--- /dev/null
+++ b/incoming/pattern-study/patterns/quousque-tandem.js
@@ -0,0 +1,239 @@
+// ===== Patternflow pattern =====
+// Title:   Quousque Tandem
+// Family:  type
+// 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.
+// Author:  patternflow-lab
+// Date:    2026-10-29
+// SPDX-License-Identifier: CC-BY-SA-4.0
+// 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
+// Round:   70
+// ===============================
+// @matrix 64x128
+// @knobs Hue=0..1, Speed=0.2..3, Ratio=0.7..0.9, Weight=0..1
+//
+// 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.
+// 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.
+// 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.
+// 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.
+
+const W = 64, H = 128;
+const { floor, ceil, round, min, max, abs, sqrt, sin, cos, log, exp, PI } = Math;
+const cl = (v, a, b) => (v < a ? a : v > b ? b : v);
+
+function hsv(h, s, v, out) {
+  h = (h - floor(h)) * 6;
+  const i = floor(h) % 6, f = h - floor(h), p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s);
+  out[0] = i === 0 || i === 5 ? v : i === 1 ? q : i === 4 ? t : p;
+  out[1] = i === 1 || i === 2 ? v : i === 0 ? t : i === 3 ? q : p;
+  out[2] = i === 3 || i === 4 ? v : i === 2 ? t : i === 5 ? q : p;
+  return out;
+}
+
+// ---- The face. Each letter is a skeleton in em units, y up from the
+// baseline, x from the letter's left edge, written with a broad nib held at
+// 30 degrees, so a stroke is thick across the nib and a hairline along it:
+// the slanted stress of an old-style roman, thin at eleven and five o'clock
+// in the o. Serifs and bars take a narrower nib (the number after a stroke).
+// Only the 19 letters and marks of the line are drawn.
+const XH = 0.45, ASC = 0.74, DSC = 0.24, CAP = 0.665;
+function arc(cx, cy, rx, ry, a0, a1, n) {
+  const out = [];
+  n = n || max(6, ceil(abs(a1 - a0) / 9));
+  for (let i = 0; i <= n; i++) {
+    const a = ((a0 + ((a1 - a0) * i) / n) * PI) / 180;
+    out.push(cx + rx * cos(a), cy + ry * sin(a));
+  }
+  return out;
+}
+const S = 0.4;
+const GLYPHS = {
+  " ": [0.26],
+  o: [0.5, [arc(0.25, 0.225, 0.17, 0.215, 0, 360)]],
+  e: [0.45, [[0.08, 0.25, 0.4, 0.25], 0.6], [arc(0.235, 0.225, 0.16, 0.215, 8, 325)]],
+  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: [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]],
+  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]],
+    [[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]],
+  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]],
+  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]]],
+  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]],
+  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]],
+  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]],
+  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]],
+  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]],
+  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]],
+  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]],
+  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)]]],
+  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]],
+  C: [0.68, [arc(0.38, 0.33, 0.28, 0.335, 42, 318)], [[0.585, 0.55, 0.6, 0.66], S]],
+  ",": [0.24, [[0.1, 0.05, 0.09, -0.02, 0.05, -0.12]], [[0.08, 0.06, 0.11, 0.03]]],
+  "?": [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]]],
+};
+const LINE = "Quousque tandem abutere, Catilina, patientia nostra? ";
+
+// ---- The strip: the line set once at E texels to the em, each texel an
+// ink count of 0..16 from a 4 by 4 supersample, kept as a summed-area table
+// two periods long. The ink over any box of the line, at any size, is then
+// four lookups, so a line a tenth of an LED high is as exact as a big one.
+const E = 40, SS = 4, SH = Math.round((ASC + DSC) * E), BASE = ASC * E, K = E * SS;
+const NIB = 0.088, NIB_A = (30 * PI) / 180, HAIR = 0.009, PAD = 0.08;
+const DX = cos(NIB_A), DY = sin(NIB_A);
+
+// One letter at the 4x supersample, the nib stamped every eighth of a texel along
+// each stroke: a bar nib long and two hairlines wide, laid at 30 degrees.
+function glyphTile(ch, nib, hair) {
+  const g = GLYPHS[ch], TW = ceil((g[0] + 2 * PAD) * K), TH = SH * SS;
+  const t = new Uint8Array(TW * TH);
+  const stamp = (px, py, n) => {
+    const ex = DX * n + hair, ey = DY * n + hair;
+    const i0 = max(0, floor((px - ex + PAD) * K)), i1 = min(TW - 1, ceil((px + ex + PAD) * K));
+    const j0 = max(0, floor((ASC - py - ey) * K)), j1 = min(TH - 1, ceil((ASC - py + ey) * K));
+    for (let j = j0; j <= j1; j++) {
+      const qy = ASC - (j + 0.5) / K - py;
+      for (let i = i0; i <= i1; i++) {
+        const qx = (i + 0.5) / K - PAD - px;
+        if (abs(qx * DX + qy * DY) <= n && abs(qx * DY - qy * DX) <= hair) t[j * TW + i] = 1;
+      }
+    }
+  };
+  for (let s = 1; s < g.length; s++) {
+    const pts = g[s][0], n = (nib / 2) * (g[s][1] || 1);
+    for (let p = 0; p + 3 < pts.length; p += 2) {
+      const ax = pts[p], ay = pts[p + 1], bx = pts[p + 2], by = pts[p + 3];
+      const steps = max(1, ceil(sqrt((bx - ax) ** 2 + (by - ay) ** 2) * K * 2));
+      for (let q = 0; q <= steps; q++) stamp(ax + ((bx - ax) * q) / steps, ay + ((by - ay) * q) / steps, n);
+    }
+  }
+  return { t, TW };
+}
+
+function buildStrip(weight) {
+  const nib = NIB * (0.94 + 1.1 * weight), hair = HAIR * (0.9 + 0.8 * weight);
+  let adv = 0;
+  const xs = [];
+  for (const ch of LINE) xs.push(adv), (adv += GLYPHS[ch][0]);
+  const P = round(adv * E), HW = P * SS, HH = SH * SS, hi = new Uint8Array(HW * HH), tiles = {};
+  LINE.split("").forEach((ch, c) => {
+    if (ch === " ") return;
+    const { t, TW } = tiles[ch] || (tiles[ch] = glyphTile(ch, nib, hair));
+    const o = round((xs[c] - PAD) * K);
+    for (let j = 0; j < HH; j++)
+      for (let i = 0; i < TW; i++) if (t[j * TW + i]) hi[j * HW + ((o + i + HW) % HW)] = 1;
+  });
+  const SW = 2 * P, SW1 = SW + 1, sat = new Int32Array((SH + 1) * SW1);
+  for (let r = 0; r < SH; r++) {
+    let run = 0;
+    for (let c = 0; c < SW; c++) {
+      const cc = c % P;
+      let n = 0;
+      for (let j = 0; j < SS; j++) for (let i = 0; i < SS; i++) n += hi[(r * SS + j) * HW + cc * SS + i];
+      run += n;
+      sat[(r + 1) * SW1 + c + 1] = sat[r * SW1 + c + 1] + run;
+    }
+  }
+  return { P, SW, sat };
+}
+
+// The ink above row v and left of column u, bilinear between the corners,
+// which is the exact area integral of ink that is constant over a texel.
+function satAt(st, u, v) {
+  const SW1 = st.SW + 1, sat = st.sat;
+  let iu = floor(u), iv = floor(v), fu = u - iu, fv = v - iv;
+  if (iu >= st.SW) (iu = st.SW - 1), (fu = 1);
+  if (iv >= SH) (iv = SH - 1), (fv = 1);
+  const o = iv * SW1 + iu, a = sat[o], b = sat[o + 1], c = sat[o + SW1], d = sat[o + SW1 + 1];
+  return (a + (b - a) * fu) * (1 - fv) + (c + (d - c) * fu) * fv;
+}
+
+// ---- The sheet. Line v (v = 0 the top line) fills rows 128 (1 - r^v) to
+// 128 (1 - r^(v+1)), its em that height over LEAD, its left edge 0.06 em in.
+// That is the picture of one page scaled by r about its bottom left corner
+// again and again, so moving every v down by one over a period zooms the
+// page by 1/r and each line takes the place and size of the line above.
+const LEAD = 1.05, PERIOD = 2.5;
+// The grain: a checker of LEDs G levels lighter and darker over the whole
+// sheet, eased off where a soft step of the ink's own is already there so
+// the two never add up past a step of 40.
+const G = 19.5, HARD = 60;
+
+export function setup(params) {
+  params.s = {
+    t: 0, w: -1, st: null, cache: {}, hue: 0, ratio: 0.7,
+    cov: new Float32Array(W * H), emRow: new Float32Array(H), F: new Float32Array(W + 1),
+    pc: [0, 0, 0], ic: [0, 0, 0],
+  };
+  return params.s;
+}
+
+export function update(dt, input, params) {
+  const S0 = params.s || setup(params);
+  const kv = input.knobValues || [0, 2, 0.7, 0.06], d = cl(dt || 0, 0, 0.1);
+  S0.hue = kv[0] || 0;
+  const speed = cl(kv[1] ?? 2, 0.2, 3);
+  S0.ratio = cl(kv[2] ?? 0.7, 0.7, 0.9);
+  // The weight in sixteenths. A strip takes about 40 ms to build, so the
+  // last few are kept while the knob turns.
+  const w = round(cl(kv[3] ?? 0.06, 0, 1) * 16) / 16;
+  if (w !== S0.w) {
+    if (!S0.cache[w] && Object.keys(S0.cache).length >= 6) S0.cache = {};
+    S0.w = w;
+    S0.st = S0.cache[w] || (S0.cache[w] = buildStrip(w));
+  }
+  S0.t += (d * speed) / 2;
+}
+
+export function draw(display, params) {
+  const S0 = params.s;
+  if (!S0 || !S0.st) return;
+  const st = S0.st, cov = S0.cov, emRow = S0.emRow, F = S0.F, P = st.P;
+  cov.fill(0);
+  emRow.fill(0);
+  const lr = log(S0.ratio), cyc = S0.t / PERIOD, ph = cyc % 1, n0 = floor(cyc);
+  const Y = (v) => H - H * exp(v * lr);
+  for (let k = 0; k < 200; k++) {
+    const v = k - ph, top = Y(v), bot = Y(v + 1);
+    if (H - top < 0.04) break;
+    if (bot <= 0) continue;
+    const em = (bot - top) / LEAD, y0 = top + ((LEAD - 1) / 2) * em, sc = E / em, xl = 0.06 * em;
+    for (let y = max(0, floor(top)); y < min(H, ceil(bot)); y++) {
+      const va = cl((y - y0) * sc, 0, SH), vb = cl((y + 1 - y0) * sc, 0, SH);
+      if (vb <= va) continue;
+      if (em > emRow[y]) emRow[y] = em;
+      // Every other line leans 12 degrees for the italic: a texel row h
+      // above the baseline is read 0.21 h further left.
+      const sl = (k + n0) & 1 ? 0.21 * (BASE - (va + vb) / 2) : 0;
+      for (let x = 0; x <= W; x++) F[x] = max(0, (x - xl) * sc - sl);
+      for (let x = 0, o = y * W; x < W; x++) {
+        let u0 = F[x], u1 = F[x + 1];
+        if (u1 <= u0) continue;
+        const wrap = floor(u0 / P) * P;
+        u0 -= wrap;
+        u1 -= wrap;
+        cov[o + x] += (satAt(st, u1, vb) - satAt(st, u0, vb) - satAt(st, u1, va) + satAt(st, u0, va)) / (16 * sc * sc);
+      }
+    }
+  }
+  // Type over 4 LEDs to the cap is drawn crisp, its coverage pushed toward
+  // ink or paper with a soft edge a quarter of an LED wide; under 1.5 LEDs
+  // it keeps its exact area, the grey of the small sizes.
+  for (let y = 0; y < H; y++) {
+    const m = 1 + 3 * cl((emRow[y] * CAP - 1.5) / 2.5, 0, 1);
+    for (let x = 0, o = y * W; x < W; x++) cov[o + x] = cl((min(1, cov[o + x]) - 0.5) * m + 0.5, 0, 1);
+  }
+  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);
+  const con = 255 * (max(pc[0], pc[1], pc[2]) - max(ic[0], ic[1], ic[2])), hc = HARD / con;
+  const p0 = 255 * pc[0], p1 = 255 * pc[1], p2 = 255 * pc[2];
+  const d0 = 255 * ic[0] - p0, d1 = 255 * ic[1] - p1, d2 = 255 * ic[2] - p2;
+  for (let y = 0, o = 0; y < H; y++)
+    for (let x = 0; x < W; x++, o++) {
+      const c = cov[o];
+      let gd = 0;
+      const nb = (e) => (e = abs(c - e)) < hc && e > gd && (gd = e);
+      if (x > 0) nb(cov[o - 1]);
+      if (x < W - 1) nb(cov[o + 1]);
+      if (y > 0) nb(cov[o - W]);
+      if (y < H - 1) nb(cov[o + W]);
+      const a = G * max(0, 1 - (gd * con) / (2 * G)), g = (x + y) & 1 ? a : -a;
+      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);
+    }
+}