Kinetic Theory

A new turn has started. The task is "Wake up and do as you please." — meaning I should create a new cool Three.js demo in /space/demos/. The last execution created demo 038-sandpile. So I should create demo 039 with some new advanced concept.

Let me first explore the current state of the demos folder to see what exists, then decide on a new demo concept.

Let me install shell tools first.

The demos folder has 38 demos already. The task says "Wake up and do as you please." — so I should create a new demo 039. Let me look at the existing index.html to understand the format, and check a couple of recent demos for style patterns (e.g., 038-sandpile).

Let me first read the index.html to see the structure.

I have 38 demos. Now I need to create demo 039. Let me think of a concept that hasn't been done yet. Existing demos:

1. spinning cube
2. nebula galaxy (particles)
3. mandelbulb explorer (raymarched fractal)
4. fluid dynamics (GPU Navier-Stokes)
5. gravity sandbox (N-body)
6. event horizon (black hole lensing)
7. sonic reactor (audio visualizer)
8. void runner (endless runner game)
9. azure odyssey (sailing / Gerstner waves)
10. abyssal bloom (deep sea boids)
11. physarum garden (slime mold GPU)
12. powder alchemy (falling sand)
13. clockwork nebula (orrery/steampunk gears)
14. neon rain
15. aurora borealis
16. skitter
17. coral resonance
18. threshold
19. attractorium (strange attractors)
20. murmuration (flocking)
21. terraforge (terrain)
22. cloudsea (volumetric clouds)
23. frostline (frost/ice)
24. koi pond
25. ferrofluid
26. synchrony (Kuramoto oscillators)
27. cymatics
28. teslasphere
29. pyrosymphony (fireworks)
30. morphogenesis (reaction-diffusion?)
31. galton cascade (Galton board / probability)
32. wavefront
33. gossamer (spider web?)
34. magnetosphere
35. cloud chamber (particle physics)
36. wavefunction (hydrogen orbitals)
37. epicycle (Fourier drawing machine)
38. sandpile (self-organized criticality)

What could 039 be? Ideas:

• Reaction-diffusion (Gray-Scott) — might be covered by 030-morphogenesis? Morphogenesis is probably reaction-diffusion (Turing patterns). Let me check.
• Voronoi fracture / physics destruction
• 3D Game of Life / cellular automata
• L-systems / procedural trees
• Marble machine / Rube Goldberg with physics
• Ray tracing / path tracing demo
• Double pendulum chaos
• Wave interference / ripple tank (maybe 032-wavefront?)
• Ant colony simulation
• Neural network visualization
• DLA (diffusion-limited aggregation)
• Ising model (statistical mechanics)
• Brownian motion
• Solar system
• Rocket / space flight sim
• Cloth simulation
• Soft body physics
• Knot theory / topological surfaces
• Hyperbolic tiling (Poincaré disk)
• 4D visualization (tesseract / 4-polytopes)
• Origami / paper folding
• Lightning / dielectric breakdown
• Lava lamp / metaballs
• Fire simulation
• Snow globe
• Aquarium
• Bouncing ball music
• Maze generation
• Procedural city
• Traffic simulation
• String harmonics / Chladni (027 cymatics did that probably)
• Percolation theory
• Forest fire model
• Segregation model (Schelling)
• Conway's Game of Life 3D
• Langton's ant
• Boids (done: murmuration)
• SPH fluid (maybe 004)
• Vortex dynamics
• Kelvin-Helmholtz
• Double pendulum with chaos visualization
• Lorenz attractor (019 attractorium covers attractors)
• Solar flare / plasma
• Quantum tunneling
• Schrödinger evolution in 2D (quantum wave packet scattering) — 036 was wavefunction eigenstates, could do time evolution
• Geodesic / spirograph
• Tessellations
• Islamic geometry / girih tiles
• Penrose tiling
• Wave function collapse algorithm (procedural generation) — fun and visual!
• Markov chains / random walk
• Brownian tree
• Snowflake growth (maybe 023 frostline?)
• Crystal growth
• DLA dendrites
• Lightning (dielectric breakdown model)
• Superconductor levitation
• Magnetic field lines (034 magnetosphere)
• Pendulum wave machine — beautiful! Pendulum wave with 15 pendulums of different frequencies creating patterns. With audio? That's nice but maybe simple.
• Rubens tube
• Euler's disk
• Gyroscope / precession
• Coriolis carousel / Foucault pendulum — Foucault pendulum is nice! Sand pendulum drawings.
• Harmonograph — drawing machine with pendulums, creates beautiful Lissajous-like patterns. Similar to 037-epicycle (Fourier drawing)? Epicycle is Fourier circles; harmonograph is damped pendulums. Might be too similar.
• Spring-mass lattice / wave simulation on cloth
• Volumetric raymarching nebula
• Portal / non-euclidean
• Black hole (done 006)
• Wormhole
• Time crystal
• Percolation
• SIR epidemic spread model on a city grid
• Predator-prey Lotka-Volterra ecosystem — ecosystem sim! "Primordial soup" / artificial life with evolution! That's a good one — evolving creatures (like Bibites). Complex but doable.
• Genetic algorithm evolution of vehicles (like BoxCar2D) — evolving walkers/cars! That's fun and interactive.
• Ant colony optimization solving TSP live
• Particle swarm optimization visualized
• Boids (done)
• Conway's Game of Life on a torus in 3D with glow
• Wireworld / Langton's ant
• Termite colony building
• Flocking with predator
• Fireflies sync (026 synchrony probably did this — Kuramoto)
• Chladni (027)
• Coupled pendulum waves
• Galton board (031)
• Avalanche (038)
• Sandpile (038)

Let me check what 030-morphogenesis, 032-wavefront, 033-gossamer, 023-frostline, 016-skitter, 018-threshold, 017-coral-resonance, 028-teslasphere are to avoid overlap.

Let me grep the index.html for those cards.

Now I have a good picture of all 38 demos. Covered topics:

• Particles/galaxies, fractals, fluids, N-body gravity, black holes, audio visualizers, games (runner), ocean sailing, boids/flocking (multiple), slime mold, falling sand, gears/orrery, cyberpunk city, aurora, creatures/locomotion, cymatics (2 demos!), portals, murmuration, terrain erosion, volumetric clouds, frost crystals, koi pond, ferrofluid, fireflies sync, Chladni, plasma globe, fireworks, reaction-diffusion, Galton board, wave interference, spider web, magnetosphere, cloud chamber, quantum wavefunction, Fourier epicycles, sandpile.

What's NOT covered yet — good candidates for 039:

1. Ising model / phase transitions — statistical mechanics, magnetization, critical temperature. 2D lattice with spin flips, visualization as domains growing. Could render in 3D as a lattice of arrows. Interactive: temperature slider, external field, watch Curie point phase transition, measure correlation length, hysteresis loops. Nice physics demo.

2. DLA (diffusion-limited aggregation) — dendrite growth. Might overlap with frostline somewhat.

3. Wave Function Collapse — procedural generation algorithm; watch a city/terrain generate with constraint solving. Very visual and trendy. Could do 3D tile-based WFC generating a little city/landscape, with the constraint propagation visualized as entropy heat. That's cool and distinct.

4. Ant colony / swarm intelligence — ants finding food, pheromone trails, shortest path. Overlaps a bit with physarum (slime mold pheromone). Hmm.

5. Ecosystem / evolution sim — primordial soup with evolving creatures. Ambitious.

6. Double pendulum chaos — sensitive dependence, divergence of nearby initial conditions, trace many pendulums. Beautiful physics. Could render 100 double pendulums with tiny initial differences fanning out, a chaos visualization with Lyapunov exponent estimation. Nice but maybe a bit simple visually compared to recent ones.

7. Hyperbolic geometry / Poincaré disk — Escher-like tilings. Cool but 2D-ish.

8. 4D polytopes — tesseract rotating in 4D, 120-cell projected to 3D. Great "wow" math demo: rotate in 4D planes (XW, YW, ZW), stereographic projection, cell-first/edge-first views, Hopf fibration? Distinct from everything done.

9. Spring-lattice cloth / jelly — soft body. Meh.

10. Lightning / dielectric breakdown — teslasphere did lightning arcs.

11. Raymarched liquid / metaballs — lava lamp. Meh.

12. Traffic flow / Nagel-Schreckenberg — emergent phantom jams. Cellular automaton traffic on a ring road, fundamental diagram live plot. Nice science but visuals modest.

13. Kuramoto on a network — done sync.

14. Game of Life 3D / smooth Life / Lenia — Lenia! Continuous cellular automaton producing beautiful "organisms" (orbium). That's gorgeous and distinct from Gray-Scott. GPU compute, continuous kernel convolution, glowing organisms gliding around. Very cool. But similar vibe to physarum/morphogenesis (cellular automata petri dish).

15. Particle swarm / flocking predators — done.

16. Kepler / orbital mechanics sim with real planets — gravity sandbox covered.

17. Pendulum wave — simple.

18. Solar wind / plasma — done.

19. Fire / combustion sim — pyrosymphony is fireworks, not fire sim. A GPU fire sim could be cool but fluids-ish (004).

20. Procedural city with WFC — see 3.

21. Ising model — I like this. Interactive statistical mechanics with real measurable physics (magnetization vs T, critical slowing down, hysteresis). Could be rendered as a beautiful 3D array of glowing cones/arrows that flip, with domain walls shimmering. Wolff cluster algorithm option for fast equilibration at criticality! Metropolis vs Wolff. Add a live M–T chart with Onsager's exact solution curve overlaid. That's a strong science demo in the spirit of 031 (Galton), 036 (wavefunction), 038 (sandpile).

22. Percolation — related to Ising but less pretty.

23. Brownian motion / statistical physics of gases — kinetic theory: hard-sphere gas in a box with Maxwell-Boltzmann distribution histogram live! That's a nice companion to Galton Cascade. 3D box of bouncing spheres, live velocity histogram vs theoretical MB curve, pressure gauge from wall collisions, temperature slider, piston compression (adiabatic heating!), Maxwell's demon mode (sorting by velocity!), effusion through a small hole. Maxwell's demon is a fantastic interactive feature. Ohh, that's a really nice demo idea — "Kinetic Theory" gas lab.

24. Origami / folding — hard.

25. Knots / braid — meh.

26. Hopf fibration / 4D — beautiful but abstract.

27. Voronoi/Delaunay fracture — destruction sim. Cool but maybe meh.

28. Erosion — done (terraforge).

29. Snow globe — meh.

30. Aquarium — koi pond adjacent.

Comparing top candidates: Ising model vs kinetic gas lab vs WFC vs Lenia vs 4D polytopes.

The recent demos have all been physics-science heavy with rich interactivity and generative audio (cloud chamber, wavefunction, epicycle, sandpile). The kinetic theory gas lab ("Ideal Gas / Maxwell-Boltzmann") fits this lineage beautifully and covers physics not yet touched: statistical mechanics, distributions, entropy, Maxwell's demon. Features:

• 3D glass box with N hard-sphere particles (up to ~2000?) with exact elastic collision handling (event-driven or time-stepped with spatial hash).
• Live velocity/speed distribution histogram with theoretical Maxwell-Boltzmann curve overlaid at current temperature.
• Temperature slider (thermostat: velocity scaling or Berendsen), pressure readout computed from momentum transfer to walls.
• Piston: movable wall, compress/expand — adiabatic heating/cooling visibly changes speed distribution! PV diagram trace! pV = NkT verification: plot pV/(NT) ≈ 1.
• Two-chamber mode: partition with removable wall — watch mixing/entropy, "free expansion" (Joule expansion, temperature unchanged for ideal gas).
• Maxwell's demon mode: a door in the partition that opens only to let fast particles one way and slow the other — creates a temperature gradient! Sorting demo. Amazing.
• Effusion mode: small hole, particles escape to vacuum chamber; heavier vs lighter isotopes separate at different rates ( Graham's law). Maybe two species (light/heavy) — isotope separation! Nice.
• Equipartition: mixture of light and heavy particles at same T — show mean KE equal, speeds differ.
• Gravity option: watch barometric distribution (density falls with height).
• Color code particles by speed (blue→red).
• Audio: subtle collision clicks sonified (rate ∝ pressure), pad following temperature.
• Live charts: speed distribution + fit, pV diagram.
• Demos of Brownian motion: one big heavy "pollen" sphere jiggling — classic Brownian motion! Could toggle a big sphere. That's lovely.

That's a rich, distinct, interactive demo: "039-kinetic" or "039-ideal-gas" / "039-maxwell-demon". Let me name it "039-maxwell-demon"? The centerpiece could be the gas lab with demon mode. Or "039-kinetic-theatre"... Let me go with 039-ideal-gas or 039-kinetic-theory. Hmm, catchier: "039-Maxwell's Demon"? The demon is one mode. I'd call it "Kinetic Canvas"? Previous names are evocative: Sandpile, Wavefunction, Magnetosphere, Cloud Chamber, Cymatics... I'll name it "039-thermal-chamber"? Or "039-molecular-dynamics"? Let me go with 039-ideal-gas-lab...

Actually, let me reconsider vs. Ising model. Ising is also great: domain formation, critical opalescence analog, M-T curve with Onsager solution, hysteresis loops with external field sweep, Wolff cluster flips, correlation length divergence at Tc. Rendered as 256×256 lattice of little double-cones or as extruded height field? Honestly the gas lab has more visual life (moving glowing spheres in 3D with trails) vs. a flipping lattice. The gas lab in 3D with glowing particles and glass walls is prettier and more dynamic.

Alternatively combine: the demo is "Statistical Mechanics Theatre" with gas + demon + effusion + brownian. I'll build the gas lab with several modes/presets:

Presets:

1. Equilibrium — single gas in box, MB distribution verification.
2. Two Gases / Equipartition — light + heavy mixture; same mean KE; speeds differ.
3. Brownian Motion — big pollen sphere + tracer path.
4. Adiabatic Piston — piston compresses gas, T rises; pV diagram draws (p vs V loop), verify pV^γ const-ish. Could animate piston oscillation if released? Maybe piston position controllable + "release" to let it bounce like a spring (gas spring!). Adiabatic oscillations are lovely: PV work → temperature oscillates. Damping from... for ideal gas in 1D piston, it's actually undamped adiabatic (entropy constant). Fine.
5. Free Expansion / Joule — partition removed, gas expands into vacuum, T constant (ideal gas).
6. Maxwell's Demon — partition with demon door; fast go right, slow go left (or vice versa); temperature diverges. Live T_left, T_right meters + entropy discussion in log.
7. Effusion / Isotope separation — small hole to second chamber, light species escapes faster; count enrichment ratio.

That's 7 presets — comparable to earlier demos' scope.

Physics implementation:

• N up to ~1500 spheres, radius small relative to box. Time-stepped integration with collision detection via spatial hash grid on CPU. Elastic sphere-sphere collisions (exact impulse), wall collisions with optional moving piston wall (momentum exchange with moving wall gives adiabatic heating). Event-driven would be fancier but time-stepped with substeps is fine and robust.
• Actually with r small and N~1500, collisions per step modest; spatial hash fine. Use fixed dt with 2-4 substeps for accuracy at high T.
• Units: k_B = 1, box L ~ 30-40 units, particle r=0.5, mass 1 (light) / 8 (heavy, isotope).
• Temperature measured as mean KE: T = (2/3)·⟨KE⟩ in 3D with k_B=1... ⟨KE⟩ = (3/2)kT.
• Thermostat mode: rescale velocities gently toward target T (isokinetic) — used in "thermostat" preset; off in adiabatic/free-expansion to show true physics.
• Pressure: sum |Δp| delivered to walls per unit time / total wall area: P = Σ(mΔv)/(A·Δt). Show gauge.
• MB histogram: speeds binned, overlaid analytic curve f(v) = 4π (m/2πkT)^{3/2} v² exp(-mv²/2kT). For mixtures show two curves.
• Demon door logic: door in partition, when particle near door within radius and crossing: fast (v > v_thresh, maybe relative to instantaneous mean) passes left→right only; slow passes right→left only. Classic demon. Result: right heats, left cools. Show T gauges on both sides + entropy note.
• Effusion: hole radius in partition; any particle crossing goes through; second chamber starts evacuated; count N1, N2 by species; flux rate ∝ ⟨v⟩ ∝ 1/√m.
• Brownian: one large sphere radius ~4, mass ~50x; trace its position with fading ribbon trail; mean-squared displacement log maybe overkill; trail is enough + kick flashes when hit? The big sphere visibly jiggles.

Rendering:

• Particles as instanced spheres (or points?). InstancedMesh with custom shader: color by speed (colormap cool→hot: deep blue→cyan→white→orange→red), slight emissive for bloom, rim fresnel. Speed color normalization by current mean speed.
• Glass box: BoxGeometry with transmission? MeshPhysicalMaterial transmission is expensive but one box... simpler: custom fresnel glass shader, additive edges, subtle grid floor with glow. Or a "chamber" look like cloud chamber: dark lab, glass box with edge glow, floor grid, dust motes.
• Trails: optional phosphor trails for subset (or all via points?). Maybe trails for Brownian particle + option for all via an afterimage pass? Simpler: per-particle short ribbon trails too costly for 1500; use a fullscreen "afterimage" via render-target feedback? The bloom + motion is fine; add trail toggle using a low-res accumulation buffer (fade quad). Let me implement optional "motion trails" as a simple afterimage: render scene to RT, blend previous frame at 0.9. Hmm, with post-processing chain this gets fiddly. Alternative: velocity streaks — stretch each sphere instance slightly along velocity in vertex shader (motion smear) — cheap and looks great! Stretched instanced spheres along v. Good.
• Brownian particle: bigger, distinct (gold), with its own trail line (ribbon of last 500 positions, additive).
• Partition: glass slab in middle that slides down/out when removed; demon door as glowing ring; hole as ring too.
• Piston: metallic slab that moves along x with handle; sparks/glow on compression?
• Post: UnrealBloom + grade pass (vignette/grain/chromatic aberration), same as previous demos.
• Environment: dark lab, subtle floor reflection? Keep it moderate: reflective dark floor via simple planar mirror might double draw calls; previous demos did planar reflectors. Could do simple: glossy floor grid + fog. Keep performance.

UI/HUD (consistent with prior demos):

• Top-left panel: title, preset buttons, sliders (temperature/thermostat strength, particle count, piston position, gravity, time scale), toggles (trails/smear, mixture, stats).
• Right panel: live readouts: N, T (measured), P, mean speed, rms speed, ⟨KE⟩ per species, histogram canvas for speed distribution + MB curve(s), pV mini-diagram in piston mode, demon T gauges, effusion counts.
• Event log (like earlier demos): "Partition removed — free expansion", "Demon engaged: sorting fast → right", "Compression: T 1.0 → 1.8".
• Bottom bar: keyboard shortcuts hint.
• Snapshot (PNG) button, fullscreen, audio toggle, quality tiers (auto-scaling particle count / pixel ratio).

Audio:

• Collisions: soft clicks/ticks (band-passed noise bursts) — but 100s per second would be noise; sonify via stochastic granular bed whose density ∝ collision rate, pitched by temperature. Wall impacts on piston add thump. Removal of partition: whoosh. Demon door: little "blip" ascending for fast pass, descending for slow pass. Pad drone tracking mean KE. Keep subtle; toggle.
• Use WebAudio with lookahead scheduling like previous demos? Keep simpler: per-event synth with throttling.

Structure: single self-contained index.html with importmap for three r160+ (check what previous demos use — likely unpkg three@0.160+). Let me check one of the recent demos for the exact CDN/importmap pattern and the grade pass implementation, to stay consistent.

Physics correctness details:

• Collision response: equal mass impulse: swap normal components along line of centers; general masses: standard formulas.
• Spatial hash: cell size ~ 2.2*maxRadius; N=1500 in box 40³ fine.
• Fixed timestep dt = 0.02·(1/timeScale?) Actually choose dt so fastest particle moves < r/2 per substep: vmax ~ sqrt(3T/m)·4 → substep count adaptive. Simpler: run 3 substeps per frame at 60fps with dt scaled by simSpeed slider; also cap.
• Pair overlaps resolution: positional correction to avoid sinking (push apart).
• Walls: reflect with moving wall velocity for piston: v' = 2V_wall − v (normal comp). Momentum/energy handled: work done by piston = ΔKE — automatically consistent.
• Partition crossing & demon/hole: when partition active at x=0 (thickness thin), treat as wall for all particles except when within door radius (|y|,|z| < r_door) and demon logic allows; hole: within hole radius passes freely (and if "effusion", once in chamber B it's gas there; optionally one-way? Effusion is one-way-ish if B is pumped: make B "vacuum pump" — particles in B slowly removed (recycled to A? or vanish) to maintain enrichment measure. Simpler: keep them, show counts + enrichment meter; add "pump B" button to vacuum chamber B (particles removed → count collected).
• Gravity slider: g downward; barometric formula check via density gradient visual (color by height? optional readout). Keep simple: gravity slider affects motion; in log mention barometric layering.

Charts:

• Histogram canvas 2D: bins of |v|, normalized as pdf; overlay MB analytic at measured T (or thermostat T). For mixture: separate histograms per species? Draw combined + two analytic curves in species colors; also equal-KE message: mean KE light vs heavy displayed.
• pV diagram: canvas plot P vs V trace with point; loop visible when oscillating piston.
• Demon: two bar gauges TL, TR with numbers.

Performance:

• 1500 instanced spheres with custom shader: trivial. Spatial hash 1500² pair checks ~ fine at 60fps with substeps 2-3 (1500*~few neighbors).
• Stats every 0.25s to avoid GC.

Auto behaviors:

• If idle in equilibrium preset, thermostat keeps T; MB curve hugs histogram.
• Auto-tour? Not necessary. Maybe an "auto" director that cycles presets every 45s? Previous demos had tours. Could add small.

I must also ensure: no overlap with 004-fluid (that's continuum), 031-galton (discrete balls but gravity piles, no thermo stat mech), 035-cloud-chamber (particle tracks). This is distinct: statistical mechanics of an ideal gas with distributions.

Name ideas: "039-ideal-gas" ... "039-kinetic" ... "039-Maxwell–Boltzmann Lab"... Prior names: short & evocative. I'll go "039-kinetic-theory" with title "Kinetic Theory"? or "Thermal"? Let me choose 039-maxwell-boltzmann? Hmm the demon is the star interactive feature. Title: "Kinetic Canvas"? For consistency with science names: "039-kinetic-gas"? I'll go with folder 039-kinetic-theatre — no, spelling "theater"? Existing "PyroSymphony" used "theatre" in description only. Simple and clear: 039-ideal-gas with title "Ideal Gas — Maxwell's Demon Lab"? Folder name should be short slug: "039-kinetic-theory". Title: "Kinetic Theory". Description covers MB distribution, demon, piston, effusion, Brownian.

Hmm, wait. Let me reconsider making the headline feature Maxwell's demon since it's the most delightful: folder "039-maxwells-demon". But the demo covers more than demon. "Kinetic Theory" is the umbrella. Go with 039-kinetic-theory, title "Kinetic Theory — an Ideal-Gas Laboratory".

Let me check the recent demos' code patterns to reuse the grade shader, audio scaffolding, quality tiers, snapshot. Read 038-sandpile index.html quickly for structure (or 031-galton which also has custom physics + histogram + log). 031-galton-cascade is closest structurally: custom 2D physics, spatial hash, histogram, log, presets. Let me view key parts of it to match conventions (sizes may be big ~100KB; read in chunks).

*******************************************************************************************************************************************************************************38.

I have the patterns. Now let me design and write demo 039: "Kinetic Theory — an ideal-gas laboratory with Maxwell's demon".

Let me now carefully design the architecture:

Physics core (pure JS, testable in Node)

A GasSim class:

State:

• N particles: Float32Array px, py, pz, vx, vy, vz; Float32Array mass, radius (per particle); species id (0 light, 1 heavy);
• Box: half extents (hx, hy, hz). Optionally partition at x=0 with opening rules. Piston: wall at x = pistonX (right wall movable) with velocity pistonV.
• Parameters: gravity g (0 default), thermostat target temperature (or null), time scale.

Step(dt):

1. Apply gravity to velocities: vy -= g*dt.
2. Integrate positions: p += v*dt.
3. Piston dynamics: piston has position X, velocity V, mass Mp, area A. Force from pressure: compute momentum delivered to piston during collisions. Piston moves: X += Vdt. If "piston locked", V=0, X fixed. Gas pressure pushes piston out; external pressure/force (spring or constant force) pushes in. For adiabatic oscillation, use spring + damping? For an ideal gas spring, the restoring "force" is the pressure itself when displaced from equilibrium; add a constant external force F_ext balancing at some volume. Piston equation: MpdV/dt = P_gasA − F_ext − cV (small damping to settle).
4. Wall collisions (including moving piston on right side when piston mode active — the right wall becomes the piston face at X, moving with velocity V).
5. Partition logic at x=0 (when active): treat as wall unless within opening (door/hole radius rd) — then crossing rules per mode:
   • 'wall': always blocked.
   • 'open': free pass.
   • 'hole' (effusion): free pass within radius; optionally pump (particles reaching x > some bound get collected).
   • 'demon': within door radius: allow fast (|v| > vth) to pass left→right only, slow (|v| ≤ vth) right→left only. Classic Maxwell demon sorting.
6. Sphere-sphere collisions via spatial hash:
   • Build hash: cell = floor(p / cell). cell size = 2maxR1.1.
   • For each pair (i<j) within neighboring cells, if dist < ri+rj: resolve: positional push apart + elastic impulse with masses.
   • Count collisions for audio/stats.
7. Thermostat (if enabled): after step, gentle velocity rescale: factor = sqrt(1 + λ(Ttarget/Tmeas − 1)) with λ small (e.g., 0.05 per step), or Berendsen.
8. Accumulate wall momentum transfers for pressure: each wall hit adds |Δp| to accum; P = accum/(A*dt_window). Track per-wall to separate piston pressure.

Brownian particle: just a big particle with radius ~2.5, mass ~30× typical — handled naturally by same collision code. Record its trail.

Measurements:

• Temperature per species & global: T = (2/(3 k_B)) ⟨KE⟩ with k_B=1 → T = 2*⟨ke⟩/3 where ke = ½mv². For global include all.
• Mean speed, rms speed.
• MB pdf overlay: f(v) = 4π (m/(2πT))^1.5 v² exp(−m v²/(2T)).
• Histogram: bins over v from 0 to vmax_hist.
• Pressure from wall momentum.
• pV diagram data: P_piston vs V = pistonX − leftWall... box from −hx to X.

Distribution of species: species 0 (light, m=1), species 1 (heavy, m=8? or 4?). For effusion isotope separation use m ratio 4 or 8 (e.g., 235 vs 238 U is only 1.3% difference — unrealistic; use ratio like 4 "helium vs xenon-ish"). Speeds ratio sqrt(8)≈2.8.

Units: box 60×36×36? Let's define half extents hx=30, hy=18, hz=18 (world units). Particle radius light 0.55, heavy 0.8 (mass 8 → radius scale m^(1/3)0.55 ≈ 1.1 — use density same: r = 0.55m^(1/3) → heavy r=1.1). N default ~ 900 light; heavy mixture 450+113? Let's just do N slider 200–2000 with mixture ratio.

Initial condition: positions random in allowed chamber(s) avoiding overlap loosely (just random; overlaps resolved by positional correction quickly), velocities from MB at T0 (Gaussian components).

Demon threshold vth: use mean speed per... classic: compare particle speed to current mean speed ⟨v⟩. fast = v > ⟨v⟩. Door radius ~3 units.

Effusion: hole radius ~2.2; particles passing to right chamber stay there; "Pump" button removes all in right chamber (count as collected); enrichment meter: (fraction light in B) vs (fraction light in A).

Presets: 0. Equilibrium — single light gas, thermostat on, box full. Histogram + MB curve.

1. Equipartition — 2 species mixed, thermostat on. Show ⟨KE⟩ light vs heavy bars equal; speeds differ.
2. Brownian — light gas + 1 big gold sphere (m=60, r=2.6), thermostat on; trail.
3. Piston — gas in left region bounded by piston on right; thermostat OFF; spring-less piston with external force; slider for external force/weight; release & watch adiabatic oscillation; pV diagram.
4. Free expansion — partition initially closed with gas all on left; "Remove partition" → Joule expansion; thermostat off; T stays constant (readout proves it); entropy log.
5. Maxwell's demon — partition with demon door; starts homogeneous; demon sorts; TL, TR gauges diverge.
6. Effusion — mixture in left; hole in partition; right chamber evacuated; light species effuses faster; enrichment meter; pump button.

Modes share one sim; preset sets flags: partition mode ('wall','open','demon','hole'), piston enabled, species mix, thermostat on/off, gravity.

UI Layout (consistent with earlier demos but fresh styling — maybe teal/cyan accent "cryo lab"):

• HUD top-left: title "KINETIC THEORY" subtitle "an ideal-gas laboratory".
• Stats panel top-right: T, P, N, ⟨v⟩, v_rms, meanKE; mode-specific extras (TL/TR, enrichment, pV).
• Histogram canvas panel bottom-right (live chart) + pV mini canvas in piston mode (same canvas switches mode? better: two stacked small canvases; second visible only in piston/demon/effusion presets showing relevant gauge). Simpler: one chart canvas that shows: speed distribution (always), and a second canvas "chartB" contextual: pV trace (piston), TL/TR bars (demon), enrichment bars (effusion), equipartition KE bars (mixture). I'll render contextual chart B.
• Log panel bottom-left (last 4 events, fading).
• Controls bottom-center: preset chips (7), sliders: Temperature (thermostat), Particles, Time, (contextual: piston force slider visible in piston preset; gravity slider), buttons: Partition/Demon toggle contextual action button ("Remove partition" / "Engage demon" / "Pump chamber" / "Release piston"), Sound, Snapshot, Help, trails toggle?

Actually keep controls manageable: presets row; sliders row (Thermostat T, Count, Time scale, Gravity); actions row (action button contextual, Stir (randomize kicks), Sound, Snap, Help).

Rendering:

• InstancedMesh of spheres, count up to 2200. Custom ShaderMaterial: color from speed via colormap; emissive intensity ∝ speed; motion smear: stretch along velocity direction in view? True smear along velocity in world then billboarded? Simpler: scale sphere along velocity axis: build per-instance matrix each frame? 2000 matrix updates per frame is fine (CPU ~ cheap). But custom shader color per instance via InstancedBufferAttribute (aSpeed updated per frame — 2000 floats, trivial).
  • For smear, need per-instance orientation quaternion aligned to velocity + stretch factor — computing quaternion per particle per frame on CPU: fine (2000). But simpler: pass aVel (vec3) as instanced attribute, do stretch in vertex shader: pos' = pos + dir * (dot(pos, dir)) * (stretch−1) where dir = normalize(vel), stretch = 1 + min(|v|*k, maxStretch). This stretches the unit sphere along velocity — easy in shader, no CPU quaternion.
  • Sphere geometry with normals: after stretching, recompute approximate normal — skip exact; lighting is mostly emissive + fresnel so fine.
• Glass chamber: box with custom shader — fresnel edges + faint grid lines on walls (shader-based grid, glowing edges). Back/left/right/bottom walls; plus front wall very faint (see-through). Use additive-ish translucent material, depthWrite false, render order after particles. Edge glow: bright frame edges (use box wireframe? better: shader computes proximity to box edges per-fragment via local position → glow lines). Nice: a single BoxGeometry with shader that draws panel grid + edge glow + fresnel sheen. Draw inside faces too (side: DoubleSide).
• Partition slab: translucent plane at x=0 with shader showing door/hole ring glow (circle at center with radius rd, glowing ring), slides down/up when toggled (animate y offset / opacity).
• Piston: metallic plate with emissive rim + connecting rod extending to right out of box; moves with piston X.
• Floor: dark reflective-ish plane with radial grid + fog; subtle.
• Dust motes: small particle field drifting (like prior demos) — 300 points with shader twinkle. Cheap ambience.
• Lighting: scene ambient + 2-3 point lights? Particles are emissive; chamber glows; bloom does the rest. Use Environment? Not needed for custom shaders; piston standard material uses env from RoomEnvironment for nice metal.
• Brownian particle: separate mesh (sphere, gold, high emissive) + ribbon trail (THREE.Line with 400 points, additive, updated per frame, positions shift buffer).
• Post: EffectComposer: RenderPass → UnrealBloomPass (strength ~0.9, radius 0.6, threshold 0.15) → gradePass (chromatic aberration + vignette + grain) → OutputPass.

Camera: OrbitControls, damping, min/max distance, auto slight drift? Keep user-controlled with gentle idle auto-rotate that disables on interaction (like previous demos maybe). I'll add autoRotate slow when idle 20s? Keep simple: autoRotate on until first interaction.

Audio (generative WebAudio):

• Master → compressor → destination.
• Ambient pad: 2 detuned oscillators (sawtooth → lowpass) whose filter cutoff & gain track temperature; very quiet.
• Collision hiss: collision rate controls gain of filtered noise burst train — implement as: schedule tiny noise ticks with probability ∝ collisions in last 100ms, bandpass freq ∝ mean speed (pitch rises with T). Throttle max ~24 ticks/s, random pan. These sound like gentle rain/hail in a box — lovely.
• Wall/piston thump on big piston hits: low thud when piston reverses or heavy impacts.
• Demon door blips: fast pass = rising blip (880→1320), slow pass = falling blip (440→220), quiet.
• Partition remove: whoosh (filtered noise sweep).
• Effusion: tink when particle passes hole? Too many; do soft tinkle at low rate tied to flux.
• UI click sounds? Prior demos didn't bother much. Skip.

Snapshot: render then toDataURL, download link (preserveDrawingBuffer false — must render immediately before capture; do composer.render() then canvas.toDataURL in same frame).

Keyboard: 1-7 presets, T thermostat off/on? Keys: Space = contextual action, R = stir/reset velocities to T, G = gravity toggle?, M mute, S snapshot, H help, F fullscreen maybe. C = camera reset.

Quality tiers: low (N cap 700, no bloom, pr 1), med (N 1200, bloom, pr 1.5), high (N 2000, bloom, pr 2). Auto-adapt on fps. Changing N resamples particles preserving T.

Now physics implementation specifics to get right:

Substep: dtFrame = min(1/30, real dt) * timeScale (0.25–2). Then sim dt split into substeps: nSub = clamp(ceil(maxVdtFrame/(0.35rMin)), 1, 8)? Simpler: fixed substep h = 0.008 * (20/ (20)) ... Let me compute: T=1, m=1 → v_rms = sqrt(3) ≈ 1.73; mean ~1.6. Max |v| maybe 6. With h=0.01, movement 0.06 << r=0.55. At T=8 (slider up to maybe 6), v_rms ~4.9, hot tail 15 → move 0.15 per h=0.01 — still < r. Use h = 0.008 base; nSub = round(dtFrame/h) capped at 20 (if timeScale=2, dtFrame=0.066 → 8 substeps; fine). Collision detection cost: N=2000, hash neighbors small (gas dilute) → each substep ~2000 * ~4 candidates = 8k checks × 8 substeps = 64k distance checks/frame — fine.

Spatial hash implementation: Map<int, array>? Avoid GC: use flat arrays with counting sort style bucketing each substep. Implement efficient:

• cellSize = 2.2 * rMax (rMax = max radius incl. brownian big sphere... big sphere messes cell size; handle big sphere separately: check big sphere against all nearby via same hash using conservative query radius — query cells overlapped by AABB of big particle. OK.)
• Use approach: compute cellId per particle (ix + 64iy + 4096iz with offset), then sort indices by cellId (counting sort via Map of head/next linked list). Use head/next arrays sized with table 2^12 with hash of cell coords: head = Int32Array(4096).fill(-1); next = Int32Array(N); for each particle: h = hash(ix,iy,iz)&4095; next[i]=head[h]; head[h]=i. Then for pair checks: for each particle i, for each of 27 neighbor cells, walk linked list. But hash collisions cause false pair candidates (fine — distance check filters) and duplicated pairs (i,j twice) — handle by only processing j>i when same cell, and for neighbor cells process all j (each unordered pair found once if we iterate 13 forward neighbors + same cell j>i trick). Standard: 13 half-neighborhood + own cell with j>i.

Positions can be negative: offset by +100 before floor.

Big brownian sphere: include in hash (its cell from center), but its radius large: pairs detected only if cell size ≥ sum radii/… cell size must be ≥ rMax2 where rMax = biggest radius, else misses. Set cellSize = 2.05 * rMax (rMax includes brownian 2.6 → cell 5.3; light particles then have big cells → more candidates: box 60/5.3 ≈ 11×7×7 ≈ 540 cells, 2000 particles → ~4/cell, 27 cells ~ 100 candidates/particle — heavy-ish but ok (200k checks/substep... at 8 substeps = 1.6M — borderline but JS can do it; brownian preset can also reduce default N to 800). Alternatively two-tier hash. Keep simple: cellSize = 2.05rMax, and brownian preset N=700. Fine.

Also heavy particles r=1.1: normal presets cellSize=2.3 → 60/2.3=26×16×16=6.6k cells, 2000 particles → mostly 0-1 per cell. Great.

Collision resolve:

Walls: for each particle: if x < -hx + r → x = -hx+r; if vx<0: wallMom[left] += 2m|vx|; vx = -vx. Similarly others; piston right wall at X with velocity V: if x > X - r && vx > V: vx' = 2V - vx; momentum += 2m(vx - V)... careful: Δp = m(vx' − vx) = m(2V − 2vx) = 2m(V−vx) (negative if vx>V; magnitude 2m(vx−V)); delivered to piston: +2m(vx−V) in +x. Piston force = momToPiston/dt.

Partition at x=0 (thin): particle crossing plane within substep: check sign change of x or proximity |x|<r:

• If partition active: if (x_i − r < 0 && x_i + r > 0) i.e., overlapping plane:
  • within opening? dist yz = sqrt(y²+z²) < rd (door center at y=0,z=0 — maybe center door at y=0,z=0 with radius rd). Door offset: keep centered, fine.
  • If not within opening → treat as wall: push out to side it came from (sign of x or vx), reflect vx (partition static). Add to pressure accum? Partition internal; skip pressure or track separately (not needed).
  • If within opening:
    • mode 'open'/'hole': pass freely (no reflection).
    • mode 'demon': decide: fast (|v| > vThreshold): allow only if moving +x (vx>0). slow: allow only if vx<0. Else reflect (as wall). Count passes.
  • Careful with particle straddling the plane and oscillating: after decision, nudge position out: if blocked, set x = sign* (r+ε) with sign = side it should stay (for wall: side of previous position or −sign(vx)?). Use: if blocked, side = (x >= 0 ? +1 : −1)?? If the particle center crossed to other side but blocked, we must push it back to its origin side: track prevX per substep before integrate. Store xPrev; side = sign(xPrev). Set x = side*(r+1e-3); vx = −vx if vx points across (vx*side < 0).
  • For demon passes, add blip + counters.

Piston thermodynamics check: force balance: piston at X, gas left of it (box left wall −hx). External force F_ext pushing −x (like weight). Mp dV/dt = F_gas − F_ext − c V. F_gas = momToPiston/(substep time). Update V each substep: V += (F_gas_inst? noisy) — better accumulate momentum over frame then update V once per frame: F_avg = momToPistonFrame/dtFrame; V += (F_avg − F_ext − cV)/Mp * dtFrame; clamp X ∈ [Xmin, hxMax−2]. Xmin = −hx+6 minimal gas length. When "locked" (default in piston preset until user releases?), keep V=0. Provide "Release" toggle: locked/unlocked. Also piston slider sets F_ext (weights). Equilibrium: F_ext = P*A → oscillation around it. Damping small c to eventually settle but show oscillations (c tiny; maybe user-toggle damping). Adiabatic: during compression T rises — thermostat OFF in this preset; show pV diagram; compute γ estimate? Just show loop.

Actually also give piston preset "heat/cool" control? The T slider becomes "external force" contextual? Simpler: keep thermostat slider visible but thermostat disabled in piston preset? Hmm — nice feature: allow heating the gas (thermostat) while piston free → piston pushed out (Charles's law!). That's beautiful: heat → expansion at ~constant pressure. So keep thermostat available in piston preset too (toggle "Thermostat: on/off" button; default on? If on, oscillations damp by thermostat rescale? Thermostat rescales velocities gently — fine.) Default: thermostat ON at T0; user can turn off to see pure adiabatic. Good — a global "Thermostat" toggle chip + T slider.

Free expansion preset: partition closed; all gas left; thermostat off; action "Remove partition" → mode 'open' → gas floods right; T stays ~constant (log: "Joule expansion: T unchanged — ideal gas has no intermolecular forces"). Reinsert partition? Action toggles insert/remove; when reinserted, gas split ~half.

Demon preset: partition with door; gas homogeneous; demon ON from start; action toggles demon on/off (off = door open freely → re-equilibration). TL/TR computed from particles in each half; gauges.

Effusion preset: partition with small hole; mixture left only; right empty; pump button; counts/enrichment.

Gravity slider: 0..30; with thermostat on; log barometric note when >0. Fine in any preset (fun in equilibrium: sedimentation; heavy species layers lower — barometric separation! nice with mixture).

"Stir" action: randomize velocities from MB at current T slider (instant thermalize).

Charts (canvas 2D, ~200×120):

• Chart A (always): speed histogram + MB curve (per species two curves when mixture). Draw measured v_rms marker line. Label axes minimal: "speed distribution f(v)".
• Chart B contextual:
  • piston: pV trace (P vs V) with fading trail (store last 600 samples, draw polyline + current point), axes labels P, V. Show γ note? just visual.
  • demon: two horizontal bars TL, TR with values; line "ΔT".
  • effusion: bars: N_left light/heavy vs collected right; enrichment ratio text.
  • equipartition: two bars ⟨KE⟩ light vs heavy (should match) + mean speeds ratio vs √(m2/m1) theory.
  • brownian: MSD? Draw trail length / ⟨step⟩? Show bar chart of kinetic energy of big sphere vs theory 3/2 T (equipartition of the big one!) — nice: bar "KE_pollen" vs "(3/2)kT" line.
  • equilibrium: show pressure gauge bar vs ideal prediction NkT/V ratio (P_measured / P_ideal ≈ 1).

Log panel: last ~5 messages with timestamps, fading opacity.

Toast on preset change (like galton): preset name + blurb.

Toast/toasts, help overlay with keyboard table, flash element for snapshot.

Numbers formatting: 2-3 sig figs.

Let me also include subtle "thermostat glow": when thermostat active, chamber edges tint toward set temperature color (blue cold → red hot) — communicates heat bath.

Particle color map by speed: normalize v by v_ref = sqrt(3T_display) (use measured T smoothed): t = clamp(v / (2.2*v_rms)) → gradient deep blue (#1a2bff) → cyan → white → orange → red. I'll implement colormap in shader: mix stops. Heavy species: same map (their speeds lower → appear bluer — exactly the physics! At same T heavy move slower: blue vs red — great visual for equipartition: heavy blue, light red, same KE).

Wait — that's a subtle but powerful visual: color by speed shows equipartition (colors differ) while KE bars show equality. Also add color-by-KE toggle? Maybe color mode toggle: "color: speed / energy / species". Nice little chip. Energy mode: same T → same color for both species (visually proves equipartition!). Species mode: light=cyan, heavy=magenta fixed. Great teaching tool. Include toggle (keyboard C? use K or V; C reserved camera reset — use V for color mode).

Rendering per-instance attributes: aSpeed float (normalized 0..1 already computed CPU-side according to color mode), aVel vec3 (for smear). Update each frame (2000×4 floats — fine).

InstancedMesh with custom ShaderMaterial + instanceMatrix: per-frame setMatrixAt for 2000 instances = 2000 matrix compositions (~fine, galton did similar with 880). To be faster, use InstancedBufferAttribute aPos vec3 + scale in shader instead of matrix — avoid CPU matrix math: geometry unit sphere; instance position from aPos attribute; scale = aRad attribute (float) with smear along aVel. Then no instanceMatrix updates at all — just aPos (vec3), aRad, aVel(vec3), aCol(float). All InstancedBufferAttributes updated each frame (2000×10 floats ≈ 80KB/frame upload — fine). Use **************************try with sphere geometry attributes copied. Or InstancedMesh with onBeforeCompile… simplest: InstancedBufferGeometry + RawShaderMaterial? Use ShaderMaterial with built-ins. I'll construct InstancedBufferGeometry from IcosahedronGeometry(1, 2) — 162 verts? detail 2 = 320 faces — nice enough; ×2000 = 640k tris... hmm heavy. detail 1 (80 faces) = 160k tris OK; bloom + fresnel hides low poly; use detail 1 for high tier, detail 0 (20 faces) too crude. Actually 2000×80=160k tris fine for GPU. Low tier N=700 → 56k. OK detail 1. Or use capsule-ish? Keep icosahedron detail 1.

Sphere shading: normal from geometry; stretch modifies — acceptable.

Shader for particles:

fragment: base color colormap(aT) * (ambient + diffuse from a key light dir) + fresnel rim * tint + emissive = color * (0.35 + heat glow aT^2 * 1.5). Output vec4(col,1). Colormap GLSL: piecewise mix of 5 stops.

Box chamber shader: BoxGeometry(2hx,2hy,2hz), BackSide? We want inside visible faintly + front faint: DoubleSide, transparent, additive-ish. Fragment: compute grid from local coords: lines every g=6 units on the walls: depending on which face (use normal to pick plane coords). Edge glow: distance to nearest box edge < e → bright line. Fresnel: pow(1-|dot(n,view)|,3) sheen. Also temperature tint uniform uTint. Alpha low ~0.08 + lines 0.25 + edges 0.6. depthWrite false.

Edges could also be LineSegments of EdgesGeometry with additive LineBasicMaterial — simpler and crisper: do both: box shader (panels+grid) + edges lines bright. And corner nodes (small spheres) maybe. Keep: box shader + EdgesGeometry lines.

Partition mesh: PlaneGeometry(2hy, 2hz) rotated; shader: radial ring at door (center (0,0) in yz): ring glow at r=rd, fill translucent; when open, animate slide down (position.y → −2hy−1, opacity→0). Demon mode: ring color cyan(magenta?) pulsing; hole: orange ring.

Piston: Box thin (0.8 thick) sized 2hy×2hz, MeshStandardMaterial metalness .9 roughness .35 + emissive rim via extra edge lines; plus rod cylinder to the right exiting box wall through a sleeve; position.x = pistonX + 0.4. When piston preset inactive, hide (or park at right wall). Simplest: piston exists only in piston preset; on switch, hide and right wall returns to hx.

Brownian sphere: Mesh sphere r 2.6 gold emissive + fresnel shader similar style; trail: THREE.Line with BufferGeometry 600 positions updated ring-buffer; additive LineBasicMaterial color gold transparent 0.5. Trail only in brownian preset.

Dust motes: Points 250, shader twinkle, drift via time uniform. (Optional cheap ambience; previous demos all have it.)

Floor: big circle mesh with shader: radial fade + grid rings? Use simple dark plane + fog; scene.fog = FogExp2(0x05070d, 0.011). Camera default pos (0, 26, 64) looking at origin-ish (0, 0, 0). Controls target (0,0,0), minDistance 30 maxDistance 160, maxPolarAngle 1.45.

Lights: not needed for custom shaders except piston (MeshStandard) → add DirectionalLight + ambient + RoomEnvironment for reflections. RoomEnvironment import for env map. PMREMGenerator.

Bloom threshold: particles emissive bright (up to 2-3) → bloom picks them; keep box dim.

Audio graph: as planned; collision ticks from sim collision counter per 100ms window: n = collisionsLastWindow; schedule min(n/4, 20) ticks over next window at random times, each: bandpass freq 1500+4000rand(T factor), gain 0.02..0.06, decay 30ms. Piston impacts: if piston momentum reversal big → thump (sine 70Hz decay). Demon blips. Whoosh for partition. Pad: two saws detuned ±4 cents through lowpass 200+300T_smooth Hz, gain 0.035. Also subtle hum at 50+T8 Hz? Keep pad only.

Snapshot: composer.render() then toDataURL.

Quality adaptation: same pattern as galton (fpsAcc 2.5s windows; drop tier <46, raise >58 sustained).

Tier application: set pixelRatio cap, bloom enabled flag, particle cap → resample N (rebuild arrays preserving species ratio; keep velocities scale to keep T).

Preset switching: rebuild gas state:

• equilibrium: N=sliderN light, full box, no partition, thermostat on.
• mixture: 70% light / 30% heavy.
• brownian: N=650 light + 1 pollen.
• piston: N light full box; piston enabled at X=hx*0.55... Actually gas should fill region left of piston: piston starts at X=12 (hx=30), particles initialized in [−hx, X−r]. F_ext set so equilibrium ≈ initial P. User adjusts weights slider (F_ext) → piston moves.
• expansion: partition wall, gas left half only (x∈[−hx, −r]).
• demon: partition + door, gas both halves (full box).
• effusion: partition + hole, mixture left only, right empty, pump.

Gravity slider applies always (except maybe warn in piston? fine).

Contextual action button label per preset:

• piston: "Piston: Locked/Free" toggle; second contextual: "− Weight / + Weight" via slider (weights slider contextual shown only in piston preset).
• expansion: "Remove/Reinsert partition".
• demon: "Demon: On/Off".
• effusion: "Pump right chamber".
• brownian: "Re-center pollen".
• mixture: "Re-mix".
• equilibrium: "Stir (re-thermalize)". Space triggers this action. Also global "Stir" via R.

Slider row: Thermostat T (0.2..8, default 1), Count (200..2000 step 50, default 1000 or per tier), Time (0.25..2, default 1), Gravity (0..30, default 0). Contextual Weight slider appears in piston mode (replace gravity slot? just show/hide).

Thermostat toggle chip: "Bath: On/Off" (default On except free-expansion preset default Off). Hmm — demon preset with thermostat ON would fight the demon's temperature gradient (thermostat global rescale ruins TL/TR split). So demon preset: thermostat OFF default (insulated box — correct physics! total E conserved, demon just redistributes). Effusion: thermostat ON to keep left chamber at T (fine). Expansion: OFF (to show T const). Piston: ON (isothermal default; turn off for adiabatic). Brownian: ON. So presets set bath on/off defaults; user can toggle.

Entropy meter? Could show S estimate via phase-space? Too much; skip — log mentions entropy qualitatively.

Now, chart B for equilibrium: P gauge vs ideal. Let me instead always show in stats: T, P, N, v_rms, ⟨KE⟩; chart A histogram; chart B contextual.

Effusion enrichment metric: ratio (light fraction in collected) / (light fraction in source). Theory ≈ sqrt(m2/m1) ≈ 2.83 for first dN. Show "enrichment ×2.8 theory" vs measured rolling (flux-weighted): measure flux of each species through hole over last window: enrichment = (fluxL/fluxH)/(NL/NH). Show measured rolling value.

Demon metrics: TL, TR, passes count, note "demon exorcised by thermodynamics: door + memory must dissipate (Landauer)" — nice log flavor line.

I think I also want a subtle but cool extra: velocity-space mini view? skip — enough scope.

Deliverable size: aiming ~55-70KB single file. Must also write headless Node test of physics: extract sim into the HTML but structured so I can copy the core into a node test file quickly. I'll write the core physics as a standalone class in the module (no THREE dependency), then in test: replicate by reading the file? Simpler: write the sim class in a and ALSO create a small node test that re-implements? No — best: put physics class in a separate ? For single-file requirement, keep all in one file; for testing, I'll write the physics core as a string-shared approach: actually simplest is to write the physics in the HTML, then for the test, extract the class source from the HTML via regex in a node script and eval it, run conservation tests. That's clean: the test script reads /space/demos/039-kinetic-theory/index.html, extracts between markers /* PHYSICS CORE START */ ... /* PHYSICS CORE END */, evals, runs tests:

1. Energy conservation in isolated box (no thermostat, no gravity): KE const within tolerance over 30s sim.
2. Momentum conservation.
3. MB convergence: mean |v| matches sqrt(8T/πm) within few %.
4. Piston adiabatic: compress slowly → TV^(γ−1) const-ish; or pressure vs volume pV^γ const. Test: pV = NkT relation PV/(NT) ≈ 1 within 5%.
5. Demon: TL drops, TR rises, total E const.
6. Effusion: light/heavy flux ratio > 1.
7. Equipartition: mean KE light ≈ mean KE heavy within tolerance.
8. Wall containment: no NaN, all particles inside box + margin.

Run with N=300, T=1, dt small, e.g., 3000 steps. Fast.

Let me now also double-check three@0.170.0 module URLs work (used by galton — fine).

One more consideration: name & folder. Folder: /space/demos/039-kinetic-theory/. Title: "Kinetic Theory — The Ideal-Gas Laboratory". Hmm, previous titles like "Wavefunction ψ", "Cloud Chamber". "Kinetic Theory" good. Or "Maxwell's Demon"? The demon preset is the most novel. But umbrella demo... Title: "Kinetic Theory", subtitle "a maxwell's demon laboratory".

Accent color scheme: cryo-cyan/teal (#5ee3ff) with hot orange (#ff8a3c) secondary — matches cold/hot duality. Panel dark navy.

Now write the code. I'll be careful about:

• GLSL syntax correctness.
• No unused varying mismatches.
• InstancedBufferGeometry index copy.
• addUpdateRange not needed (full upload fine).
• THREE r170: outputColorSpace default; UnrealBloom + OutputPass as in galton.

Performance of stats DOM updates: throttle to 4Hz.

Let me write the whole file now. Structure:

1. HTML head + CSS (panels: hud, stats, charts, log, controls, help, toast, flash).
2. Body divs.
3. importmap.
4. module script:
   • imports
   • config constants
   • PHYSICS CORE (GasSim class) with markers
   • renderer/scene/camera/controls setup
   • environment: floor, chamber box + edges, partition, piston, dust, pollen + trail
   • particle instancing + shaders
   • bloom composer + grade pass
   • audio engine
   • charts (2D canvas)
   • UI wiring (presets, sliders, buttons, keys)
   • quality tiers + adaptation
   • main loop: step sim (substeps), update attributes, stats, charts, audio cues, render
   • snapshot, resize

Physics details for piston force on gas: piston only on right wall in piston preset; left wall −hx fixed. Also when piston preset off, piston hidden.

Also free expansion: initial particles left half; ensure partition reflection robust.

The demon door radius 3.2; effusion hole radius 2.0; located at center y=0,z=0.

Partition reflection epsilon handling: after reflect, set x = side*(r+0.02).

Pressure measurement: accumulate over window 0.5s: momWalls (6 walls incl piston separately), P = mom/(Adt) where A = total wall area (or per piston for pV: use piston momentum & piston area = (2hy)(2hz)). For equilibrium chart: P_total = momAll/(Atotaldt), P_ideal = N*T/V. Display ratio.

Volume for pV: V = (X + hx) * (2hy) * (2hz).

Piston numbers: A_face = 2hy2hz = 3636=1296. N=1000, T=1 → P = N T / V, V at X=12: (42)1296 = 54,432 → P ≈ 0.0184. F = PA ≈ 23.8. So weights slider F_ext ∈ [5..80], default 24. Mp = 400 (slow, stately oscillation). Damping c = 8. ω = sqrt(γ P A /(Mp L))... will be slow ~0.5 rad/s — visible. Good.

Wait — with thermostat ON, oscillations are isothermal (γ=1). Adiabatic γ=5/3 monatomic. Fine.

Piston motion per frame: gather momToPistonFrame; F_gas = mom/dtFrame; a = (F_gas − F_ext − c V)/Mp; V += a dtFrame; X += V dtFrame; clamp; if clamped, V=0.

But gas collisions with moving wall during substeps use current piston X & V (V const within frame — fine).

Locked piston: V=0, X fixed at slider value? Give "position" only via dynamics; locked = pin current X. Unlock → dynamics. Initial: locked at X=12.

Stir (R): re-randomize velocities Gaussian σ=sqrt(T/m) per species, zero net momentum? keep simple.

Count slider: rebuild particles preserving current species distribution & T.

Thermostat: per frame: T_meas; if bath on and T_meas>1e-6: scale = sqrt(1 + k*(T_target/T_meas − 1)), k = min(1, 2.5*dtFrame) → gentle (τ≈0.4s). Applied to all velocities (also pollen? yes).

Gravity: vy accum; with bath on, equilibrates to barometric; fine.

Histogram: 48 bins, v range 0..vmaxHist = max(4*sqrt(3Tt), 6). Update every 0.25s from current snapshot (not time-averaged — N=1000 gives decent stats; add temporal smoothing α=0.5 for stability).

MB overlay per species: f(v) = 4π (m/(2πT))^1.5 v² e^{−m v²/(2T)}; normalized so pdf over v. For mixture overlay both weighted by species fraction... draw both curves scaled by their counts fraction; combined = sum. Draw combined white + species curves colored faint.

Chart drawing with devicePixelRatio aware canvas.

Log: array of {t, msg}; render as divs with fade after 6s.

Toast preset info.

Presets list with name + blurb: 0 Equilibrium — "one gas, one temperature — the Maxwell–Boltzmann law" 1 Equipartition — "light & heavy share energy, not speed" 2 Brownian — "a pollen grain kicked by the invisible" 3 Piston — "heat, work and the gas spring" 4 Free expansion — "Joule's expansion: entropy up, temperature flat" 5 Maxwell's demon — "a sorting imp challenges the second law" 6 Effusion — "light isotopes slip the hole first"

Blurb on toast.

Now the contextual chart B content per preset: 0: Pressure: measured vs ideal bar. 1: KE per species bars + speed ratio measured vs √8. 2: KE_pollen vs 1.5T bar + |v| pollen? Bar. 3: pV trace. 4: T over time trace (should stay flat) — draw time series T(t) last 30s + N_right fraction rising. Two series. 5: TL/TR bars + trace of ΔT over time? bars + passes count. 6: enrichment: rolling enrichment measured vs theory bar.

Nice.

Colors: accent cyan #67e8f9-ish; hot #ff9a5c; light species #6fe3ff, heavy #ff7ad9 (magenta) for species mode.

Now audio implementation sketch:

Master gain 0.9, compressor. Mute toggle M / button.

Snapshot S / button. Help H / ? overlay. Fullscreen F.

Camera: FOV 55, pos (8, 22, 68), target (0,2,0)? box center at origin: box spans x∈[-30,30], y∈[-18,18] — put floor at y=-18-? Box sits on floor: shift whole rig so floor at y=-19? Simpler: keep box centered at origin, floor plane at y=-19.5, camera (0, 20, 66). Controls target (0,0,0).

Also add a very subtle pedestal/base ring? skip.

Edges: 12 edges of box as LineSegments additive cyan 0.7 — with bloom they'll glow.

Extra flourish: temperature-reactive edge color: lerp cyan→orange with T.

Pollen trail: use Line with 500 points; update every frame shifting array (Float32Array copyWithin) — 500*3 copy fine.

Dust motes: 240 points in big sphere volume, PointsMaterial with additive, size 0.35, opacity 0.35, drift via per-frame rotation of the points object (rotate slowly) — cheap.

Scene bg: #04060c; fog exp2 0.0085.

Now — write it. I'll write the file in one go with a heredoc via write tool (read_write_file_in_shell_environment write mode). It'll be long (~1500 lines). Then extract & test physics in node. Then update index.html main listing. Then done.

Let me carefully write the physics core first (mentally compile):

Simplify: building methods:

region: 'full' | 'left' (x<0) | 'piston' (x<pistonX-2r).

Velocity init: gaussian via Box-Muller, σ = sqrt(T/m).

step(dt):

Wait — demon counts: fast pass left→right means cold left, hot right. flux counters used by effusion: count species passes through hole (either direction? count net left→right). For effusion preset, hole passes: if px crossing from left to right (pxPrev<0<=px...) hmm within-slab check: if pass && partition=='hole' && side(prev)<0 && px now >0: flux[species]++. Also right→left passes subtract? For enrichment measurement count only L→R arrivals. Then pump recycles them.

For demon: count similarly via pxPrev sign vs new sign.

Position clamp for pollen big sphere vs partition: pollen only exists in brownian preset (partition none) — safe.

Hash pair loop:

Hash table 8192 fine.

resolvePair with masses & radii; positional correction slop 0.001, percent 0.8.

Big pollen radius 2.6 with cell = 2.2rMax: neighbors within 27-cell coverage: distance ≤ rMax+rMin < cell? For two big-adjacent particles... only one pollen, fine. Heavy-heavy: 2.2 vs 1.1+1.1=2.2 borderline: use cell = 2.4rMax? cell bigger → more candidates. rMax in mixed presets = 1.1 → cell 2.64. Two heavies approach: sum 2.2 < cell ok. In brownian rMax=2.6 → cell 6.24; light-light sum 1.1 << cell — candidate flood: box 60×36×36 / 6.24³ ≈ 320 cells; N=650 → ~2/cell → 27 cells ~ 54 candidates — ok.

Substep count: caller computes h such that maxMove < 0.3rMin: estimate vmax = 6sqrt(bathT+... use measured vmax? track vmax each frame cheaply during stats? Use vMaxEst = max over i of |v| sampled every frame (loop over 2000 — cheap). nSub = clamp(ceil(dtFrame * vMaxEst / (0.3*rMin)), 1, 14).

With T=8: v~ sqrt(38)=4.9 rms; tail 15. dtFrame max 1/302=0.0667. 0.066715/(0.30.55)= 6 → fine.

Energy check: elastic collisions conserve exactly (impulse formula), positional correction adds tiny energy; moving piston does work properly; thermostat deliberately changes E.

Stats computed per frame (or 0.25s): T per species, mean speed, v_rms, KE means; T_L/T_R for demon; P from momentum accum windows.

Demon threshold: vThresh = mean speed overall (update 1Hz). Classic demon uses equal temperature split... fine.

Now GLSL colormap (speed):

Emissive boost: col = 0.55 + 1.9t*t.

Color modes: speed: t = v/(2.4vRef) where vRef=sqrt(3T_disp). energy: t = ke/(2.41.5T_disp) → ke/(3.6*T). species: t = sp==0? 0.32 : 0.9 fixed (or distinct hues: pass t=0.35 light cyan / heavy 0.95 pinkish — but colormap at 0.95 is red... species mode should use distinct mapping: I'll pass t and also aMode? Simpler: compute color param CPU side fully as t into same colormap: light → 0.30 (cyan), heavy → 0.85 (orange-red), pollen → 0.55 (white-hot)? pollen gold separate mesh anyway. But species colors better: cyan vs magenta — magenta not in colormap. Alternative: add second tiny branch in shader: uniform uColorMode; if mode==2 use aSp attribute: light = #59d8ff, heavy=#ff6ad5. Add aSp attribute (float). Fine.

Pollen gold mesh: shader fresnel gold.

Piston visuals: standard material + edges lines (LineSegments EdgesGeometry) emissive-ish color; rod cylinder standard dark metal; sleeve ring at right wall. Also faint "glow disk" on piston face when compressed? skip.

Charts canvases: two canvases 220×130 CSS, dpr-scaled.

Also small "temperature color bar" in HUD? skip.

Controls layout: bottom panel rows: row1: preset chips ×7. row2: sliders: Bath T (0.2–8 step .1) | Count | Time | Gravity (+ Weight slider contextual in piston). row3: chips: [Action(dynamic)] [Bath: On/Off] [Color: Speed/Energy/Species] [Sound] [Snapshot] [Help].

Keys: 1-7 presets, Space action, B bath toggle, V color mode, R stir, M mute, S snapshot, H help, C camera reset, F fullscreen, P pump (effusion same as space? fine).

Log lines flavor:

• preset switches.
• thermostat: "thermal bath coupled at T = X" / "bath decoupled — energy now conserved".
• partition: "partition removed — gas expands into vacuum (Joule)" / "reinserted".
• demon: "demon engaged — fast → right, slow → left" / disengaged: "door open — gases re-equilibrate".
• demon milestone: "ΔT exceeds 0.5 — the imp appears to win… but Landauer's principle invoices the memory erasure."
• piston lock/free; "compression: T rose …" log notable when T crosses thresholds? maybe log on action only.
• pump: "right chamber evacuated — counting enriched flux".
• gravity: "gravity on — watch the barometric layering".

Good. Now, also an "auto-director"? skip; enough.

Mobile: hide stats & charts panels under 760px like galton did (display none). Controls wrap.

Edge cases:

• Count slider change mid-piston: rebuild within piston region.
• Preset switch resets accumulators, histogram smoothing, charts, trail, piston state, partition state.
• NaN guard: if any NaN → reinit preset.

Time to write. I'll write the file with the write tool in one shot, then run a syntax check by extracting module JS and running node --check? Node can't parse ESM import from URL but node --check only parses syntax; import statements fine with .mjs. I'll extract the content to /tmp/app.mjs and run node --check. Then a physics test /tmp/test.mjs importing the extracted class (need class exported or eval). Plan: mark physics core with /*=PHYSICS-BEGIN=*/ and /*=PHYSICS-END=*/; test script reads html, slices, wraps with export, writes /tmp/phys.mjs, imports, runs tests. The physics core must not reference THREE — pure JS only. Good.

Also ensure no top-level await issues etc.

Let me write the code now. I'll be meticulous. (This will be a large file ~ let me aim for well-organized ~1400 lines.)

Key subtle GLSL: In vertex shader for instanced buffer geometry, attributes position, normal, plus instanced attributes; use viewMatrix (available in ShaderMaterial), projectionMatrix, normalMatrix (model-view normal; our mesh at identity so fine).

InstancedBufferGeometry: copy index & position/normal from IcosahedronGeometry(1,1). Set instanceCount = n; changing n: geo.instanceCount = n.

aPos update per frame from sim arrays; aRad, aVel; aT (color param); aSp.

For pollen (species 2): include in instanced particles? It's big; render separately to also get nice material; exclude from instanced set: instanced mesh gets only sp<2. Pollen: dedicated mesh positioned from sim arrays (index n-1 by convention). Also exclude pollen from histogram.

For species attribute when count changes rebuild attributes sized maxN once (allocate max 2400, set instanceCount dynamically; attributes fixed size, updateRange full is fine).

Actually updating 2400×(3+3+1+1+1) floats per frame upload even when n=1000 — fine.

Physics loop placement: sim.step handles substeps internally: sim.update(dtFrame) computes nSub and loops; also piston frame-level update inside.

Pressure window: maintain ring: momAccum, timeAccum; every 0.5s compute P = mom/(A*τ) then reset accumulators; smooth with previous.

A_total = 2*( (2hx)(2hy) + (2hx)(2hz) + (2hy)(2hz) ) = 2*(6036 + 6036 + 3636) = 2(2160+2160+1296)=25616=11232. For piston mode: gas volume uses piston face; total wall area slightly different (right wall is piston) — same area. Fine. P_ideal = NT/V, V = 2hx2hy2hz = 77760 (full) — display ratio ~1. With gravity on, ratio shifts slightly — fine, note.

Piston face area 1296; momPiston window similarly → P_piston.

Demon TL/TR: compute per frame cheaply when demon preset: loop partition counts.

Effusion enrichment: flux counters over window: enrich = (fluxL/max(1,fluxH)) / (NL/NH_left). theory sqrt(8)=2.83.

Now the initial velocity Gaussian: Box-Muller:

σ per component = sqrt(T/m). |v| then MB distributed with mean 2σ√(2/π).

Zero total momentum: compute sum v, subtract mean (nice for energy bookkeeping in free expansion/piston). Do it.

Re-thermalize (stir): same.

Overlap at init: random positions may overlap → positional correction resolves within first frames with small energy blip; thermostat smooths. OK. For piston region ensure x < pistonX - r.

Partition init: for expansion: x ∈ [-hx+r, -r-0.05]; demon: full but avoid slab |x|>r+0.05 — just resample while |x| < r+0.05.

Right — door is at center (y=0,z=0), radius 3.2. Door visual: ring on partition shader: ring radius uniform; when hole mode: smaller ring, orange.

Partition shader:

Piston rod: cylinder radius 0.5 from piston face to right wall +2; positioned each frame: length changes → scale cylinder.

I also want a subtle "heat bath" visual: outer glow shell tint — reuse chamber box uniform uTint lerp by bath T (blue→red) when bath on; gray when off.

Camera idle auto-rotate: controls.autoRotate = true speed 0.6; disable on 'start' event, re-enable after 30s idle? Keep: disable on interaction permanently? Prior demos sometimes re-enable. I'll re-enable after 25 s idle.

Flash on snapshot.

OK also gradePass resolution uniform update on resize.

Font/styling: reuse galton-ish CSS but cyan accent: --accent: #6fd3ff; --accent2: #ff9a5c.

Histogram smoothing: smooth[i] = lerp(smooth[i], inst[i], 0.35) each update (4Hz).

Chart A draw: axes, filled histogram bars (light species cyan, heavy magenta stacked? draw side-by-side overlay with globalCompositeOperation 'lighter'), MB curves: light cyan line, heavy magenta line, combined white line, v_rms marker. Legend tiny.

Chart B per preset as planned.

Stats rows: N, T (target/measured), P (meas + ratio ideal), ⟨v⟩, v_rms, mode-specific row (ΔT demon / enrichment effusion / V piston / KE pollen brownian).

Alright — also "Stir" R: thermalize velocities at bathT.

Let me write out the entire HTML now carefully. I'll then syntax-check and physics-test.

One more check — unpkg three@0.170.0 paths used by galton work; copy them.

Also title/meta description.

Writing now. Also remember: side: THREE.DoubleSide on chamber, depthWrite:false, transparent true. Render order: floor(0) < particles(1) < chamber(2) < partition(3) — set explicitly.

Floor: CircleGeometry radius 220 at y=-19.5 rotated -π/2, shader: radial gradient dark blue→black + faint concentric rings + grid dots? Simple: color mix by radius + subtle ring lines. Fog affects it. Use MeshBasicMaterial? Custom tiny shader with fog support complicated — use MeshStandardMaterial? simplest: MeshBasicMaterial color #070a12, plus a ring grid via canvas texture? Keep custom ShaderMaterial WITHOUT fog (fog=false); distant floor fades via radial alpha to bg color — do manual fade in shader to bg color. Good enough.

Dust: PointsMaterial size 0.3, additive, opacity .3, color #88aaff; geometry 260 pts in shell; rotate slowly.

The sim arrays maxN 2400; sliders cap by tier: high 2000, med 1200, low 700.

Now write!

Actually one more physics nuance: thermostat rescale should exclude pollen? Including is fine.

For pV trace: store samples every 0.1s (P_piston smoothed, V). 600 samples ring.

For free-expansion T(t) trace: store last 400 samples at 0.1s of T and Nfrac right.

Demon ΔT: bars + numeric.

Colors of text/UI per species: light #6fd3ff heavy #ff7ad9.

Let me now also think: default preset on load = Equilibrium, bath on T=1, N=1000 (tier high 2000? default slider 1000; tier caps max). Start with toast.

Sim speed slider "Time" multiplies dt.

Alright, writing the file. I'll write in one big write operation. Let me draft the code mentally-section by section, being careful with syntax.

Also add: when bath off and no gravity and piston locked and partition static → total KE should be conserved; show "E drift" in log if >2%? no, tests cover it.

One risk: demon threshold update: vThresh = meanSpeed (update every 0.5s). OK.

Effusion pump: only when preset effusion: "Pump" button toggles pumpRight; when on, particles with px>0 (species<2) get collected & respawned left with thermal velocity at bathT... respawn left at random pos avoiding partition slab. collected counts by species. Note: respawning adds/removes energy; bath keeps T anyway (bath on in effusion). Fine.

Also effusion initial: all particles left. Right chamber vacuum.

For piston preset, ensure partition none, region piston: pistonX default 12, locked=true. Weight slider F_ext 5..80 default 24. When locked: piston ignores forces. Action chip: "Release piston"/"Lock piston". Log PV values on release.

Volume display in stats when piston: V, P_face, T.

Edge case: piston unlocked with bath on → isothermal expansion to equilibrium with F_ext; oscillates with damping; pV loop spirals to point. With bath off → adiabatic, settles at different V; log hint.

Also guard piston min: X >= -hx+8 (gas length ≥ 8); max hx-2.

If piston reaches min/max, V=0 (inelastic stop).

Compressibility check: gas spring stiffness k = γ P A²/(Mp V)... whatever, visuals fine.

Impulse of piston on gas during substeps uses pistonV — when locked, vw=0.

momPiston accumulates 2m(vx−vw) per hit (only when vx>vw).

Piston frame update (only if pistonOn && !locked): F_gas = momPistonWindow/dtWindow? Use instantaneous per-frame: F = momPistonFrame/dtFrame (noisy but okay with Mp big). Smooth: Fsmooth = lerp(Fsmooth, Finst, 0.5). V += ((Fsmooth − Fext − cV)/Mp) dtF; X += V dtF.

Hmm with Mp=400, dt=1/60, F≈24: a≈ small; oscillation period ~ 2π sqrt(Mp L/(γ P A)) ≈ 2π sqrt(40042/(1.40.01812961.4?)) eh fine.

Also piston collisions counted for thump: if single-hit momentum > threshold → thump.

Alright, writing now for real. I'll produce the file, then check.

For the charts, write helper:

Chart update at 4Hz.

Stats DOM ids: stN, stT, stP, stV, stVrms, stKE, stExtra (label+value change per preset), fitVal? no.

Extra row: label span id stExtraK, value id stExtraV.

Log: function log(msg) → prepend div to #logList, cap 5, auto-fade via CSS animation.

Also "spec readout" small line under charts? skip.

Time to write the file.

Order of module script:

1. imports
2. helpers ($, toast, log)
3. CONFIG constants (box dims, colors)
4. PHYSICS CORE markers + GasSim
5. sim instance + preset definitions + state vars
6. three setup: renderer, scene, camera, controls, lights, env
7. floor, chamber, edges, partition, piston, dust, pollen+trail
8. instanced particles
9. postprocessing
10. audio
11. charts
12. UI wiring + keyboard
13. quality tiers
14. resize/snapshot
15. main loop

Let me make sure the physics core is THREE-free and marker-wrapped.

Potential pitfalls to double check after writing:

• IcosahedronGeometry(1,1) has position/normal attributes; copy into InstancedBufferGeometry:

• instanceCount property: geo.instanceCount = n (supported r170) plus geo._maxInstanceCount? Setting instanceCount works.

• ShaderMaterial with InstancedBufferGeometry: must NOT set material.instancing... Instanced rendering auto when geometry.isInstancedBufferGeometry. Yes.

• For bloom: UnrealBloomPass(new THREE.Vector2(w,h), strength, radius, threshold).

• OutputPass handles tone mapping/colorspace; renderer.toneMapping = ACESFilmic? galton likely used default + OutputPass. I'll set renderer.toneMapping = THREE.ACESFilmicToneMapping; toneMappingExposure 1.1; OutputPass applies it.

Colors in shaders will be treated linear; fine.

Audio: create on first pointerdown/keydown (also try on load — browsers block; do lazy init on gesture, plus button).

Snapshot: set flash opacity then fade; download link click.

Now the code. Also include meta description. Let me write.

function gauss(rng) — plain Math.random fine.

I'll now write the complete file content.

Details for charts contextual per preset index:

• 0 equilibrium: bars P_meas vs P_ideal (normalized): draw two bars: measured (cyan) & ideal (white outline) height normalized to ideal. text ratio.
• 1 equipartition: bars: KE_L cyan, KE_H magenta (normalized to 1.5T), and speed ratio measured vs theory text.
• 2 brownian: KE_pollen bar vs 1.5T line; plus mean free jiggle? text of pollen |V|.
• 3 piston: pV trace polyline fading.
• 4 expansion: T(t) line + N_right/N area line.
• 5 demon: TL bar (cyan) TR bar (orange), ΔT text, passes.
• 6 effusion: enrichment bar measured vs theory marker; counts.

Chart B canvas shared; label id chartBTitle updated.

For histogram species split: sp0 speeds, sp1 speeds; normalized pdfs per species (each integrates to its fraction) — draw stacked filled: light bars cyan alpha .7, heavy bars magenta alpha .6 overlay 'lighter'. Combined white curve = mixture pdf. Species curves thin.

vmaxHist = max(3.2sqrt(3bathT/1), 5)? base on light species σ. update on T change.

OK writing. Also the log flavor texts. Also help overlay table.

Length is fine; let me go. I'll write with the file write tool. Path /space/demos/039-kinetic-theory/index.html. Need mkdir first.

Let me draft key numeric defaults:

• hx=30, hy=18, hz=18
• light: m=1, r=0.55; heavy: m=8, r=1.10; pollen: m=60, r=2.6
• bathT default 1.0, slider 0.2..8 (display "1.0")
• count default 1000 (slider 200..2000 step 50)
• time 1 (0.25..2)
• gravity 0 (0..25)
• weight F_ext 24 (5..80)
• demon door 3.2, hole 2.0
• piston X0 12, M 400, damp 6

Colors:

• bg #04060c; fog
• light cyan #6fd3ff; heavy pink #ff7ad9; hot #ff9a5c; accent #6fd3ff.

Physics core exports nothing (class declared with class GasSim {...} and test wrapper appends export). Test extraction: slice between markers, append \nexport { GasSim };\n write to /tmp/phys.mjs.

Now write the whole thing. Also careful: template literals inside the HTML script — I'm writing via the write tool with a content string; no shell interpolation issues since write tool takes raw content.

Let me write the sim class fully:

Hmm — zeroing net momentum including heavy species fine; but for pollen preset, subtracting mean is fine too.

thermalize(i) single particle: set v from gauss at bathT for species mass (used by pump

Now write the big file. I'll write it in one write call.