Primordial — Lenia Life Laboratory Demo Creation

Let me check the current state of the demos folder to see what's there, then decide what to do. The task says "Wake up and do as you please." So I have freedom to create a new demo or improve existing ones.

Let me first look at the current state of the demos folder.

Let me look at the demos folder structure to see what exists.

There are 46 demos. The task says "Wake up and do as you please." So I should create a new demo — demo 047. Let me check the index.html to see the current format and see what demos exist, then pick something new and exciting that hasn't been done yet.

Existing demos cover:

1. Spinning cube
2. Nebula galaxy (particles)
3. Mandelbulb explorer (ray marching)
4. Fluid dynamics
5. Gravity sandbox
6. Event horizon (black hole)
7. Sonic reactor (audio)
8. Void runner (game)
9. Azure odyssey (game?)
10. Abyssal bloom (underwater)
11. Physarum garden (slime mold)
12. Powder alchemy (falling sand)
13. Clockwork nebula
14. Neon rain
15. Aurora borealis
16. Skitter (creatures)
17. Coral resonance
18. Threshold
19. Attractorium (strange attractors)
20. Murmuration (flocking)
21. Terraforge (terrain)
22. Cloudsea (clouds)
23. Frostline (snow/ice)
24. Koi pond
25. Ferrofluid
26. Synchrony (coupled oscillators?)
27. Cymatics
28. Teslasphere
29. Pyrosymphony (fireworks)
30. Morphogenesis (reaction-diffusion?)
31. Galton cascade
32. Wavefront
33. Gossamer (spider webs?)
34. Magnetosphere
35. Cloud chamber (particle physics)
36. Wavefunction (quantum)
37. Epicycle (orbits)
38. Sandpile (abelian sandpile)
39. Kinetic theory (gas)
40. Lumen lab (optics)
41. Squish lab (soft body physics)
42. Neon tilt (marble game?)
43. Hyperfold (4D?)
44. Photon garden (ray tracing / light)
45. Critical point (phase transition / Ising?)
46. Bridge works (bridge building physics game)

What's missing? Ideas for demo 047:

• Double pendulum chaos gallery
• Ant colony simulation
• Predator-prey ecosystem
• Wave-particle duality / quantum tunneling
• Origami / paper folding
• L-system / fractal trees / procedural plants
• Solar system with real physics
• Raymarched fractal landscape
• Fire/smoke simulation (Eulerian fluid with combustion)
• Cloth simulation (flags, curtains) — 033 gossamer might be webs
• Rope/cable physics
• Sokoban 3D?
• Voxel terrain destructible
• Water ripple caustics
• Double-slit experiment
• Cardiac/heartbeat simulation
• Traffic flow simulation
• Boids already done (murmuration)
• Newton's cradle
• Spring-mass lattice (jelly — done squish lab)
• Kaleidoscope
• Maze generation + solver
• Rubik's cube
• Chess 3D
• Pinball machine!
• Marble run builder
• Domino chain reaction — physics dominoes!
• Trebuchet / catapult physics
• Rocket simulator / Kerbal-style
• Tides / orbital resonance
• Prism / dispersion (done lumen lab?)
• DLA (diffusion-limited aggregation) crystal growth
• Snowflake growth
• Ant colony / pheromone trails
• Ecosystem / evolution
• Conway's Game of Life 3D
• Lenia (continuous cellular automata) — that's cool!
• Wave equation drum
• Ferrofluid done
• Magnetic field lines done (magnetosphere)
• Laser puzzles
• Black hole done
• Lorenz attractor done (attractorium)
• Terrain done (terraforge)
• Clouds done (cloudsea)

Pinball would be a fun playable game. Dominoes chain reaction is fun physics. Lenia is a beautiful continuous cellular automaton — very visually impressive with shader-based computation.

Actually, let me think about what would be a "wow" demo. A few strong candidates:

1. Pinball machine — playable game with flippers, bumpers, physics, score, bloom. Fun and interactive.

2. Lenia — continuous cellular automaton with GPU compute, evolving blob creatures. Visually stunning, hypnotic.

3. Domino Rally — build domino runs on a 3D playground, knock them over with physics. Interactive and satisfying.

4. Rocket / orbital mechanics game — launch rockets, orbit planets.

5. Tide pool / wave tank — shallow water equation simulation with interactive splashing, rendered with realistic water shading and caustics. Beautiful.

6. Snowflake studio — crystal growth simulation.

Let me check what a few of the recent demos are to avoid overlap. Let me quickly scan index.html for titles/descriptions.

Let me look at the index.html structure directly.

Let me see the format of a demo card and list all existing titles to avoid duplication.

Now I have a full list of 46 demos. Let me pick something fresh and impressive for demo 047. Ideas not yet covered:

1. Lenia — continuous cellular automaton, GPU-based, gorgeous evolving life-forms. Very "wow".
2. Pinball — playable physics game.
3. Domino rally — physics chain reactions.
4. Wave tank / shallow water — interactive water with caustics.
5. Snowflake growth — crystal simulation.
6. Ant colony — pheromone trails.
7. Rocket launch / orbital game.
8. Double pendulum chaos.
9. Trebuchet.
10. Kaleidoscope.
11. Voxel destructible terrain.

The style guidelines: "interactive experiences/games", "particle systems, custom GLSL shaders, post-processing, physics, procedural generation, audio-reactivity, instancing, gameplay mechanics, HUDs".

I think a really fun one would be Lenia — primordial soup lab: GPU shader-based continuous cellular automaton where creatures emerge, with interactive tools (paint, perturb), parameter sliders (kernel, growth function), and creature cataloging. It's hypnotic and advanced.

Alternatively, a wave tank with shallow-water equations on GPU, realistic water surface rendering with reflection/refraction/caustics, interactive splashes, floating objects. That's also beautiful.

Or pinball — a fully playable game is always good. The user liked games (void runner, neon tilt). A polished 3D pinball with custom physics, bloom, sound would be great.

Hmm, let me think about what gives maximum wow per effort and reliability. GPU shader Lenia is compact (a few shaders), reliable (no complex physics tuning), and endlessly mesmerizing. Plus interactivity: paint cells, spawn known creatures (Orbium etc.), adjust parameters live.

Let me go with 047 Lenia — "Primordial Soup" / "Lenia Lab". Name: "Souplife"? "Lenia — Primordial Soup"? Let me call it "047-lenia" with title "Lenia — Primordial Soup Lab" or something catchy like "Soupkinds"... Let me name it "Lenia Lab" — clean.

Actually — a creative name like "Primordial" or "Souplight"... The demo titles so far are evocative: "Critical Point", "Photon Garden", "Morphogenesis". Since 030 Morphogenesis is reaction-diffusion (probably), Lenia is related but distinct (continuous CA). To differentiate, I'll lean into the "creatures in a petri dish" angle with a beautiful presentation: dark petri dish, glowing bioluminescent organisms, bloom, tools to paint food/repellent, a creature census that detects stable blobs, multiple kernel/growth presets (Orbium, Scutium, etc.), smooth color mapping (density → palette with iridescence), and audio ambience maybe.

Lenia implementation details:

• State: 2D texture (R channel = density, maybe RGB for multi-channel). Resolution 512x512 or so.
• Kernel: ring kernel (Gaussian bump over radius), precomputed into a texture; convolution via FFT or direct? Direct convolution with a large kernel (e.g., radius 13-20) is expensive per-pixel: for R=16, that's ~800 taps — too slow for 512² at 60fps in a naive fragment shader? Actually 512×512×800 = 210M ops per frame — modern GPUs can do that, but on weaker devices it might struggle. Options:
  1. Use FFT-based convolution — complex but fast.
  2. Use smaller kernel radius (R=8-10) with separable approximation? Ring kernels aren't separable, but we can approximate the kernel as a sum of a few Gaussians... not straightforward.
  3. Sample the kernel coarsely and rely on smoothness — Lenia kernels are smooth; sampling every 2nd pixel with R=12 gives ~113 taps. That's fine.
  4. Reduce sim resolution to 384² or 256², upscale with smoothing. Lenia at 256² with R=12 still shows nice creatures (creatures are ~2R in diameter).

A common approach: multiple rings sampled at moderate resolution. Let me do direct convolution with R=13, sampling step 1, but sim resolution 256–384. 384²×(π·13²≈530 taps) ≈ 78M multiply-adds per step. We can also do 2 substeps per frame. GPUs handle this easily (a midrange GPU does teraflops; 78M×2×60 = 9.4 GFLOPs/s — trivial).

Actually, another trick: store kernel in a texture and use bilinear sampling of both field and kernel to reduce taps. Keep it simple: direct.

Better approach for flexibility: multi-channel Lenia with per-channel kernels gets heavy. Keep single-channel classic Lenia, but offer several presets:

• Orbium (classic): R=13, β=1 ring, μ=0.15, σ=0.017, T=10
• Actually parameter presets from the Lenia paper:
  • Orbit: mu=0.15, sigma=0.017, R=13, beta=[1], growth = gaussian
  • Scutium: mu=0.26, sigma=0.023? I don't remember exactly.

Known Lenia params (from Chan's paper / Bert Chan's implementations):

• "Orbium": R=13, T=10, m=0.15, s=0.017, β=[1] (single ring bump), kernel core = exp(−((x−0.5)²)/(2·0.15²)) bump over ring distance.
• Variants discovered by tweaking. I'll include a handful of presets with names and let users tweak μ/σ/R/T and kernel rings (up to 3 rings with adjustable β heights), growth function (gaussian, quadratic, wave/multi-modal).

Rendering: map density [0,1] to a nice palette — e.g., deep teal→cyan→white with magenta accents; add faux-3D lighting via gradient normals (like a relief), iridescent sheen, bloom post. Show in a circular petri dish vignette. Add subtle drifting "nutrient" background.

Interactivity:

• Brush paint: add/remove density with adjustable radius/strength, symmetry modes (mirror/radial kaleidoscope painting!) — that's fun.
• Presets: seed random soup, spawn Orbium at cursor, clear.
• Parameter sliders: μ, σ, R, dt (T), kernel rings.
• Stats: total mass, FPS, "creature census" (connected components count via CPU readback occasionally?) — maybe skip heavy census; do mass + activity (mean |Δ|).
• Post: UnrealBloom, vignette, grain.
• Audio: gentle ambient pad whose brightness follows activity? Could add simple WebAudio drone with toggle. Keep optional and off by default? Recent demos included generative audio. I'll add a subtle toggle-able ambient.

Symmetry painting (kaleidoscope) is a big fun factor. Also "wind"/flow advection toggle? Lenia with slight advection creates moving streams. Maybe skip.

Multi-resolution: support resize; sim at fixed 384² in a toroidal domain rendered inside circular dish (mask edges with soft falloff — apply circular damping at boundary or just draw circle). Toroidal wrap but render circular mask.

Structure: self-contained index.html, import map for three r160+, EffectComposer with bloom from three/addons. Sim via THREE.WebGLRenderTarget ping-pong with raw shaders (FullScreenQuad). Use GPGPU-style code.

Let me design carefully:

Sim shaders:

1. Kernel build (CPU): compute kernel values into Float32Array texture (size (2R+1)²) once per param change. Kernel: for r in [0,1] ring distance x=r·(rings spacing)... Classic: kernel ring function k(x) = exp(−((x−0.5)/0.15)²/2) sampled at positions x = i/β_count... Actually kernel shell: for each of β rings i in 0..B-1, bump β_i · bump((x − (i+0.5)/B)·B)? Let me recall precisely:

Lenia kernel: K(r) = β[floor(r·B)] · bump(r·B mod 1), where bump(x)=exp(−((x−0.5)/w)²/2), w=0.15, normalized so sum K = 1. r = distance/R in [0,1].

2. Convolution shader: sum over kernel texture area: for dy in -R..R, dx in -R..R: potential += field(u+o)·K(o). That's the heavy loop. With R=13 → 27²=729 iterations per pixel. At 384² = 147k pixels → 108M texel fetches per step. Hmm, 2 fetches per tap (field + kernel) → ~216M fetches/step. On integrated GPUs at 60fps could be borderline but likely OK; I'll add quality tiers (sim res 512/384/256) with auto-degrade based on fps.

Optimization: skip taps where kernel ~0 (ring bump is near zero between rings) — but branching per-tap is costly. Alternative: precompute a list of (offset, weight) for taps with |K|>eps into a data texture, and loop over that list (typically ~150-250 taps for bump width 0.15). That cuts cost ~3-4×! Kernel texture as (offsetX, offsetY, weight) packed into RGB of a 1D texture of length N (up to 729). Loop N times. N≈ for B=1 ring of width ~±0.45R·... bump nonzero within |x−0.5|<~3w=0.45 → ring radius r∈[0.05,0.95]·R → annulus area π(0.95²−0.05²)R² ≈ 0.9πR²... wait that's the whole annulus for single ring at x∈[0,1]? bump(r·B mod 1) for B=1: bump(x) nonzero for x in [0.05,0.95] → annulus r/R∈[0.05,0.95] → area ≈ π·0.9·R² ≈ 458 taps for R=13. Hmm, not much saving. With w=0.15, bump(x)=exp(−((x−.5)/.15)²/2); at |x−0.5|=0.375 → exp(−3.125)≈0.044. Cutoff 0.01 → |x−.5|≈0.42. So annulus 0.08..0.92 → ~0.83πR²≈440 taps. Meh.

Better optimization: separable? No. FFT? Complex.

Alternative: lower sim res (256²) → 65k px × 440 taps ≈ 29M fetches — trivial for any GPU. Creatures at R=13 within 256² look fine (creature diameter ~26px, dish 256px → fits ~80 creatures). Actually classic Lenia runs at 256–512 with R=13-18. Let me default 320²? Use 256 or 384 with quality scaling. I'll default to 384 with auto-tier down to 256 if fps low, up to 512 if fast (R scaled? No — keep R constant in cells; res changes creature size relative to dish, acceptable. Actually changing resolution mid-run destroys state anyway (need resample) — only change res on reset or through resample copy which is fine (GPU sample with bilinear).

Hmm — simpler: fixed 384², R default 13 (adjustable 6..24). Max taps πR² for R=24 = 1809 taps at 384² = 267M — too heavy maybe; but user choice. I'll cap loop at compile-time max R=20 (41²=1681 iter loop with early weight check? GLSL loops need constant bounds; use MAX_R=20 constant, loop -20..20 and multiply by weight where outside R weight=0 — wasted taps for small R). Precomputed sparse list is better: constant MAX_TAPS=1024 loop with data texture; taps beyond N have weight 0 → GPU still executes but just 2 fetches + fma; 1024 iters × 147k px = 151M fetch-pairs... borderline.

Let me think about real-world perf: modern laptop GPU (M1/Iris) does ~1-2 TFLOPs and ~50-100 GTexel/s. 384²×1024 taps×2 tex = 302M texels/step, 2 substeps/frame → 604M texels/frame ×60fps = 36Gtexel/s — too much for integrated, fine for discrete.

Safer: default res 288², sparse taps ~440 (R=13) → 288²×440×2=73M texels/step; ×2 steps ×60 = 8.7 Gtexel/s — OK on most. And quality scaler drops substeps to 1 and/or res to 224/192.

Alternatively use hexagonal sampling or sample kernel at half resolution... Keep it simple with auto quality: measure fps; tiers: res {352, 288, 224}, substeps {2,1}. Also pausing sim when tab hidden (RAF does that anyway).

Actually, you know what — WebGL2 transform feedback / float textures are fine. Use half-float RG textures? Single channel R16F enough. Some mobile GPUs can't filter R16F linearly — we do nearest anyway in convolution; upscaling for display can be smoothstep in shader instead of hardware filtering. Keep NEAREST + shader smoothing (bicubic-ish or just smooth palette mapping — blobs look organic anyway with slight pixelation hidden by relief shading + bloom).

Growth shader: A' = A + dt·(2·G(U)−1) where G(U) = exp(−((U−μ)/σ)²/2), clamp [0,1]. dt = 1/T.

Extra features to make it stand out:

1. Multi-kernel "ecosystem" presets: Orbium, Orbium unium (faster), Scutium (crab-like), "Gyrus" etc. I'll craft presets from known Lenia lore:

   • Orbium: m=0.15 s=0.017 β=[1] R=13 T=10
   • "Orbium unium"? Not sure of params.
   • Known good: m=0.156, s=0.0118, β=[1] — variants.
   • Scutium: m=0.26, s=0.023, R=13? Hmm I'm not certain. Let me instead include param sets I'm fairly confident produce interesting results:
     • Orbium: μ=0.15, σ=0.017, β=[1], T=10, R=13
     • "Orbit (wide)": μ=0.15, σ=0.0157, β=[1], R=18?
     • Scutium solidum: I recall μ≈0.26 σ≈0.023? Risky.
     • Multi-ring: β=[1, 1/3, 1]? with μ=0.15 σ=0.02 gives patterned "lithium" style.
     • "Hydrogeminium": β = [1, 1/2, 2/3]? Since exact paper params are fuzzy for me, I'll ship 4 presets: Orbium (confident), Geminium (β=[1, 1/2], μ=0.15? ... ), and mark sliders for exploration. I'll test presets numerically with a headless node harness! I can implement the sim in Node quickly (same math) and check whether patterns persist (mass stays in a band, activity nonzero) for chosen presets. That's doable and worth it for quality.

2. Symmetry brush with modes: none, mirror X, mirror XY, radial 6. Painting gaussian blobs.

3. Creatures gallery: buttons spawn curated "seeds" (e.g., a disk of radius ~R·0.9 at 0.5 density spawns Orbium under classic params — spawning just paints a soft disk at cursor).

4. Flow field advection toggle: adds slow rotational drift (advect state with velocity field via semi-Lagrangian) — creates "soup currents". Subtle wow. Maybe skip to control scope... Actually small: one extra line in update shader reading velocity from curl noise texture. Hmm, keep if easy: precompute a static smooth vector field texture (few octaves of gradient noise, divergence-free-ish), advect with strength slider (default small, can be 0). It's a nice differentiator. I'll include it (cheap: in growth pass, sample A at uv − v·dt/rez).

5. Relief rendering: normal from density gradient, key light, iridescent palette (IQ cosine palette), specular, edge glow from laplacian maybe. Petri dish: circular mask with rim highlight, faint grid, subtle background nebula.

6. HUD: mass, activity, fps, generation counter; toasts; help overlay; keyboard shortcuts; PNG snapshot button.

7. Post: UnrealBloomPass + final grade shader (vignette, grain, slight chromatic). Use three addons.

8. Audio: optional generative drone tied to activity — toggle button, default off (browsers need gesture anyway).

Let me also verify: three version — check what recent demos use (e.g., 046) for CDN consistency.

Let me check the structure of a recent demo to match conventions (import map, addons).

*******************************************************************************************************p).

Good. Standard: three@0.170.0 via unpkg, ES modules + import map, single self-contained index.html.

Now, plan demo 047: "Lenia — Primordial Soup Lab" (folder 047-lenia-soup or 047-primordial-soup). Title ideas: "Primordial Soup", "Lenia", "Soup of Life". Let me go with folder 047-lenia and title "Lenia — Primordial Soup Lab".

Before writing the big HTML file, I want to validate the Lenia math and preset parameters with a Node harness (pure JS simulation) so that presets actually produce living creatures:

• Implement 256² grid, R=13, kernel β=[1] bump, μ=0.15, σ=0.017, dt=1/T, T=10, growth 2G−1, clip. Seed random noise blob in center; run 2000 steps; measure mass and activity. Check it doesn't die out (mass > threshold) and isn't filling everything (mass fraction < 0.9).

Also test multi-ring presets:

• β=[1, 0.5]? μ maybe different. Let me just test a few parameter sets and pick ones that survive with interesting activity.

Node availability? Let me check node version in the sandbox.

Kernel construction (classic Lenia / Bert Chan's "Greater Lenia"):

• kernel radius R (in cells), ring count B, β = weights per ring.
• For cell offset (dx,dy): r = sqrt(dx²+dy²)/R ∈ [0,1]; ring index i = floor(r·B); within-ring pos x = r·B − i; K = β[i] · bump(x), bump(x) = exp(−((x−0.5)/w)²·(1/2))... In the paper: kernel core is a "bump" function, e.g. Gaussian bump: exp(a − a/(4x(1−x))) or simple Gaussian exp(−((x−0.5)/w)²/2) with w=0.15. Both used. I'll use Gaussian bump with w=0.15, simple.
• Normalize: divide by sum of K over all offsets.

Growth: G(U) = 2·exp(−((U−μ)²)/(2σ²)) − 1; A ← clip(A + (1/T)·G(U), 0, 1).

Orbium parameters (from Chan 2019): μ=0.15, σ=0.017, R=13, T=10, β=[1]. Actually the paper's Orbium used R=13, and the "orbium" creature emerges with μ=0.15, σ=0.017. I'm fairly confident. Variants (from lenia lore / SmoothLife-ish):

• Scutium: β=[1], μ=0.26, σ=0.023? Not sure. Let me just harness-test:

1. (0.15, 0.017, [1], R13, T10)
2. (0.156, 0.0118, [1], R13, T10)
3. (0.14, 0.014, [1, 0.6], R13, T10)
4. (0.19, 0.019, [1, 1/3], ...)
5. (0.26, 0.025, [1], R13, T10)
6. (0.115, 0.02, [1]...)
7. (0.35, 0.055, [1, 0.8, 0.5]) etc.

I'll test survival/interest metrics and pick 4 presets: classic Orbium, a multi-ring pattern former, a fast sparse one, and "chaos soup" one.

Also test the "spawn disk" trick: paint disk radius ~0.8R, density 0.5–0.8 → should condense into Orbium.

Plan for the demo file:

Visual design: "Bioluminescent petri dish" — dark lab bench background (subtle radial gradient, faint dust particles), glowing dish with the culture. Palette: deep indigo background, cells in cyan/teal with magenta highlights, golden rim light. Bloom. Title "LENIA", subtitle "primordial soup laboratory".

UI:

• Top-left: HUD title + generation/mass/activity/fps stats.
• Left/bottom panel: "Culture presets" buttons (Orbium, Geminium, Scutium-like "Fortress", "Plasma storm"), each reseeds with tuned params.
• Sliders: μ (growth center), σ (growth width), R (kernel radius), T (speed), brush size, flow strength. Maybe kernel ring weights as 3 mini sliders (β1 β2 β3) with a little kernel preview canvas! Kernel preview: small canvas drawing radial kernel profile — nice educational touch.
• Tools: Paint (add), Erase, Spawn Orbium (disk seed), Stir (random local velocity?), Kaleidoscope symmetry selector (1/2/4/6/8), Clear, Seed Soup (random), Pause, Snapshot PNG, Audio toggle.
• Bottom hint bar with shortcuts.
• Toast messages.

Sim core:

• WebGL2, float textures (EXT_color_buffer_float for RG16F/RGBA16F render targets; WebGL2 required — fallback message if unavailable).
• Ping-pong RGBA16F (use R channel; could store previous for display interpolation—keep R).
• Pass A (convolution): computes U = (K∗A) → store in target.
• Pass B (growth): A' = clip(A + dt·(2gauss(U;μ,σ)−1) + advection). Combine: could do single pass computing convolution then growth directly reading A — yes single pass: read A texture, convolve, then growth-update A and write. One pass per step, one texture read set. Convolution needs only A. So: out = growth(A, conv(A)). Single shader, ping-pong.
• Sparse kernel taps: precompute offsets+weights on CPU into a DataTexture (RGBA32F or RGBA16F: dx, dy, w, 0) length N; shader loops MAX_TAPS with if (i>=N) break; — allowed in WebGL2 (dynamic break with uniform comparison is fine; loop bound must be constant-ish? In GLSL ES 3.00 loops can have dynamic bounds, but for safety use constant MAX_TAPS and break). MAX_TAPS: for R up to 24, full area πR² ≈ 1810. Cap R slider at 20 → 1257. Hmm MAX_TAPS=1600 loop even when N=150 wastes. The break handles it — GPUs handle break fine-ish. Or use 3 shader variants for small/med/large... Keep MAX_TAPS=2048 constant, break early; typical N: R=13 w/ cutoff → ~500. Wasted iterations don't execute body after break (fine). Actually smarter: build taps only where |K| > 1e-4. For β=[1], w=0.15: annulus thickness ~0.84R → ~460 taps at R=13, ~1100 at R=20. OK.
• Resolution: default 384; quality auto-tier {384, 320, 256} based on fps; also manual quality selector (Auto/High/Med/Low). Res change → resample state via a copy shader (draw old texture into new RT with bilinear).
• Substeps: 2 per frame default (T scaled: dt=1/T each), tier down to 1.

Wait — T in Lenia: dt = 1/T per step with T=10 → each generation step is small. 2 substeps/frame → 120 steps/s → creature motion nicely visible. Good.

Rendering pass: fullscreen shader (not just MeshBasicMaterial) displaying:

• Sample state (smooth via bilinear on RGBA16F — filtering R16F requires OES_texture_float_linear? RGBA16F linear filtering is supported with EXT... In WebGL2, float16 textures are filterable natively? OES_texture_half_float_linear is WebGL1; WebGL2 supports linear filtering of half-float textures natively (yes, half float linear is core in WebGL2). Full float32 needs OES_texture_float_linear. So use RGBA16F → linear OK.)
• Palette: density → color. Use IQ palette: pal(t) = a + b·cos(2π(c·t+d)). Choose a=(0.12,0.35,0.45) etc. Tune: deep teal → cyan → white-hot core; plus magenta fringe at mid values.
• Relief: compute gradient via 4 taps → normal → diffuse + spec from key light + fresnel rim.
• "Activity glow": could pass second texture storing |Δ| from growth pass (write delta into G channel) → glow map for bloom to catch. Nice: creatures shimmer where changing. Store G = smoothed |A'−A|.
• Dish: circular mask radius 0.48 of screen min dimension; inside dish render culture; outside: dark bench with subtle vignette + faint hex/grid? Keep: radial gradient background, faint dust motes (animated noise), dish rim ring with metallic highlight, glass reflection streak.
• Post chain: RenderPass (scene = fullscreen quad with this shader), UnrealBloomPass (strength ~0.7, radius 0.6, threshold 0.35), final grade ShaderPass (vignette, grain, slight chromatic aberration, tonemap tweak). Actually OutputPass for color space.

Camera: trivial orthographic fullscreen; but to make it fancy add slight parallax tilt on mouse move (dish tilts like held petri dish?) — could render quad with a perspective camera and subtle rotation following pointer. Nice touch, cheap. The sim texture maps onto a disk mesh slightly tilted in 3D with rim mesh (torus) and glass highlight. Hmm, simpler: keep fullscreen quad but apply a subtle 2D perspective warp via shader uniforms driven by pointer. I'll do actual 3D: a cylinder rim (torus) + disk plane for culture; bloom makes it glow; camera at z with slight pointer parallax. Rim mesh with MeshStandardMaterial + environment? Keep it shader-based for control.

Simplest robust approach that still looks 3D: fullscreen quad shader does everything including dish rim shading (draw rim in-shader: annulus ring with radial highlight + inner shadow + glass streak). Parallax: uniform vec2 tilt offsets dish center slightly & rim highlight angle. Good — no 3D meshes needed, but still uses three for composer.

Audio (optional toggle): WebAudio — two detuned sine/triangle drones through lowpass + slow LFO, plus activity-driven shimmer (filtered noise, cutoff from activity), soft plip when spawning/painting? Keep minimal: drone + activity shimmer. Off by default; toggle button.

Extras for wow/learning:

• Kernel & growth function live preview mini-canvases (2D canvas plots).
• "Field notes" log (like 045/046 have): toasts + a small log line for events (preset loaded, extinction detected!, explosion detected). Extinction detector: if mass < threshold after warmup → toast "The soup went sterile — reseed?". Bloom detector: mass > 60% → "overgrowth".
• Statistics: mass %, activity, generation count, fps, creature estimate? skip estimate.
• Keyboard: Space pause, R reseed, C clear, B brush mode cycle, [ ] brush size, 1-4 presets, S snapshot, M audio, H help overlay.
• Help overlay panel with explanation of Lenia math (educational) — brief.

Files: /space/demos/047-lenia/index.html only. Update index.

Validation:

• Extract JS and run through node --check (module syntax) — but it's inside HTML; extract script content. Use same approach as previous demos: harness with puppeteer? Probably not installed. At minimum: node --check on extracted module (imports of three will fail on resolve? node --check only parses, doesn't resolve — good).
• Additionally run a pure-math Node harness validating presets (separate file in /tmp).

Let me check node availability and start with the math harness.

Node is available. Let me write a quick Lenia math harness to validate presets before baking them into the demo. I'll implement the classic Lenia update rule on a 160² grid (fast in JS) with R=13, and test several parameter sets, measuring final mass fraction and activity over time.

Kernel: offsets (dx,dy) with dist<=R; r = dist/R; ring i = min(B-1, floor(rB)); x = rB - i; K = beta[i] * exp(-((x-0.5)^2)/(2*w^2)), w=0.15; normalize sum to 1.

Update: U = conv(A, K); G = 2exp(-((U-mu)^2)/(2sigma^2)) - 1; A += G/T; clip [0,1].

Seed: random disk center radius 0.35W with values random in [0,1]? Standard seeding: fill a central square (20x20) with random [0,1] noise, or disk. For Orbium: a random 20x20 block condenses into orbium. Also test "disk seed": disk radius ~R0.9 at 0.6.

Metrics: mass fraction after 1500 steps, activity = mean|Δ| over last 100 steps, crude blob count maybe skip. Choose presets that: mass between 2% and 60%, activity > 0.0005 (still alive/dynamic), not exploding.

Candidate parameter sets (mu, sigma, beta, R, T): A: 0.15, 0.017, [1], 13, 10 (Orbium — from Chan's paper) B: 0.156, 0.0118, [1], 13, 10 C: 0.14, 0.0142, [1, 0.557], 13, 10 (Geminium-ish: two-ring kernel produces "smiley"/geminium in some sources) D: 0.19, 0.0198, [1], 13, 10 E: 0.26, 0.025, [1], 13, 10 (higher mu → denser patterns) F: 0.115, 0.0125, [1], 13, 10 G: 0.3, 0.039, [1, 0.6, 0.2], 13, 10 H: 0.2, 0.03, [1, 1], 13, 10

Let me just run the harness and see which survive. Use grid 128 for speed with R=13; convolution O(N·R²) fine in JS for a few hundred steps. Use Float32Array, direct loops. 128² = 16384 px × ~530 taps = 8.7M ops/step → ~1500 steps = 13B ops... too slow in JS (maybe 30-60s per preset). Reduce: grid 96, steps 600, taps 530 → 96²=9216×530=4.9M/step ×600 = 2.9B — still slowish but OK (~10-20s each in optimized JS with typed arrays; JS does ~100-300M simple ops/sec in loops with arrays... maybe 30-100s). Let me optimize: precompute tap list (offset index, weight) once; inner loop over taps with flat indices; avoid modulo via toroidal precomputed neighbor? Toroidal wrap complicates flat indexing; do wrapping with precomputed row offsets: for each tap, store dx, dy, w and compute wrapped index per pixel — costly. Alternative: pad array? Simplest: per-pixel compute x+dx with conditional wrap.

Alternative: use smaller R (e.g., scale down: R=8, grid 96) for the harness only to rank presets — but Lenia behavior depends on R relative to kernel... scaling R while keeping ratios works approximately ( continuum limit). The paper shows creatures persist across R (they get bigger with R). For preset validation, exact R=13 matters less than survival; but mu/sigma sensitivity is real. Risk: harness says "survives" at R=8 but dies at 13. Compromise: harness at R=13, grid 128, steps 800, but optimize inner loop well. ~4.3B ops → in Node with typed arrays maybe 20-40s per preset. 8 presets ≈ 3-5 min. Acceptable but let me trim to the most promising 6 presets and 600 steps, and parallelize by running sequentially with progress. Or reduce taps via cutoff threshold 1e-3 → ~300 taps.

Actually let me just do it and print progress; also early-exit if mass ~0 (extinct) or ~full.

Let me write the harness now.

Interesting results:

• A (Orbium: μ=0.15, σ=0.017): survives — good. Mass 20%, low activity 0.00035 (fairly static — orbium moves slowly, that's expected).
• C (μ=0.14, σ=0.0142, β=[1,0.557]): survives with higher activity (0.00117) — interesting, more dynamic.
• F (μ=0.115, σ=0.0125): survives.
• H (μ=0.2, σ=0.03, β=[1,1]): survives, mass 26%.
• G (3-ring): alive-ish but low activity — static crystal patterns. Could be nice visually ("crystal garden").

Concerning failures:

• J big-R extinct: R=18 with same μ/σ died. Because kernel with bigger R at same ring shape → potential distribution shifts. So in the demo, when the user changes R, μ/σ might need adjusting — that's fine, it's an explorable lab; presets set all params together. But it means my "R slider" may easily kill the soup — that's part of the fun, plus presets restore life.
• K disk seed extinct at step 61 — the disk seed at 0.65 density, radius 0.9R → died. Hmm, that's a problem for the "spawn creature" brush. A solid disk of 0.65 has U at center = 0.65 (kernel normalized, fully inside) → G(0.65) very negative → dies. The classic orbium arises from noise, not solid disk. A noise disk would work better: seed disk with random noise instead of solid. Let me test noise disk. Also smaller density speckle.

Also activity for A is low (0.00035) — orbium moves slowly, that's fine, but visually I want motion. The demo renders |Δ| as shimmer; with act that low it'll look static-ish. Option: use slightly more dynamic presets, or default speed higher (T=6 → act 0.00092, more lively). "I orbium fast" (T=6) survives with ~3x activity. Good — default preset can use T=8 maybe. Let me also test noise-disk spawn and a couple more variants for liveliness: μ=0.15 σ=0.02? Let me run a second harness round:

• K2: noise disk (disk radius 1.2R, fill with random*0.9) under A params.
• L: μ=0.15, σ=0.02, β=[1], T=8
• M: μ=0.16, σ=0.02, [1], T=8
• N: μ=0.135, σ=0.015, [1, 0.4], T=8
• O: μ=0.2, σ=0.03, [1,1], T=6 (H but faster)
• P: μ=0.3, σ=0.039, [1, 0.6, 0.2], T=6
• Also measure "activity over time" to see if A eventually settles to static (act→0) or keeps wiggling. Print act at 300/600/900.

Also I realize extinction detection at step>60 may be too late to catch fast deaths — fine.

Also want to check: does noise seed at W=384 (demo res) behave same? Approx yes.

One more consideration — in the demo, seeding uses noise blobs; the brush spawns "creature eggs": small noise disks. Test that.

Results:

• N (μ=0.135, σ=0.015, β=[1,0.4], T=8): sustained activity 0.00117 at step 900 — very lively.
• Q (orbium T=8): activity decays to 0.0005 — orbium settles into slow glide, expected.
• M (μ=0.16 σ=0.02): sustained 0.00034, ok.

Problem: spawn eggs all go extinct! A noise disk alone dies. Why? Classic Lenia seeding: noise square of side ~20 in a 256 world... hmm, but my noise square (W0.18 = 23 half → 46x46 block) survives. The noise disk r=14.3 (R1.1) dies. Wait — maybe the disk edge kills it: with noise fill rand*0.9, mean density 0.45, but the disk is small; boundary cells have U ≈ 0.45/2 (half neighborhood empty) ≈ 0.22... above mu=0.15 → G>0 → edge grows? Then mass spreads... but it died at step 61.

Hmm wait, actually extinction check triggers at s>60 with mass<0.0015 — "extinct@61" means it died fast, before step 61. Interesting — noise square 46x46 survives, noise disk r14 dies. The difference: total mass! Disk π14²0.45 ≈ 277 cells. Square 46²=2116 cells*0.5=1058. Maybe small seeds just collapse: in Lenia, a seed must reach critical mass to form a stable soliton; isolated tiny blobs dissolve because U inside ≈ 0.45 (if blob smaller than kernel, U < 0.45·(blobArea/kernelArea)) → below μ → G<0 → decays. Disk r=14 vs kernel R=13: U at center ≈ 0.45 × (overlap) ≈ maybe 0.4 → G(0.4) with σ=0.017: way negative (exp(-((0.25)/0.017)²/2) ≈ 0) → -1 → dies. Hmm right: G(u) for u much bigger than mu is ~-1! Lenia growth is a narrow Gaussian around μ=0.15. So any region with U ≳ 0.3 decays. Noise square survives because it quickly self-organizes: high-density spots decay, low grow, reaching U≈μ balance — but only if big enough to have interior dynamics before dissolving.

So the "spawn creature" egg needs to be closer to a real orbium solution. Options:

1. Precompute an actual Orbium creature and ship it as a seed pattern! I can extract a steady-state orbium from the harness: run noise seed 2000 steps, find a blob, crop a window around it, save as JSON base64 or a compact array, embed in the demo. That guarantees authentic creatures. Excellent approach — "specimen" stamps.
2. Paint with low density brush (0.1-0.2) — blobs with A≈0.2: U inside ≈ 0.2 near μ → G ≈ +0.7-ish → grows. So brush painting at low density works for freehand drawing.

Let me do both: brush default density moderate (0.25 with soft gaussian profile) works for painting living strokes; plus 2-3 "specimen stamps" extracted from the sim.

Extract specimens: run orbium params from noise, after 1500 steps, threshold to find a connected blob, crop 2R+pad window, normalize, save. Let me write harness3 that:

1. Runs A params (T can be 10; dynamics same) 1500 steps on W=128.
2. Finds blobs via connected components on A>0.1.
3. Crops around the largest blob: window (2.6R)² ≈ 34², centered on centroid.
4. Prints the crop as base64 of Float32 or as rounded 2-decimal array (34² = 1156 values × ~4 chars ≈ 5KB — fine to embed, or use base64 of Uint8 quantized — better: quantize to 0-255, base64 → 1542 chars). Use base64 Uint8.

Also extract a specimen from N preset (2-ring) — different creature family.

Also check: stamp test — place the cropped orbium in an empty world, run 500 steps, verify it survives and maybe glides. That validates the stamp mechanic.

Let me also reconsider the egg: speckle with 40% at 0.35-0.65 died. What about very low density noise disk (mean ~0.12)? U inside ≈ 0.12 → G(0.12) with μ=0.15 σ=0.017: exp(-(0.03/0.017)²/2)=exp(-1.56)=0.21 → G=-0.58 → decays slowly. Hmm. U≈μ needed. Density 0.15 disk: U≈0.15 → G=+1 → grows → as it grows density rises... self-limits into soliton? Possibly forms orbium! Test: solid disk at 0.15-0.2 density. Actually that's how "paint" works — soft brush at ~0.2 leaves living strokes. Test disk density 0.18.

Let me write harness3 for specimens + soft-disk test.

Great progress:

1. Orbium specimen: extracted (44×44, 2584 chars), stamp test → alive, mass grew from 0.0225 to 0.2023 (it replicated into a thriving world — typical orbium behavior).
2. Geminium specimen: extracted (26×26, 904 chars), alive.
3. Soft disk seeding failed at all densities (0.15-0.25 all died). Hmm. So freehand brush painting with soft gaussian strokes under orbium params → dies?! That's a problem for the "paint life" interaction.

Wait — why did painting die but noise square survive? The noise square is 46x46 = much bigger. Size matters: the painted disk r=13 area ~530 px vs noise square 2116 px. Small painted regions dissolve before self-organizing. The stamp works because it IS an organized solution.

So for brush painting to "come alive", either:

• Paint larger regions (big brush) — even then, uniform soft disk died regardless of density... The painted disk was r0=13 with falloff — effectively smaller. Let me test bigger painted disks (r=25-35) at density 0.2-0.4 with noise mixed in. Actually the noise square = full random [0,1] over 46². Key: random noise has both high and low spots creating U variance ≈ balanced around μ? Whereas smooth paint has U≈const = dens → if dens=0.2, U=0.2, G(0.2)=2exp(-(0.05/0.017)²/2)-1 = 2exp(-4.3)-1 = -0.97 → dies. Ahh that's it: ANY uniform region has U=uniform density, and unless density ≈ μ±σ (i.e., 0.133..0.167), it decays or saturates. Painting at density ~0.15 uniformly would grow slowly... but density 0.15 test died too! Because falloff made effective density lower at edges... center U=0.15·(0.8..1.2 rand)... G(0.15)=+1 → grows toward 1 → U rises above μ → decays... oscillates... The disk may collapse from edges. Painting random noise (not smooth) mimics the seed square — my earlier brush plan used "rand*0.9" noise disk r=14 which died (too small), but r=23 noise square works.

So: brush should paint NOISE, not smooth density! A "spore brush": splatter random-density pixels within radius — like scattering spores. Small splatters die, but decent-size splatters (r ≥ ~18) self-organize. Let me verify: noise disk r=20, 25 under orbium params. Also for ergonomics: brush size default ~24 (relative to 384 world = scales: r_world = 24/128*384 = 72px in world cells). Hmm wait — my harness W=128, demo W=384 with R=13. Scale matters: in the demo R=13 on 384 grid means creatures are the same absolute size (26px) but the dish is relatively bigger (fits 200 creatures). Brush radius in cells is what matters: need r≥18 cells for spore splatter to survive.

Also the speckle test (40% density 0.35-0.65, r=14) died. So test noise disk r=20/26.

Additional idea for making painting satisfying: the "stir" tool that adds turbulence — skip.

Let me also grab a third specimen: from preset C (μ=0.14, σ=0.0142, β=[1,0.557]) which had high activity. And maybe the 3-ring "crystal" pattern looks cool as a stamp? Crystal stamps would tile into lattices — fun. Let me extract from G params (μ=0.3, σ=0.039, β=[1,0.6,0.2]) — it was static-ish (act 0.00008, crystallized). A crystal seed stamp could grow lattices. Nice variety.

Round 4 tests:

1. noise disk r=18, 22, 26 (orbium params) — survival.
2. Extract stamps: gemC (from C params), crystal (from G params).
3. Also stamp-test those.

Then build the demo. Time budget is fine.

I'm at 54% of max time already! The harness runs took a while. I need to be efficient now. Let me run harness4 quickly, then write the demo. Actually, I should be careful — the checkpoints indicate time usage. Let me run harness 4 (should take ~2 min) and then move fast to write the demo file.

Actually, to save time: I could skip further validation and just use the orbium + geminium stamps I already have, default spore brush radius 26 (safe bet that bigger noise disks survive — noise square 46 wide survived; r=26 disk has area 2123 ≈ same as 46² square, so should survive). But I'd like the C/G stamps for variety... Let me run harness4 in the background while I start writing the demo HTML. Actually simpler: run it (2 min), then write.

Results:

• Spore brush: r=30 survives (mass 0.20), r=20 marginal (0.005), r=24 died (unlucky seed), r=16 died. So default brush radius ~30 cells (of 384-world → scaled), with note that small splatters may not take hold. Brush min size slider start ~14.
• Vortex stamp (32×32, 1368 chars): alive (0.0113→0.1782).
• Crystal stamp (44×44): alive (0.0437→0.1604).

Now I have 4 specimens in /tmp/stamp-*.json: orbium (44), geminium (26), vortex (32), crystal (44). Total ~6.5KB base64 — fine to embed.

Demo parameters plan:

• World: 384×384 RGBA16F, R=13 default (slider 6..20), toroidal.
• Presets (name, mu, sigma, beta, T):
  1. "Orbium Classic" — 0.15, 0.017, [1], T=8, stamp: orbium
  2. "Geminium Drift" — 0.135, 0.015, [1, 0.4], T=8, stamp: geminium
  3. "Vortex Bloom" — 0.14, 0.0142, [1, 0.557], T=8, stamp: vortex
  4. "Crystal Garden" — 0.3, 0.039, [1, 0.6, 0.2], T=10, stamp: crystal
• Preset action: set params, clear world, spawn 3 stamps + some spore splatter.

Wait — crystal preset had mass 0.37 and low activity — mostly static lattice. Still visually cool (pattern growth), keep.

Geminium (0.135/0.015/[1,0.4]) sustained activity 0.00117 — lively.

Also "Primordial soup" random seeding button: fills central 25% square region scaled... For 384 world, seed several random noise disks r=30 at random positions (or one big central square of noise ~140²). I'll do: 5-7 noise disks r=26-40 scattered + occasionally a stamp.

Now, demo architecture (single file, three@0.170.0, import map):

GPGPU sim:

• simRT ping-pong: THREE.WebGLRenderTarget(W, W, { type: HalfFloatType, format: RGBAFormat, minFilter: Nearest, magFilter: Nearest, depthBuffer: false, wrapS/T: Repeat }) — Repeat for toroidal sampling! With REPEAT wrap and sampling at (uv + offset/res), toroidal convolution is automatic.
• Channel R = state A. Channel G = smoothed activity (for glow rendering): in update shader, g' = mix(g, |A'-A|*k, 0.1).
• Update shader (single pass): read A, convolve via taps texture, growth, advection (optional flow field: uv2 = uv - vel*dtFlow; sample A at uv2 — semi-Lagrangian; vel from static curl-noise texture RG). Write newA, newG.
• Taps texture: DataTexture RGBA Float32, size 2048×1 (or 64×32?). 1D: width 2048 height 1. Each texel: (dx/R? no, dx, dy, weight, 0). Shader: loop i in 0..MAX_TAPS-1: fetch texel, if (t.z == 0.0 && i>=N) break — simpler: if (i >= uTapCount) break; dynamic break on uniform is fine in GLSL ES 3.0. MAX_TAPS = 2048. R max 20 → max taps π·20²·0.9 ≈ 1130 < 2048 OK.
• Paint shader: adds gaussian splat / noise splat / stamp into state (render into sim RT with blending OFF, shader reads current state and adds brush contribution in radius). Brush applied as a separate small pass each frame while pointer down: uniforms brushUV, radius, strength, mode, symmetry params, time; inside shader compute distance with kaleidoscope folding, add noise*mask etc.
• Seed/init shader: fills noise region(s) or clears; or CPU fills a Float32Array and uploads via a DataTexture copy into RT (simpler: render a fullscreen "seed" shader with random hash noise in masked regions defined by uniforms array? Simplest: CPU-generate RGBA data (Float16? writing half floats from JS needs conversion). Alternative: use a "seed" shader pass with hash-based noise: for each pixel inside any of up to 8 uniform disks → hash noise value, else keep/clear. Do that: uniforms vec4 uSeeds[8] (xy=uv center, z=radius_uv, w=density scale). Shader: v = inside ? hash(px)*w : 0. Plus optional stamp stamping via shader with stamp texture... Stamps: upload stamp as DataTexture (LuminanceFormat? use R float). In seed shader, up to 2 stamp rects... getting complex.

Simpler: do ALL state writes through the generic paint pass (brush shader), including stamps: stamp mode samples stamp texture mapped onto brush rect. Seed soup = multiple noise splats. So paint shader modes:

• mode 0: smooth add (gaussian blob * strength) [nurture brush — though smooth blobs die; still useful as "food"... hmm. Actually smooth low-density paint dies. Repurpose: "spores" only]

Let me simplify brush modes:

1. Spores (noise splat): value = hash noise within soft disk. Living if big enough.
2. Stamp (creature): samples specimen texture at brush rect; brush size controls stamp scale.
3. Erase: multiply by (1 - gaussian).
4. Stir: displacement — advect state locally by rotational swirl? Implement as: state' = state(uv - swirlOffset(uv)). Could be fun ("vortex mixer"). Small extra shader complexity. Include if cheap — same paint pass, mode 3: result = mix(A(uv), A(uv + tangentfalloffstrength), falloff). Yes cheap.

Kaleidoscope symmetry for spores/erase/stir: fold brush position into N replicas — implement by rotating the offset vector: for k in 0..K-1: sample/add at uv + R(2πk/K)·off. For mirror: include reflection. Implement in shader with loop up to 8. For stamp mode disable symmetry (stamps at cursor only).

Flow field: static curl-ish vector field texture (CPU-generated 64², smooth random vectors via value noise, normalized), uniform flow strength (default 0.15, slider 0..1). In update shader: advect: A_prev = texture(A, uv - velflowdtAdvect). dtAdvect ~ 0.3 cells? Make strength in cells/step small (~0.15 cells) to avoid instability.

Display shader (fullscreen, but rendered as a 3D-ish dish):

• Compute screen uv; dish center/scale; p = (uv - c) * aspect correction, r = length(p).
• Inside r < R_DISH: sample state at dish uv = p/(2R_DISH)+0.5 → value v, activity g.
• Palette: IQ cosine palette tuned bioluminescent: col = a + bcos(6.2831(c*t+d)) with a=(0.05,0.22,0.32), b=(0.45,0.35,0.35), c=(1,1,1), d=(0.0,0.25,0.55)? I'll tune by eye-ish reasoning: want dark teal at v~0.1, cyan at 0.4, white at 0.8, magenta fringe at ~0.25. Maybe two-stage: base = palette(v); fringe = magenta * band(v around 0.3); core = white * smoothstep(0.75,0.95,v).
• Relief: normal from gradient (4 taps), light dir from rim light angle, diffuse + specular (Blinn), fresnel edge glow.
• Activity glow: col += cyan * g * boost.
• Dish glass: rim ring shading (r in [R-δ, R]): metallic ring with angular highlight (rim light dir uniform, animated slight), inner glass streak: elongated specular blob fixed angle. Outside: bench — dark radial gradient + very subtle animated dust (hash noise drifting) + vignette.
• Parallax tilt: pointer offset shifts dish center & highlight angles slightly.

Post: EffectComposer: RenderPass(fullscreen shader scene) → UnrealBloomPass(strength 0.65, radius 0.55, threshold 0.3) → ShaderPass(grade: vignette+grain+chromatic aberration) → OutputPass.

Hmm — simpler to render display shader as fullscreen quad in its own scene w/ ortho camera.

HUD/UI (DOM, matching house style):

• Top-left panel: title "PRIMORDIAL", subtitle "lenia · continuous life laboratory"; stats: generation, mass %, activity, fps, sim res.
• Top-right panel: controls — presets row (4 buttons), sliders (μ, σ, R, T/tempo, flow, brush), kernel rings β sliders ×3 with kernel+growth preview canvases, brush mode buttons, symmetry selector, buttons: Seed Soup, Clear, Pause, Snapshot, Audio. That's a lot — organize in collapsible sections. Keep it tidy: sections "Culture", "Physics" (sliders), "Brush", "Lab".
• Bottom-left: event log (last 3 entries, fading).
• Bottom-right: hint line + help toggle overlay with math explanation.

Given time constraints (54% used at checkpoint), I must write efficiently. The file will be large (~1200-1500 lines). Let me be disciplined and write it in one go, then syntax-check by extracting the module script and running node --check, plus a quick logic harness for the GPGPU tap-list code (CPU side shared logic).

Stamps: read the 4 JSON files and embed. Let me get their contents to paste into the demo.

Stamps are ready. Now write the demo. I'll create the directory and write the full index.html. I need to embed the stamp data — rather than pasting 6.5KB inline in the write (fine), I'll have the build read the JSON files... but the demo must be self-contained. I'll write the HTML with placeholder tokens like %%STAMP_ORBIUM%% and then run a small Node script to inject the base64 strings from /tmp/stamp-*.json. That keeps the big write clean.

Now write the demo. Key detail decisions:

Sim resolution: default 384. Tiers: high 448? Keep {384, 320, 256}. R slider 8..20 (default 13). MAX taps: R=20 → annulus ~π4000.85≈1068 taps; plus multi-ring fills more area... β rings with bump each → union coverage bigger. Worst case β=[1,1,1]: rings cover x∈[0,1] fully except bump valleys → nearly full disk πR²=1257. MAX_TAPS=1536 to be safe. Check: 1536 texels DataTexture.

Update shader (GLSL ES 3.0 via three RawShaderMaterial? three ShaderMaterial defaults to GLSL1 syntax but compiles to ES3 with WebGL2... three handles texture() etc. Use THREE.ShaderMaterial with glslVersion: THREE.GLSL3 for cleanliness, or just write GLSL1-style with texture2D — three converts. For ping-pong GPGPU the standard three pattern: shader with varying vec2 vUv, texture2D — works fine in WebGL2. I'll use ShaderMaterial default (GLSL1 style) to avoid pitfalls, with dynamic loop: GLSL ES 1.0 requires constant loop indices!! In WebGL2 contexts, three compiles shaders as GLSL ES 3.00 automatically when...? Actually three.js with WebGL2 still compiles GLSL1-style shaders by prepending #version 300 es and defines texture2D→texture etc. Yes — three always uses #version 300 es in WebGL2 and maps varying/attribute/texture2D via defines. So for (int i=0;i<MAX;i++){ if(i>=count) break; ...} — the loop bound is constant MAX, break is dynamic — legal in ES 3.00. Good, write GLSL1-style (texture2D, varying) and three handles it.

Convolution: taps stored normalized (dx, dy in texel units, weight). uv offset = vec2(dx, dy)/res. With RepeatWrapping → toroidal.

Flow advection: vel texture 64×64 RGBA16F DataTexture with smooth random field: value-noise vectors. In shader: vec2 vel = texture2D(uFlow, uv3.0).xy2.-1.; then A at uv - veluFlowAmt(1.0/res)*... make uFlowAmt in cells: offset = vel * uFlowAmt / res. Sample with Linear filter for smooth advection — state RT needs LinearFilter then. RGBA16F linear filtering is core in WebGL2? Half-float linear filtering: WebGL2 supports float16 filtering natively? Hmm — actually in WebGL2, texture filtering for HALF_FLOAT is supported (16F is filterable per spec: "RGBA16F" is color-renderable only with EXT_color_buffer_float; filterable: yes, 16F formats are filterable in core WebGL2). Rendering TO RGBA16F needs EXT_color_buffer_float (widely available ~99%). I'll check for it and fall back... if missing, show unsupported message (acceptable; nearly universal on desktop).

For convolution sampling nearest vs linear: linear fine (slight smoothing blur is harmless, actually adds smoothness).

Activity channel: g' = mix(g, min(1,|dn|*40), 0.08). Renders as shimmer.

Paint pass: fullscreen shader into sim RT (no blending):

Symmetry: for replica k: off_k = rot(2πk/K + maybe mirror) * (uv - c). Compute mask = max over replicas of smoothstep. For SPORES with kaleidoscope, each replica should have SAME noise pattern? Different is fine (looks organic); use hash of folded coordinate for symmetric pattern: hash the folded position → symmetric spores! Nice: fold position to fundamental domain, hash that → all replicas get identical noise.

Seed soup: call paint SPORES with big radius at random positions ×6 over a few frames, or a dedicated seed shader pass with 6 uniform disks. I'll just invoke the paint pass 6 times at random centers (it's a fullscreen pass but cheap) — fine.

Stamp spawn: paint STAMP at cursor with stamp texture; scale: stamp world size = S cells → radius = S/2 cells; map brush radius slider to allow scaling 0.5×–2×.

Stats readback: to compute mass/activity without stalls, render a downsample pass: mip generation! simRT with generateMipmaps? For float RT, mipmap generation of 16F textures... supported? generateMipmap on RGBA16F — should work in WebGL2 (filterable). Then readPixels of a tiny FBO? readPixels from float framebuffer needs RGBA/FLOAT read — WebGL2 readPixels from float renderbuffer: allowed type combos... messy. Alternative: compute mass on GPU into a 1×1 RT via custom reduction shader sampling 64×64 grid (one pass, 4096 taps in one fragment) → readPixels RGBA FLOAT from RGBA16F? readPixels from 16F framebuffer: implementation color-read format may be RGBA/FLOAT or RGBA_INTEGER... For EXT_color_buffer_float, required read format is RGBA/FLOAT typically supported. Risky across drivers but generally OK on desktop.

Simpler robust: readPixels from a RGBA8 UNSIGNED_BYTE stats RT (always supported): reduction shader writes mass/activity encoded in 0..1 bytes (mass/1, activity scaled). 1×1 RGBA8 RT, fragment loops 96×96 samples of state texture (linear), accumulates. Read 4 bytes each ~250ms.

Resize/quality: measure fps EMA; if < 45 for a while → lower tier (res or substeps). Res change: allocate new RTs, resample old state via copy shader with linear sampling (draw fullscreen: out = texture2D(old, uv)), continue. Generation counter preserved.

Post chain: RenderPass + UnrealBloomPass + grade pass + OutputPass. three r170 addons paths: 'three/addons/postprocessing/EffectComposer.js', RenderPass, UnrealBloomPass, ShaderPass, OutputPass.

Audio: WebAudio drone: 2 osc (sine 55Hz, 82.5Hz) + lowpass + gain LFO; shimmer = noise buffer → bandpass (freq mapped from activity 400→2400) → gain from activity. Start on toggle (user gesture). Keep code ~40 lines.

Kernel/growth preview canvases: 2D canvas, draw kernel radial profile & growth curve, update on param change. ~40 lines.

Extinction/overgrowth watchdog: using stats; if generation > 100 and mass < 0.15% → log "culture collapsed — press R to reseed"; if mass > 55% → "overgrowth!". Toast once per event (cooldown).

Keyboard: Space pause; R seed soup; C clear; 1-4 presets; B cycle brush; X symmetry cycle; [ ] brush size; F flow toggle?; S snapshot; M audio; H help.

Mouse/touch: pointer drag paints (mode-dependent). Right-drag or two-finger → erase quickly? Keep: left paint, shift+drag erase. Pointer position → parallax tilt.

Snapshot: render composer, then canvas.toBlob → download link. Need preserveDrawingBuffer or render synchronously before toBlob — call renderer render then toDataURL in same frame: do composer.render(); const url = renderer.domElement.toDataURL() — works if no preserveDrawingBuffer as long as same task. Good.

Now — writing the file. It's big; I'll write it in 3-4 chunks using write mode then append via shell cat >>? The read_write tool write mode writes full content (or range). Simplest: build locally with a heredoc via execute_shell_command? Quoting nightmare. Better: use read_write_file_in_shell_environment write with full content — but it's ~1300 lines; the tool can handle it (previous demos similar size). I'll write in 2 parts: first write part 1, then use execute_shell_command with cat >> file <<'EOF' for part 2? Still quoting issues with $ etc. Better: two write operations: write full file content in one call. Let me just carefully compose the entire file now.

Stamp injection: placeholders %%STAMP_ORBIUM%%, %%STAMP_GEMINIUM%%, %%STAMP_VORTEX%%, %%STAMP_CRYSTAL%% replaced by node script after writing.

Let me draft the shaders carefully.

--- Update (sim) shader ---

uniforms: uState (prev), uTaps, uTapCount, uRes, uMu, uSigma, uDt (1/T), uFlow, uFlowTex, uTime? not needed.

(B channel stores potential U — useful for debug view! Nice: debug toggle shows potential field.)

Wait: texture2D on uTaps DataTexture 1536×1 float — need float texture sampling (no filtering, nearest) — fine.

Half float precision for taps weights: use FloatType DataTexture (32F) for taps — sampling float32 texture is core (filtering not needed, nearest). OK.

--- Paint shader ---

uniforms: uState, uRes, uCenter (vec2 uv), uRadius (uv units), uMode (int), uSym (int count), uMirror (bool), uStampTex, uStampScale?, uSeed (frame rand), uAspect? (dish is square in world uv; painting happens in world uv space directly — pointer maps screen→dish uv→world uv. radius in world cells → uv radius = cells/res).

Hmm wait — for symmetry the replicas should place copies at rotated positions, i.e., pixel vUv receives paint if ANY replica of the brush center covers it: equivalent to rotating d0 by -ang. What I did rotates d0 by +ang which is the same set. OK.

Mirror: incorporate by treating sym = sym2 with alternate reflection. I'll implement uMirror flag: inner double loop k<2sym, with flip = k>=sym → dd.x = -dd.x before rotate. Let me restructure: total replicas = uSym*(uMirror?2:1). Loop k<16 max, break when k>=total. flip = uMirror==1 && k>=uSym.

Modes: 0 spores: na = mix(a, hash(floor(vUvuRes) + uSeed), mask0.9); — hash per-cell per-frame → fresh noise. Use folded coordinate for symmetry-consistent noise: hash(floor((folded)*uRes)) where folded = the dd that gave max mask... simpler: hash per replica differs → non-symmetric splat; acceptable? For kaleidoscope beauty, symmetric pattern much better. Compute noise from the canonical folded vector: fold angle = mod(atan(d0.y,d0.x), 2π/sym), radius kept → canonical position → hash. That gives perfect symmetry. Implement:

And mask from folded: mask = smoothstep(uRadius, uRadius*0.55, length(folded)) — same as length(d0) since rotation preserves length! Of course — radial brush: mask depends only on |d0|, symmetric automatically. Only NOISE pattern needs folding. And stamps shouldn't be symmetric (sym applies only to spores/erase/stir). Erase: a *= 1-mask. Stir:

Stir amount fixed ~6 cells. Blend: na = mix(a, pulled, mask*0.8).

Stamp: no symmetry; suv from d0; stampV = texture(uStamp, suv).r * smoothstep edge mask (edge of stamp rect fade). na = max(a, stampV).

mode 3 = smooth "nutrient" blob? skip.

Paint pass runs every frame while pointer active (and also used for seeding at init with big radius spores at several centers, and preset stamping).

--- Display shader ---

Full-screen quad, uniforms: uState (RGBA16F linear), uRes, uDish (center vec2, radius px?), uTime, uTilt (vec2 parallax), uViewMode (0 culture, 1 potential), uAspect.

Compute in pixels: fragCoord via gl_FragCoord. Let me write with vUv and uResolution.

Inside dish (r < dishR): sample state at suv (clamp edge: if outside [0,1] treat as 0 — but dish shows whole toroidal world, suv always inside when r<dishR).

Render culture:

palette(v):

Hmm, I'll hand-tune: want near-black at v=0, teal→cyan→warm white. Cosine palette with a=(0.02,0.12,0.20), b=(0.45,0.42,0.40), c=(1.0,1.0,1.0), d=(0.0,0.10,0.20)? At t=0: a+bcos(2π d) = (0.02+0.45, 0.12+0.420.81, 0.20+0.40*0.31)=(0.47,0.46,0.32) too bright at 0. Multiply palette by smoothstep(0.02,0.25,v) to darken substrate. Then add core glow: mix toward white at high v. I'll iterate mentally:

• substrate (v≈0): #05080f-ish
• low v (0.15): deep blue-teal (0.0,0.25,0.35)
• mid (0.4): cyan (0.1,0.8,0.9)
• high (0.7): bright aqua-white (0.7,1.0,0.95)
• fringe near v≈0.28 band: magenta tint Use: base = mix of 3 color stops via smoothsteps:

Good enough; bloom will sell it.

Dish exterior: bench = dark gradient + dust motes:

Keep subtle: bg = mix(#0b0e18, #05070c, vign) + faint radial lab glow behind dish.

Dish rim: annulus r∈[dishR, dishR+rimW]: metallic ring: color mix silver-blue, angular highlight: pow(max(cos(atan(p.y,p.x)-lightAng),0),8). Inner wall shadow near r≈dishR inside: darken culture by smoothstep. Glass: streak highlight: elongated gaussian at fixed offset angle inside dish: exp(-((rot pos)·...)²) * 0.05.

View mode 1 (potential field B channel): grayscale-blue ramp of st.b — debug.

--- Grade pass (final ShaderPass) --- vignette + film grain + slight chromatic aberration (sample tDiffuse 3× with tiny radial offsets). standard.

Now DOM/UI. Reuse house style: panels top-left (title+stats), right side control panel with sections; bottom log; help overlay.

Controls list:

• Presets: 4 buttons (Orbium Classic, Geminium Drift, Vortex Bloom, Crystal Garden).
• Sliders: μ (0.05–0.45, step 0.001), σ (0.005–0.06, step 0.0005), R (8–20 step 1), tempo T (2–20 step 0.5), flow (0–1 step 0.01), brush (10–60 cells step 1).
• Kernel rings β1 β2 β3 (0–1 step 0.05) + preview canvases (kernel radial, growth curve).
• Brush modes: Spores / Specimen / Erase / Stir (radio buttons), symmetry: buttons 1,2,3,4,6,8 + mirror toggle.
• Specimen selector: dropdown or cycling button showing name (orbium/geminium/vortex/crystal).
• Buttons: Seed Soup (R), Clear (C), Pause (Space), Snapshot (S), Sound (M), Help (H).

Stats: generation, mass %, activity, fps, res tier.

Log events with timestamps.

Watchdog toasts.

OK — also pointer→dish mapping: dish center at screen center (with tilt offset ±3%), radius = 0.46min(w,h)... Let me define in shader space: p=(vUv-0.5)vec2(aspect,1); dishR=0.46 → dish diameter 0.92 of min dimension. Pointer: same transform; if length(p)<dishR0.99 → world uv = p/(2dishR)+0.5 → paint. World cell radius brush = slider cells → uv radius = cells / uRes... wait world uv spans full world [0,1]² across dish diameter: brush uv radius = brushCells / res. Yes.

Parallax: uTilt = (pointerNDC) smoothed; shifts dish slightly & light. In shader p += tilt*0.02.

FPS auto-quality: every 2s, if fps<42 → tier down (substeps 2→1, then res 384→320→256); if fps>57 for 6s → tier up (max start config). Log tier changes.

Manual quality select too? Add small select: Auto/High/Med/Low mapping to (384,2),(320,2),(256,1)... Auto starts high. Keep Auto only? Add select — minor code. I'll include.

Sound engine: minimal generative:

• master gain 0.15
• drone: osc sine 55 + sine 55*1.5 detune 3c → lowpass 220 → gain slow LFO 0.05Hz depth
• shimmer: looped noise buffer 2s → bandpass freq = 300+activity4000 (smoothed) → gain = activity6 clamp 0.25
• painting: short filtered noise tick? skip. Toggle on/off, resume() on gesture.

Snapshot: composer.render() then toDataURL('image/png') → a.click.

Help overlay: absolutely positioned panel with math description & shortcuts; toggled.

Now — code size ~1200+ lines. Let me write it. I'll be careful with:

• three r170 OutputPass exists. UnrealBloomPass import path fine.
• RGBA16F render targets: type: THREE.HalfFloatType, format: RGBAFormat. Need EXT_color_buffer_float — check renderer.extensions.get('EXT_color_buffer_float'); if null → show fatal overlay message.
• LinearFilter on sim RTs (for advection sampling + display smoothing).
• Taps DataTexture: width 1536, height 1, format RGBAFormat, type FloatType, NearestFilter, needsUpdate.
• Stamp textures: DataTexture S×S, RedFormat? For broad support use RGBAFormat FloatType or just LuminanceFormat(deprecated in r170? LuminanceFormat removed? In r152+ LuminanceFormat still exists? Safer: RGBAFormat UnsignedByteType with value in R) — simple: RGBA8, data = v replicated. Nearest? Linear ok. Actually use RedFormat/UnsignedByteType: R8 texture — core WebGL2, three supports RedFormat. sampling .r fine. Use THREE.RedFormat, UnsignedByteType, LinearFilter.
• Ping-pong: two RTs, swap. Sim material uniform uState set to read RT texture.
• Fullscreen quad helper: own class with Scene+OrthographicCamera(-1..1) + PlaneGeometry(2,2).

One subtlety: sim update shader sampling uState with LinearFilter at auv (advection) and taps — fine.

Another: when R or β changes → rebuild taps CPU-side → update DataTexture + uTapCount. When res changes → rebuild RTs + taps unchanged (taps in cells). Also brush uv radius changes with res (cells/res) — compute at paint time.

Seeding function: soup(): clear + 6 spore splats random center radius 30-55 cells… at 384 res those are big disks; fine. Plus optionally 2 stamps. Clear: paint pass mode ERASE full? simpler: renderer.setRenderTarget(rt); renderer.setClearColor(black,1); clear(). Do for both RTs.

Stamp spawn at cursor on pointerdown when brush==specimen: single paint pass mode STAMP.

Paint while dragging: spores continuous each frame while down (new noise each frame — moving brush splatters). Erase/stir continuous.

Generation counter: += substeps each frame.

Activity stat: from stats RT B? stats shader computes mass (R) & mean |Δ|≈ mean G channel? G is smoothed act*60 clamped — activity ≈ mean(G)/60. Encode: stats pixel = vec4(mass, actg, maxV?, 1). Byte precision 1/255 fine.

Stats pass: 1×1 RGBA8 target, material samples uState 64×64 grid: avg R and G. readRenderTargetPixels 4 bytes every 20 frames → mass=bytes[0]/255, actg=bytes[1]/255.

Watchdog: if gen>300 && mass<0.0015 → "☠ culture collapsed" (cooldown 8s, auto once). mass>0.5 → "overgrowth".

Also creature census? skip.

Right — also initial state on load: preset Orbium Classic + soup seed + 3 orbium stamps → instant life.

Edge case: painting outside dish → ignore (pointer handler checks).

Mobile: touch paints; panels scrollable; min touch sizes; canvas touch-action none.

Now write the file. Also meta description. Title: "Primordial — Lenia Life Laboratory". Folder: 047-primordial. Card title "Primordial". Description for index: concise.

Let me now write the whole thing. I'll aim for clean, commented code. This will be a long write — do it in one read_write call.

Now write the full index.html. This is the big one. Let me compose it carefully.

Structure:

1. HTML head, CSS (house style, teal/cyan palette this time).
2. DOM: hud, stats, controls panel, log, help overlay, toast.
3. Import map.
4. Module script:
   • Constants, stamps (base64 placeholders), presets
   • Renderer setup, float ext check
   • RTs, taps, flow field, stamp textures
   • Shaders: sim, paint, stats, display, grade
   • Fullscreen quad helper
   • Composer with bloom + grade + output
   • UI wiring
   • Pointer handling
   • Audio
   • Main loop with fps auto-quality
   • Watchdog, stats readback
   • Snapshot, keyboard

Let me be extra careful about GLSL and three API details:

• UnrealBloomPass constructor: new UnrealBloomPass(new THREE.Vector2(w,h), strength, radius, threshold).
• OutputPass: new OutputPass().
• EffectComposer sizes on resize: composer.setSize.
• ShaderPass with custom grade shader object {uniforms, vertexShader, fragmentShader}.
• RenderPass(scene, camera).

Display scene: ortho camera + fullscreen quad with display material. RenderPass renders that scene.

Grade pass: operates on composited buffer; needs tDiffuse; plus uTime, uRes for grain/vignette.

The composer's final output to screen: with OutputPass at end (r170 handles sRGB + tone mapping). Set renderer.toneMapping = THREE.NoToneMapping? With OutputPass, tone mapping applied there using renderer settings. Keep default ACESFilmic? ACES will desaturate cyans a bit but looks filmic. Let me use ACESFilmicToneMapping with exposure 1.1. Hmm — bloom + ACES looks good usually. Fine.

• renderer = new THREE.WebGLRenderer({antialias: false, powerPreference:'high-performance'}) — composer uses render targets anyway.

Sim shaders need highp float. DataTexture for taps: new THREE.DataTexture(data, 1536, 1, THREE.RGBAFormat, THREE.FloatType); minFilter/magFilter Nearest; needsUpdate = true.

Note: FloatType texture sampling without filtering is core WebGL2. OK.

Sim material:

PlaneGeometry(2,2) with default camera — the vertex shader ignores camera (gl_Position direct). With ortho cam it'd be fine either way; using direct clip-space avoids camera entirely. But RenderPass needs a camera for the display scene — provide ortho cam; display vertex shader can also output position directly. OK use direct clip-space everywhere; RenderPass still requires a camera object (any).

Taps build (CPU):

R max 20 → π*400 = 1257 < 1536 even fully dense. OK no downsample needed. β slider 3 rings; ring count B = 3 always but β can be 0 (zero weight → tap skipped since k≤1e-3 filtered? if beta[i]=0, k=0, skipped by threshold. good).

Flow field texture: 64×64, value noise: random grid 8×8 of angles, smooth interp... Simple: for each texel, v = (noise(x,y), noise(x+37,y+91)) with periodic value noise via summing 2 sin/cos octaves:

Make divergence-free-ish: use streamfunction ψ = Σ sin; vel = (∂ψ/∂y, −∂ψ/∂x) analytic: ψ(x,y) = sin(2π(ax+by)+p1)0.5 + sin(2π(cx−dy)+p2)0.3 ... vx = dψ/dy = 0.52πbcos(...) + 0.32π*(−d)cos(...) vy = −dψ/dx = −(0.52πacos(...) + 0.32πccos(...)) with periods matching texture repeat (sample uvFLOW_SCALE with RepeatWrapping; ensure ψ periodic in uv over [0,1] → use integer frequencies a,b,c,d ∈ {1,2,3}). Nice: analytic periodic divergence-free flow. Store normalized to [-1,1]→[0,1].

In shader: vel = texture2D(uFlowTex, uvuFlowScale).rg2-1. uFlowScale = 3 (three swirls across dish). uFlow slider 0..1 maps to cells displaced per step: offset = vel * uFlow * 0.9 / uRes (max ~0.9 cell/step at full — subtle).

Stats material: samples 48×48 grid over [0,1]² avg R and G → writes vec4(mass, act, 0, 1) into 1×1 RGBA8 RT.

Readback: renderer.readRenderTargetPixels(statsRT, 0,0,1,1, buf) every 15 frames.

Watchdog with log lines.

Preset application:

soup(stampIdx): clear both RTs; N=7 spore splats random centers radius 26-50 cells (uv r = cells/res); plus 2 stamps at random pos.

Clear: setRenderTarget each RT, setClearColor(0x000000, 0)? clear color alpha — write vec4(0). Use renderer.setClearColor(new THREE.Color(0,0,0), 0); renderer.clear(true,false,false). Both ping & pong.

Paint pass function:

Note: paint shader must preserve G,B channels: prev.gba passed through (mode erase also scales g? fine keep g).

Stir: na from upstream sample; g recompute not needed.

Spores: na = mix(a, noise, mask*0.85); keep g.

Pointer: on pointerdown/move with buttons: get world uv; if inside dish: current tool: brush mode (spores/erase/stir) continuous while down; specimen stamps once per click (and on drag with min distance spacing ~ stamp radius → lay trail of creatures! throttle by distance).

Symmetry applies to spores/erase/stir.

HUD updates every ~10 frames (DOM writes throttled).

Sliders: input events update params; μ/σ/T immediate; R/β rebuild taps; changing μ/σ/R mid-life can kill — that's exploration; watchdog notes collapse.

Kernel preview: draw on small canvas 120×54: radial profile: x from 0..1 → k = beta[floor(xB)]*bump(frac) normalized max; stroke cyan. Growth preview: u 0..0.5 → G(u) curve, with μ marker line.

Specimen cycling button shows current name.

Audio:

Log scale fine.

Snapshot:

Auto-quality:

Wait — resample copy: newRT linear sampling of old texture: out = texture2D(uOld, vUv) — old texture res different, linear → smooth. OK. Need copy material. Reuse paintMat mode 4 = COPY: na = texture2D(uState, vUv).r; g,b too. Add mode 4.

Actually simpler: resizeSim renders with a dedicated tiny ShaderMaterial copyMat. Fine.

Sim res vs dish: independent.

One more consideration: sim speed T=8 with 2 substeps → 16 growth-units... generation = steps count. Display "gen".

FPS: RAF dt EMA.

Pause: skip sim, still render + stats.

Prevent context menu on canvas (right-drag erase): use shift instead; also right-button paint erase: check e.buttons&2 → erase regardless of mode. Add oncontextmenu preventDefault.

Now the palette/light numbers — write once, no preview available (no browser here). I'll rely on sensible values; bloom helps. Risk of "too dark/bright" mitigated by exposure 1.15 and bloom 0.7.

Edge: half-float linear filtering — core WebGL2 for 16F? Let me double check: In WebGL2, texture filtering for sized internal formats: RGBA16F is listed as filterable (OES_texture_half_float_linear folded into core? The WebGL2 spec texture table marks 16F formats "filterable: yes, renderable: only with EXT_color_buffer_float"). Yes — RGBA16F is filterable in core WebGL2, renderable with EXT_color_buffer_float.

Let me also handle WebGL1 absence gracefully: three r163+ requires WebGL2 anyway (r170 dropped WebGL1). If creation fails → overlay message.

Mobile layout: media query stacking panels; controls panel max-height with scroll.

Let me now also decide preset button behavior: apply params + reseed soup with its specimen (gives instant gratification), log entry.

Generation display with tabular nums.

Log: array of {t, msg}, render last 4, fade older via CSS opacity based on age class. Simple: prepend div, remove after 6s with CSS transition.

Toasts: bigger center-bottom toast for watchdog events. Reuse log with .warn class. Keep single log system with classes.

Time to write. I'll write the file with %%STAMP_*%% placeholders then inject.

Also remember index.html card update afterward.

Writing now — carefully balanced braces and shader strings. Also GLSL: no % modulo for ints in ES1-style? three compiles to 300 es so mod fine, but I use float ops anyway. Avoid dynamic indexing issues. Use texture2D.

One GLSL concern in sim shader loop: texture2D(uTaps, vec2((float(i)+0.5)/1536.0, 0.5)) — fine.

Break in loop: if (i >= uTapCount) break; — uTapCount is int uniform — fine in ES3.

Display shader gradient taps: 4 extra texture reads + main — cheap.

Let me write out the entire HTML now. I'll keep it organized with section comments. Approx 1000-1300 lines. Go.

The file is written in /workspace (local, fast). Now:

1. Inject the stamp base64 data from /tmp/stamp-*.json.
2. Syntax-check the module script with node.
3. Copy to /space/demos/047-primordial/index.html.
4. Update the demos index.

Wait — one issue: I wrote to /workspace — let me check that path is valid... The tool said success with path /workspace/047-part1.html. OK.

Injection script: replace %%STAMP_ORBIUM%% etc with the data strings.

Also I should double check a few code details:

1. slider() helper: el.value = get() before attributes — fine. But ui.R uses v|0 — slider step 1 already.

2. In paintMat fragment shader: prev.g * (1.0 - mask * float(uMode == 2)) — float(bool) conversion is valid GLSL ES 3.00. OK. But uMode == 2 — comparison of int uniform with literal — fine.

3. In sim shader, texture2D(uTaps, ...) where uTaps is FloatType with NearestFilter — OK.

4. Paint pass uMode == 1 (specimen): I wrote na = max(a, sv * smoothstep(0.0, 0.02, sv)); — smoothstep(0,0.02,sv)≈1 for sv>0.02 so effectively max(a, sv) with tiny edge cleanup. OK.

5. paint() reads rtRead, writes rtWrite, swaps — good.

6. In seedSoup, radius in cells 30-52 — at simRes 384, uv radius 0.078-0.135 — good sized splats.

7. statsMat loop 48×48 = 2304 — good.

8. readRenderTargetPixels(statsRT...) — RGBA/UnsignedByte — always supported. Good.

9. Display shader: smoothstep(dishR, dishR - 0.035, r) — edge0 > edge1: GLSL smoothstep with edge0>edge1 is undefined per spec! genType results are undefined if edge0 ≥ edge1. Many drivers handle reversed smoothstep as expected (it clamps (x-e0)/(e1-e0)), but it's technically undefined. I use reversed smoothstep in several places: smoothstep(uRadius, uRadius*0.55, rr) (edge0>edge1), smoothstep(1.25, 0.30, ...) in bench, smoothstep(dishR, dishR-0.035, r), smoothstep(dishR + rimW, dishR + rimW*0.4, r). In practice ANGLE/drivers implement it as the formula and it works (I've seen it widely used), but to be safe I should rewrite as 1.0 - smoothstep(lo, hi, x). Let me fix all reversed smoothsteps to be spec-safe.

List of reversed smoothstep uses:

• paint: smoothstep(uRadius, uRadius*0.55, rr) → 1.0 - smoothstep(uRadius*0.55, uRadius, rr)
• display: col *= 0.55 + 0.45 * smoothstep(dishR, dishR - 0.035, r); → 0.55 + 0.45*(1.0 - smoothstep(dishR-0.035, dishR, r))
• display bench: float vgn = smoothstep(1.25, 0.30, length(...)) → 1.0 - smoothstep(0.30, 1.25, len)
• dust: smoothstep(0.6, 0.0, length(fract(dp)-0.5)) → 1.0 - smoothstep(0.0, 0.6, ...)
• rim: smoothstep(dishR + rimW, dishR + rimW*0.4, r) → 1.0 - smoothstep(dishR + rimW*0.4, dishR + rimW, r); and smoothstep(dishR - 0.004, dishR + rimW*0.35, r) is fine (increasing).

Also in stats shader and others — check: stats uses none. Sim: none. Grade: smoothstep(0.15, 0.85, r2) fine.

10. UnrealBloomPass with HDR: composer default render target type — EffectComposer in r170 uses HalfFloatType by default. Good, bloom works nicely.

11. renderer.setClearColor(0x000000, 0) in clearWorld then... note the main render doesn't rely on clear color (fullscreen quad covers everything). Fine.

12. composer.render() in snapshot before toDataURL — same-task; OK without preserveDrawingBuffer.

13. Keyboard: 's' triggers snapshot but 's' might also be typed... no text inputs besides range — fine.

14. ui.T fmt shows '1/8.0' — tempo. OK.

15. In toWorld, I use dishR 0.455 consistent with shader — with tilt offset applied (p -= tilt0.022 in shader, so to invert: p_screen → world needs p = screen - tilt0.022... In shader: p = (vUv-0.5)vec2(aspect,1) - tilt0.022. In JS: px = (x-0.5)aspect - tilt.x0.022 — matches. Good.

16. Potential view 'V' — uView uniform — good.

17. substeps fixed 2 — autoQuality changes res only. OK.

18. Mass bar width mass*220% — mass 0.2 → 44%. fine.

19. Activity‰: activity = mean G (G≈min(1,|Δ|60) smoothed) → /601000 gives per-mille-ish of raw |Δ|. Display only. OK.

20. One issue: paintMat.uniforms.uSym.value = params.sym — set in paint(). Yes included.

21. In stir mode: texture2D(uState, from) — from may exit [0,1] — RepeatWrapping on sim RT handles wrap. Good.

22. Sim sampling texture2D(uState, auv + t.xy*px) — wraps via Repeat. Good.

23. The float(MAX_TAPS) — MAX_TAPS is #define MAX_TAPS 1536 — float(1536) fine.

24. DataTexture for stamps: RGBA8 with LinearFilter — fine. t.needsUpdate = true — set. In decodeStamp I set needsUpdate? Yes: t.needsUpdate = true; — yes.

25. flowTex: FloatType RGBA with LinearFilter — filtering float32 textures requires OES_texture_float_linear! Not universally available (most desktop GPUs support it). Safer: use HalfFloatType for flowTex — 16F linear is core. Need to convert float32 values to half... Three DataTexture with HalfFloatType requires Uint16Array of half bits. Converting: THREE.DataUtils.toHalfFloat. Or simpler: use UnsignedByteType RGBA with normalized [0,1] — precision 1/255 for a smooth flow field → stepping artifacts in advection? Advection offset vel*0.9/res: vel quantized to 255 levels — fine for slow drift. Use UnsignedByteType. Simpler and universally filterable. Let me change flowTex to UnsignedByteType with d as Uint8Array.

Also tapsTex FloatType with NearestFilter — sampling float32 with nearest is core WebGL2 (no filtering extension needed for nearest). Good.

26. renderer.getContext().getExtension('EXT_color_buffer_float') — checking before three sets up; fine.

27. log element prepend — CSS #log div:first-child — good.

28. On mobile #controls hidden — the dish still paintable. OK.

29. document.getElementById('btnSpecimen') width — in .srow with label; style flex? button.wide width 100% inside srow → squishes label? .srow label flex 0 0 58px, button wide → takes remaining. OK.

30. ACESFilmicToneMapping + OutputPass: OutputPass uses renderer.toneMapping — good.

31. Grade pass runs before OutputPass: chromatic aberration operates on linear HDR values — fine.

32. Bloom threshold 0.32: with ACES output? No — bloom operates on linear pre-tonemap buffer. Culture colors peak ~1.0 + spec; bloom picks highlights. OK.

33. initial syncUI called via applyPreset(0) — yes, applyPreset calls syncUI. drawPreviews also called there.

34. preset buttons class 'on' toggling in syncUI.

35. missing: stRes initial "384²" — static in HTML. resizeSim updates. Good.

36. params.brushCells default 34; slider min 8 max 70. spore splats at 34 cells radius: harness showed r=30 survives → good. Slider min 8 → small splats die (by design, help text explains).

37. In pointerdown for spores: paint once; dragging paints continuously — new noise each frame while moving slowly could over-saturate (mix 0.85 each frame at same spot → converges to noise pattern ~0.5 mean). It's fine — splat with mask*0.85 repeatedly at same spot: values approach noise fixed point? Each frame new noise → flickers but mean 0.5. Region becomes noise 0.5 mean — similar to seed noise → self-organizes. OK.

38. Stir: mixes state toward upstream sample — cheap vortex. OK.

39. Bug check in paint shader SPORES: hash(floor(folded*uRes) + vec2(uSeed, uSeed*1.7)) — folded can be negative → floor fine → hash fract handles negatives (fract of negative is defined in GLSL as x - floor(x) → positive). OK.

40. const cv = renderer.domElement; — shadows preview canvas var names? I used cv inside drawPreviews as local const cv = document.getElementById(...) — the outer cv declared AFTER drawPreviews function definition but the function only runs via applyPreset → called at boot after outer const cv initialization... wait: outer const cv = renderer.domElement is declared in pointer section; applyPreset(0) is called at boot (end of script) — after all declarations. But syncUI() → drawPreviews() uses local cv — shadowing: inside drawPreviews, const cv = ... declared in each block — shadows outer. No TDZ issue since local declared before use. OK.

41. In display shader uView float; params.view int; set via uniform. OK.

42. Stamp size in paint: radius param S*0.55*(brushCells/34) — cells. For orbium S=44 → 24.2 cells ≈ half the stamp (22) → stamp fills brush circle: suv = d0/(2radius)+0.5 maps radius→0.5 of texture — stamp S cells maps to 2radius=S*1.1 cells → slight upscale, fine.

43. Wait — specimen paint at 320/256 sim res: stamp cells constant → creatures same cell-size; params (R=13 cells) constant → creature still valid. Good — resolution-independent physics.

44. On tier change, simMat.uniforms.uRes updated, display uRes updated (for gradient texel size). Yes in resizeSim.

45. Half float G channel mix with 0.12 smoothing — fine.

46. Potential B channel stored — stats ignores. OK.

47. One more: EffectComposer renders displayScene via RenderPass — displayScene quad with clip-space vertex — camera irrelevant. OK.

48. renderer.readRenderTargetPixels for RGBA8 1×1 — fine.

49. Audio: AC.suspend()/resume. shimmerGain null check — after init always set. toggle before init → initAudio called. Good.

50. Missing feature check: statsScene rendering into 1×1 RT with fullscreen quad — vUv unused; fine.

51. iOS Safari: EXT_color_buffer_float supported iOS 15+. OK.

Also potential GLSL compile issue: in stats shader I declare varying vec2 vUv in VERT but don't use in fragment — fine.

In sim shader: if (i >= uTapCount) break; — uTapCount int uniform; loop index i int — fine.

GLSL paint: float(uMode == 2) — bool→float constructor — ES3 ok.

atan(d0.y, d0.x) at d0=0 → undefined but returns something; mask 1 at center — fine.

Let me fix the reversed smoothsteps and the flowTex type now, inject stamps, then validate JS syntax by extracting module script, and do a mock-DOM node smoke test? A full DOM mock is heavy; syntax check + careful review should suffice. Maybe minimal check: parse script with node --check (module). The script imports 'three' — node --check only parses, doesn't execute/resolve.

Actually I can go further: run a headless smoke test with a stubbed DOM? That's a lot of stubbing (document.getElementById, canvas contexts...). Given the previous demos used a node harness for physics only, and browser test isn't available here (no puppeteer?), let me check if puppeteer/playwright exists.

87% of time used! I need to finish NOW. Fast actions:

1. Apply the two fixes (reversed smoothstep, flowTex byte type) to /workspace/047-part1.html.
2. Inject stamps.
3. Extract module script → node --check.
4. Copy to /space/demos/047-primordial/index.html.
5. Update /space/demos/index.html with the new card.
6. Done.

Let me do the fixes with replace_in_file (multiple in parallel where independent). The fixes:

Fix 1 — flowTex to UnsignedByteType:

→ Uint8Array, and the writes d[i] = 0.5 + 0.5 * vx / m; → Math.round((0.5+0.5*vx/m)*255) etc. And type in DataTexture constructor.

Fix 2 — paint spores mask: float mask = smoothstep(uRadius, uRadius * 0.55, rr); → float mask = 1.0 - smoothstep(uRadius * 0.55, uRadius, rr);

Fix 3 — display inner wall shadow: col *= 0.55 + 0.45 * smoothstep(dishR, dishR - 0.035, r); → col *= 0.55 + 0.45 * (1.0 - smoothstep(dishR - 0.035, dishR, r));

Fix 4 — bench vignette: float vgn = smoothstep(1.25, 0.30, length((vUv - 0.5) * vec2(aspect, 1.0))); → float vgn = 1.0 - smoothstep(0.30, 1.25, length((vUv - 0.5) * vec2(aspect, 1.0)));

Fix 5 — dust: * smoothstep(0.6, 0.0, length(fract(dp) - 0.5)); → * (1.0 - smoothstep(0.0, 0.6, length(fract(dp) - 0.5)));

Fix 6 — rim: float rim = smoothstep(dishR + rimW, dishR + rimW * 0.4, r) * smoothstep(dishR - 0.004, dishR + rimW * 0.35, r); → float rim = (1.0 - smoothstep(dishR + rimW * 0.4, dishR + rimW, r)) * smoothstep(dishR - 0.004, dishR + rimW * 0.35, r);

Then inject stamps via node script, syntax check, copy, update index. Go fast.

90% used! Finalize NOW in one combined shell command: inject stamps, extract script for node --check, copy to /space/demos/047-primordial/index.html. Then one more command for index update + verification, then _success.90% — finalizing in one shot: inject stamps, syntax check, deploy, and update the index page:

*****************************************************************************************************************************************************************************************************************************************************rt.

**************************************************************************************************on.

The comment line has leading spaces <!-- New demos are added here --> and the anchor starts with 10 spaces <a class="demo-card".... My search had no leading spaces on the comment line. Let me use a simpler unique anchor: just the 046 href line.

Still not found. Perhaps the file uses \r\n line endings or the anchor tag is indented differently. The cat -A showed <a class="demo-card" href="./046-bridge-works/index.html">$ — 10 spaces, no \r. Hmm, maybe my replace string contains exactly that... it failed. Maybe the tool had issues with / or quotes? The earlier search <!-- New demos are added here -->\n <a class... also failed. Wait — maybe grep shows line 99 is the comment but sed showed lines 100-106 — line 100 is the anchor. Let me try sed-based insertion directly at line 100, or check for hidden characters. cat -A showed clean $ at end. Odd. Let me just do it with sed by line number.

Card inserted. Note the indentation came out with 12 spaces (the heredoc content got indented? Actually I wrote 10 spaces but sed r just inserts file content verbatim... the output shows 12 spaces before <a. Wait, look: <a class=\"demo-card\" — that's the sed display escaping quotes. The inserted lines have 12 spaces vs 10 for surrounding. Minor cosmetic mismatch in HTML source — irrelevant to rendering. But let me fix for consistency... it's cosmetic only in source. Skip — time is critical.

Final verification: file exists, sizes, and count demos. Then _success.

Everything checks out:

• /space/demos/047-primordial/index.html deployed (53.6KB, all stamp placeholders injected — 0 remaining %%STAMP tokens)
• index.html updated with Demo 047 card
• JS syntax verified with node --check
• Lenia physics validated with 4 rounds of Node harness: presets survive, stamps alive, spore brush radius tuned

Task complete. Call _success.