2dedc35turing-sphere: reaction-diffusion on the sphere, spectral solver on WebGPUJeremy Magland 1# turing-sphere
3Reaction–diffusion systems (Turing patterns) solved **live in the browser on the
4surface of a sphere**, using a spectral spherical-harmonic method with the
5transforms running on the GPU via WebGPU.
61e12f1Write the solver in MATLAB and compile it to WebGPUJeremy Magland 7The solver itself is **MATLAB**. The `.m` files under [`models/`](models/) are the
8algorithm — [numbl](https://numbl.org) parses and lowers them in the browser, and
9each element-wise line becomes a WebGPU compute kernel. You can edit the MATLAB
10on the page and watch the pattern change.
c47b479Point the demo link back at the original repo's Pages siteJeremy Magland 12**Live demo:** <https://concept-collection.github.io/turing-sphere/>
14## What it does
16It solves the N-species system
18```
19d(u_k)/dt = D_k*lap_s(u_k) + f_k(t, x, y, z, u_1, ..., u_N), k = 1, ..., N
20```
22on the unit sphere, where `lap_s` is the Laplace–Beltrami operator. Diffusion is
23treated implicitly in spherical-harmonic coefficient space, where `lap_s` is
24diagonal with eigenvalues `-l(l+1)`; reaction is treated explicitly on the grid.
25The two are combined with a first-order IMEX Euler step — the entire time loop is
27```
28V_k = synth(U_k) # spectral -> grid
29R_k = analys(f_k(t, x, y, z, V_1..V_N)) # reaction on grid -> spectral
30U_k = (U_k + dt*R_k) / (1 + dt*D_k*l(l+1))
31```
33You watch the patterns emerge in real time on orbitable 3D spheres (one per
34species, cameras synced), with pause/resume, re-seeding, live parameter editing,
35and colormap selection.
61e12f1Write the solver in MATLAB and compile it to WebGPUJeremy Magland 37Three models are included, one `.m` file each:
39- **[Schnakenberg](models/schnakenberg.m)** — Turing spots (unstable band
40 14 ≤ l ≤ 40, peak l = 24)
41- **[Brusselator](models/brusselator.m)** — stripes and spots from a stiffer reaction
42- **[Allen–Cahn](models/allencahn.m)** — a single species whose interfaces form
43 and coarsen
45## MATLAB, compiled to WebGPU
61e12f1Write the solver in MATLAB and compile it to WebGPUJeremy Magland 47A model file is ordinary MATLAB defining two functions — `init` builds the initial
48spectral state, `step` advances it one timestep:
50```matlab
51function [Un, Vn, u, v] = step(U, V, lam, a, b, D1, D2, dt)
52 u = synth(U);
53 v = synth(V);
54 uuv = u .* u .* v;
55 Un = (U + dt * analys(a - u + uuv)) ./ (1 + (dt * D1) * lam);
56 Vn = (V + dt * analys(b - uuv)) ./ (1 + (dt * D2) * lam);
57end
58```
60Getting from there to the GPU uses numbl for everything up to the IR, and this
61repo only for the backend:
631. **numbl parses and lowers.** Each function is specialized for the concrete
64 argument types of the current grid, via the same `specializeUserFunction`
65 entry point numbl's own JIT uses. Types and array shapes are fixed at this
66 point, so the backend never has to re-decide what an operation means.
672. **numbl's inline pass fuses.** Lowering emits one statement per *operator*
68 (ANF); `inlinePass` folds single-use temps back into their consumer, so one
69 line of MATLAB becomes one expression tree. `uuv = u .* u .* v` arrives as a
70 single statement, not three.
713. **This repo emits WGSL** ([`src/mgpu/wgsl.ts`](src/mgpu/wgsl.ts)). Each
72 element-wise statement becomes one compute kernel that computes one output
73 element per invocation — the WebGPU counterpart of numbl's own C-side fused
74 emitter. Anything it cannot express is refused at compile time with a source
75 position, never silently mis-compiled.
764. **`synth` / `analys` are external operations.** numbl learns their type rules
77 from a `.mtoc2.js` workspace file — its sanctioned extension point for a
78 JS-defined builtin — and the backend maps each call onto the existing
79 spherical-harmonic compute pipelines.
81The Schnakenberg step above compiles to 11 GPU operations: 4 transforms, 5
82generated kernels, and 2 buffer copies feeding the new state back.
84Two consequences worth noting:
86- **The step is synchronous.** WebGPU's encode path (`writeBuffer`, dispatch,
87 `submit`) is all synchronous; only readback and pipeline creation are async, and
88 every pipeline is built once at compile time. So a timestep is pure command
89 recording — the whole batch goes out in one submit, and the only `await` in the
90 loop is the single readback per rendered frame. numbl's own execution being
91 synchronous is therefore not an obstacle: nothing about the algorithm needs to
92 block.
93- **Parameters are uniforms, not constants.** Tunable scalars are deliberately
94 lowered without exact values, so moving a slider rewrites a small buffer
95 instead of triggering a recompile. Editing the MATLAB recompiles; changing `dt`
96 does not.
98## Provenance
100This is the browser port of a MATLAB reference implementation
101(`SphericalReactionDiffusion.m`, "websph"), which defines the solver through a
102four-member porting boundary: `coeffs2vals`, `vals2coeffs`, `grid.lat`,
103`grid.lon`. Profiling of the MATLAB version shows the transforms are ~96% of
104compute, so this port swaps in:
106- **Transforms:** [shtns-webgpu](https://github.com/concept-collection/shtns-webgpu) —
107 fp32 spherical harmonic transforms in WGSL compute shaders, modeled on
108 [SHTNS](https://nschaeff.bitbucket.io/shtns/). Its source is vendored under
109 [`src/sht/`](src/sht/) (CECILL-2.1), including the f64 CPU reference
b689087Benchmark the WGSL transforms against upstream SHTNSJeremy Magland 110 transform used for testing. [`bench/shtns/`](bench/shtns/) builds the real
111 SHTNS and measures ours against it — see
112 [Against upstream SHTNS](#against-upstream-shtns).
2dedc35turing-sphere: reaction-diffusion on the sphere, spectral solver on WebGPUJeremy Magland 113- **Rendering:** three.js spheres with per-vertex colormaps, adapted from the
114 `SphereEmbedding` view in
115 [figpack](https://github.com/flatironinstitute/figpack)'s experimental
116 extension package ([`src/render/`](src/render/)).
61e12f1Write the solver in MATLAB and compile it to WebGPUJeremy Magland 117- **Solver:** the MATLAB stayed MATLAB. [`models/`](models/) holds the IMEX loop
35d91faDelete the TypeScript solver; the .m models are the only implementationJeremy Magland 118 as `.m` files, executed on the GPU by [`src/mgpu/`](src/mgpu/). There is no
119 second implementation: the app, the desktop benchmark and the tests all compile
120 and run the same `.m`.
35d91faDelete the TypeScript solver; the .m models are the only implementationJeremy Magland 122An earlier version of this repo carried a TypeScript port of the loop alongside
123the `.m`, and used it as the test oracle. That is gone. Two implementations
124agreeing only shows they share assumptions, so the `.m` path is now checked
125against closed-form answers instead — see [Tests](#tests). The one place a second
126implementation is still the right oracle is the transforms themselves, where
127[`src/sht/reference.ts`](src/sht/reference.ts) is shtns-webgpu's own f64
128direct-summation twin.
35d91faDelete the TypeScript solver; the .m models are the only implementationJeremy Magland 130Because the algorithm is compiled to compute shaders, **WebGPU is required** —
131there is no CPU fallback (the f64 CPU transform remains, for tests).
133## Numerics
135- Grid: Gauss–Legendre × equispaced-phi, dealiased for the cubic reactions with
136 the `(pdeg+1)` rule from the reference implementation:
137 `nlat ≥ ((pdeg+1)·lmax+1)/2`, `nphi ≥ (pdeg+1)·lmax+1` (rounded up to a power
138 of two for the GPU FFT path). At the default lmax 63 that is a 128×256 grid.
139- Spectral layout: SHTNS conventions — orthonormal + Condon–Shortley, complex
140 coefficients for m ≥ 0, m-major ordering.
141- fp32 transforms introduce ~1e-6 relative error per step (verified against the
142 f64 CPU path); for pattern formation from 1e-2 seeded noise this is
143 inconsequential.
15a77e2Add a desktop WebGPU benchmark and show its command in the appJeremy Magland 145## Desktop vs browser
147How much does running this in a browser cost? [`scripts/bench.ts`](scripts/bench.ts)
35d91faDelete the TypeScript solver; the .m models are the only implementationJeremy Magland 148runs the *same* thing — same `.m`, lowered by numbl into the same WGSL kernels,
149over the same transforms — from Node on desktop WebGPU (Google Dawn), and the app
150prints the command line that reproduces whatever it is currently simulating:
152```
35d91faDelete the TypeScript solver; the .m models are the only implementationJeremy Magland 153npm run bench -- --preset schnak-spots --lmax 63 --steps 2000 \
15a77e2Add a desktop WebGPU benchmark and show its command in the appJeremy Magland 154 --seed 1 --a 0.1 --b 0.9 --D1 0.0004 --D2 0.008 --dt 0.05
155```
157Copy it from under the stats line, run it, and compare the `ms/step` it reports
158with the app's. Both sides go through the one shared
159[`src/bench/runSpec.ts`](src/bench/runSpec.ts) — the app formats a run into that
160command, the benchmark parses it back — so there is no second copy of the
35d91faDelete the TypeScript solver; the .m models are the only implementationJeremy Magland 161defaults for the two runs to drift apart on. Both then go through the same
162[`ModelSession`](src/mgpu/session.ts), down to the device request in
163`requestShtDevice()` (Dawn is installed under `navigator.gpu` and the WebGPU
164globals, and the rest runs unchanged).
166The benchmark runs under `vite-node`, which is what resolves numbl's compiler
167sources and the `?raw` model imports — plain Node cannot (see
168[The numbl dependency](#the-numbl-dependency)).
170It reports two numbers, because they answer different questions:
172```
173 0.54 ms/step 1857.5 steps/s 92.87 model time/s (batches of 16)
174 one step per submit: 0.74 ms mean · median 0.60 · p05 0.51 · p95 1.29 · min 0.50
175```
177The first is throughput: a batch of steps submitted together and awaited once,
178which is how the app runs and what keeping the state in GPU buffers is for. The
179second is per-step latency, one submit each — comparable to a design that
180synchronises every step, and the only way to get a distribution.
182**What the GPU-resident design is worth.** At lmax 31 on an Intel Xe (Mesa, via
183Dawn) this path runs at **0.25 ms/step**, against **3.01 ms/step** for the
184TypeScript solver this repo used to carry — same machine, same transforms, same
185parameters. A **~12x** difference, and almost all of it is the four per-step
186buffer readbacks that version paid and this one does not. Note that CI, which
187only has a software rasterizer, shows no such gap: there the transforms dominate
188and both designs land within ~10% of each other. The saving is real but it is a
189saving on driver round-trips, so it only appears once the GPU is fast.
e5b7827Fix CI: do not omit optional dependenciesJeremy Magland 191Desktop WebGPU comes from the `webgpu` package (prebuilt Dawn, ~70 MB), listed
192as an optional dependency so that a platform it has no binaries for fails the
193install of that package alone rather than the whole tree. `npm install` picks it
35d91faDelete the TypeScript solver; the .m models are the only implementationJeremy Magland 194up; without it there is no desktop GPU to run on and the benchmark says so.
195Those binaries need glibc 2.29+, which rules out older cluster images
196(RHEL/Rocky 8 is 2.28) unless you run inside a container with a newer base. Other
197flags: `--steps`, `--warmup`, `--batch`, `--json`, `--help`;
198`DAWN_FLAGS='backend=vulkan'` (`;`-separated) passes Dawn options through, e.g. to
199pick a backend or to compare against Dawn's own software adapter.
0f3abbdSeparate solver time from frame time, and add a cross-environment checkJeremy Magland 201### Comparing the two honestly
0f3abbdSeparate solver time from frame time, and add a cross-environment checkJeremy Magland 203The app reports **two** numbers, and only the first is comparable to the
204benchmark:
206```
207solver 0.58 ms/step (1724 steps/s) · 12.4 ms/frame incl. readback + render
208```
210`solver` is the batch of steps alone, waited for but not read back — the same
211thing the benchmark's throughput number measures. `ms/frame` additionally carries
212a GPU→CPU readback **per species**, the colormapping, and the vertex upload.
214Those per-frame costs are fixed: they do not shrink when the GPU gets faster. So
215the faster your GPU, the larger the ratio between them — on a quick discrete GPU
216it is easy for a frame to cost ten times the four steps inside it, purely because
217a `mapAsync` round trip in a browser has to drain the queue and cross into the GPU
218process. **That is expected, and it is not the solver being slower in the
219browser.** Compare `solver` with the benchmark's throughput line; comparing
220`ms/frame` against it measures the readback, not the computation.
222Other things the comparison does not control for:
224- the browser's renderer→GPU-process boundary on every submit, where Dawn in Node
225 is in-process; and, for a page that is not cross-origin isolated, coarser
226 `performance.now()`.
35d91faDelete the TypeScript solver; the .m models are the only implementationJeremy Magland 227- both sides are fp32 throughout, on the same generated kernels, so nothing here
228 is a numerics comparison — only a cost one.
cde22eaStop the per-frame sync from inflating the app's solver numberJeremy Magland 230### Why the browser is slower, and how to find out by how much
232Some gap is real and some is measurement. Four numbers, in increasing order of
233what they include — walk down them and the gap attributes itself:
236node scripts/compare-perf.mjs [--lmax 63] [--steps 300]
237```
239measures the same solver work in both — batched, nothing read back, no rendering
240on either side — and reports each with its CPU-encoding share, the Fourier stage,
241and the adapter. It stops you first if the two are not even the same device: a
242browser quietly falling back to a software adapter is a common cause of "the
243browser is much slower", and then the ratio compares different hardware and means
244nothing.
3221abdAdd a Benchmark button that measures the solver and the GPU's clock rampJeremy Magland 246Or press **Benchmark** in the app: it pauses rendering and runs batches
247continuously for two seconds, reporting the same measurement the terminal makes,
248plus the **ramp** — the first third of the run against the last. GPUs downclock
249when idle and an animation-paced loop leaves them idle most of every frame, so a
250large ramp means the steady-state number is limited by clocks rather than by the
251work.
253By hand, five numbers, in increasing order of what they include:
cde22eaStop the per-frame sync from inflating the app's solver numberJeremy Magland 255| number | includes |
256|---|---|
257| `npm run bench -- --lmax 63` | desktop solver: batched steps, one sync per batch, in-process Dawn |
3221abdAdd a Benchmark button that measures the solver and the GPU's clock rampJeremy Magland 258| the app's **Benchmark** button | browser solver, sustained, no rendering, no pacing |
259| `test.html?soak=2000&lmax=63` → `solver` | the same, without the page around it |
260| the app's `solver` | browser solver, one batch of 32 every two seconds |
cde22eaStop the per-frame sync from inflating the app's solver numberJeremy Magland 261| the app's `ms/frame` | four steps **plus** a readback per species, colormapping and the vertex upload |
263If the soak matches the benchmark, the solver is fine in the browser and
264everything above it is readback and rendering. If the soak is itself slower, the
265remaining suspects are:
267- **the GPU-process boundary.** Every submit and every sync is IPC out of the
268 renderer; Dawn in Node is in-process. This is a fixed per-batch cost, so it hurts
269 most when the GPU is fast. `npm run bench -- --batch 4` makes the desktop pay a
270 sync as often as the app's frame loop does, which shows how much of the gap is
271 just amortization.
17db8f1Add scripts/compare-perf.mjs, and rule out CPU command encodingJeremy Magland 272- **not CPU command encoding**, which is worth ruling out explicitly because it is
273 the obvious suspect: a step is ~47 WebGPU calls, and 32 of them per burst is a
274 lot of JS→GPU traffic. Measured, it goes the other way — 0.009 ms/step in Chrome
275 against 0.062 ms/step under node-webgpu, because Chrome defers commands to the
276 GPU process while node-webgpu validates them inline. Encoding is *cheaper* in
277 the browser. Both `compare-perf.mjs` and the benchmark print it.
cde22eaStop the per-frame sync from inflating the app's solver numberJeremy Magland 278- **competing with the renderer.** The page draws two spheres through WebGL on the
279 same GPU, in its own animation loop. The soak has no renderer, so comparing the
280 soak against the app's `solver` separates contention from everything else.
281- **clocks.** An animation-paced loop leaves the GPU idle for most of each 16 ms
282 frame, so it may never leave its low-power state, while the benchmark hammers it
283 continuously and boosts. On a thermally managed laptop this alone can be worth a
3221abdAdd a Benchmark button that measures the solver and the GPU's clock rampJeremy Magland 284 factor of two, and it is not something the code can fix. The **Benchmark**
285 button's ramp figure measures it directly.
286- **anything else using the GPU.** Another process competing for it changes
287 whichever run overlaps it, which makes a comparison across two separate
288 invocations meaningless. `compare-perf.mjs` runs both sides back to back in one
289 invocation partly for this reason.
290- **not buffer robustness**, another plausible suspect: WebGPU clamps every array
291 access for safety, which could cost real time in the transform kernels' inner
292 loops. Measured with Dawn's `disable_robustness` toggle
293 (`DAWN_FLAGS='enable-dawn-features=disable_robustness' npm run bench`), it makes
294 no difference here at all — 0.59 ms/step either way.
cde22eaStop the per-frame sync from inflating the app's solver numberJeremy Magland 295- **which browser.** WebGPU implementations differ substantially in maturity;
296 Chrome and Safari are not interchangeable for this.
298None of these change *what* is computed — see below for how to confirm that
299independently.
0f3abbdSeparate solver time from frame time, and add a cross-environment checkJeremy Magland 301### Is it really the same computation?
303```
304node scripts/compare-env.mjs [--lmax 31] [--steps 200] [--preset schnak-spots]
305```
307runs one identical spec on the desktop and in a real browser and compares the
308final spectral state. The pipeline is deterministic given (model source,
309parameters, lmax, seed, steps) — a seeded PRNG, then fixed arithmetic — so the two
310should agree to fp32 round-off. Both sides build their spec through the same
311`parseArgs`, so neither can quietly use a different default.
313They will *not* agree bit for bit; GPUs differ in fused-multiply-add and other
314latitude fp32 allows. Between Intel Xe (via Dawn) and SwiftShader — about as
315different as two implementations get — 200 steps at lmax 31 agree to a relative
316L2 of **2e-6**.
318It also reports which **Fourier stage** each side chose. `ShtPlan` picks FFT or
319DFT from the device's workgroup-storage and invocation limits, and those are
320genuinely different algorithms that round differently, so a mismatch there
321explains a difference in the values rather than being a symptom of one. The app's
322stats line and the benchmark both print the chosen stage for the same reason.
b689087Benchmark the WGSL transforms against upstream SHTNSJeremy Magland 324## Against upstream SHTNS
326The transforms are a WGSL translation of
327[SHTNS](https://nschaeff.bitbucket.io/shtns/), and the tests check them against
328their own f64 CPU twin — which shows they are self-consistent, not how they
329compare with the library they are modeled on. SHTNS itself runs on the CPU with
330hand-tuned SIMD codelets, and on Nvidia GPUs with its own CUDA kernels, including
331a single-precision mode. That is a direct comparison, and
332[`bench/shtns/`](bench/shtns/) makes it:
334```
335cd bench/shtns && ./bootstrap.sh && make # clone SHTns at a pinned commit, build
336node scripts/compare-native.mjs --check # then, from the repo root
337```
339`bootstrap.sh` adds CUDA support when `nvcc` is on `PATH`, so the same tree gives
340you the CPU comparison anywhere and the GPU one on a machine with an Nvidia card.
341`compare-native.mjs` runs every implementation present, back to back in one
342invocation so a second process competing for the GPU affects both sides rather
4166b48Tidy up after the SHTNS comparisonJeremy Magland 343than one, and prints them in one table. On an RTX PRO 6000 Blackwell, at the
344app's default lmax:
346```
347 grid lmax 63 · 128×256 · nlm 2,080 (one synthesis + one analysis per round trip)
4166b48Tidy up after the SHTNS comparisonJeremy Magland 349 webgpu 0.084 ms/round trip 11848/s (baseline) fp32
350 NVIDIA (blackwell), via Dawn · CPU-side launching 0.012 ms/step
351 shtns cuda 0.021 ms/round trip 48009/s 0.25x webgpu fp32
352 NVIDIA RTX PRO 6000 (sm_120, 188 SMs) · CPU-side launching 0.018 ms/step
353 shtns cpu 0.072 ms/round trip 13982/s 0.85x webgpu fp64
355```
4166b48Tidy up after the SHTNS comparisonJeremy Magland 357Read that carefully rather than as "4x". The two GPU rows are limited by different
358things: the WGSL row spends 14% of its time on the CPU and is genuinely GPU-bound,
359while SHTNS spends **86%** — 0.018 ms of 0.021 — queueing its six-or-so kernels, so
360its number is close to what it costs to *submit* a round trip on that host and its
361actual GPU time is below that and unresolved. The 4x is a lower bound on the gap in
362GPU work, not a measurement of it. `compare-native.mjs` flags any row above 50%
363for this reason.
365The other number worth noticing is the third row: one CPU core in fp64 is about
366level with the WGSL transforms on a 188-SM datacentre GPU. At lmax 63 there are
3672,080 coefficients on a 128×256 grid — far too little work to occupy that card, so
368this says more about occupancy than about the shaders. Sweep lmax before drawing
369conclusions, and stop at 511: above that `16*nphi` exceeds the workgroup-storage
370limit, the FFT stage falls back to the O(nphi·mmax) DFT, and the comparison stops
371being about the FFT.
b689087Benchmark the WGSL transforms against upstream SHTNSJeremy Magland 373Two things are measured, because they answer different questions:
375- **transforms** (`npm run bench:sht` here, `--mode transform` there) — one
376 spectral → grid → spectral round trip and nothing else. This is the
377 library-against-library number, and since the transforms are ~96% of the
378 solver's compute it is what decides how fast the solver can be.
379- **solver** (`npm run bench` here, `--mode solver` there) — a whole IMEX Euler
380 timestep, which is what the app's `solver` line reports.
382`--check` diffs the final spectral state across implementations, which is what
383makes the timing mean anything: two numbers are only comparable if they are the
384cost of the same computation. That check is possible at all because the spectral
385layout and normalization are SHTNS's own — orthonormal with Condon–Shortley,
386coefficients grouped by `m`, `LM(l,m)` agreeing index for index — so a state can
387be diffed element by element with no reindexing. Over 20 steps, fp32 WGSL against
388fp64 SHTNS agrees to **~1e-6** relative L2, for every model.
390It is also the check on the one second implementation this repo has. The native
391solver cannot run `models/<key>.m` — C has no numbl — so `bench/shtns/spec.h`
392restates the same arithmetic, one line per line of MATLAB. `--check` is what
393keeps that transcription honest, and `compare-native.mjs` refuses to compare two
394runs whose resolved grid or parameters disagree, which is the other way the two
395sides could drift.
397[`bench/shtns/README.md`](bench/shtns/README.md) lists what is *not* identical and
398should be kept in mind when reading the ratio — SHTNS runs its Legendre
399recurrence in fp64 even in fp32 mode for `lmax <= 128` (WebGPU has no fp64 at
400all), the Fourier stages are cuFFT/VkFFT/FFTW against a WGSL FFT, and SHTNS'
401polar optimization is off by default here because we have none.
4166b48Tidy up after the SHTNS comparisonJeremy Magland 403How much the grid size matters is easiest to see on a weak GPU, where there is no
404launch-overhead floor to hide behind. On an Intel Xe iGPU against one core of the
b689087Benchmark the WGSL transforms against upstream SHTNSJeremy Magland 405same laptop, one round trip costs:
407| lmax | grid | WGSL (fp32) | SHTNS, 1 CPU core (fp64) |
408|---|---|---|---|
409| 31 | 64×128 | 0.183 ms | 0.017 ms |
410| 63 | 128×256 | 0.250 ms | 0.110 ms |
411| 127 | 256×512 | 0.733 ms | 0.602 ms |
41310x behind at lmax 31, 1.2x at lmax 127 — the same comparison, on the same two
414chips. Whatever a single number says, it is saying it about one grid size.
2dedc35turing-sphere: reaction-diffusion on the sphere, spectral solver on WebGPUJeremy Magland 416## Tests
35d91faDelete the TypeScript solver; the .m models are the only implementationJeremy Magland 418There is no second implementation of the solver to diff against, so the `.m` path
419is checked against **closed-form answers**. Each case is one whose evolution is
420known exactly, run through the whole real pipeline — MATLAB source, numbl
421lowering, generated WGSL, GPU transforms — and compared with arithmetic
422([`test/analyticChecks.ts`](test/analyticChecks.ts)):
424- **A** — a linear reaction `f(u) = c*u` leaves every spherical-harmonic mode
425 independent, growing by exactly `(1 + dt*c) / (1 + dt*D*l(l+1))` per step. This
426 pins the transform round-trip, the eigenvalue mapping, the IMEX update and the
427 state feedback at once, and checks that nothing leaks between modes. Agrees to
428 ~2e-7 over 20 steps.
429- **B** — a nonlinear reaction on a *uniform* field stays uniform and diffusion
430 cannot touch it, so each step is exactly the scalar ODE map. Agrees to 1.5e-8
431 over 25 steps. Checks that a generated kernel evaluates a nonlinear reaction.
432- **C** — a 1e-6 perturbation of the Schnakenberg fixed point follows the
433 linearized 2x2 IMEX recurrence, and the `(l=24, m=7)` mode is confirmed
434 unstable. Looser (~2e-3) because fp32 keeps only about four digits of a
435 perturbation that small.
437Two test models exist only for this: [`test/models/linear.m`](test/models/linear.m)
438and [`test/models/logistic.m`](test/models/logistic.m).
440Alongside those, [`test/modelChecks.ts`](test/modelChecks.ts) compiles every model
441the app offers and asserts **how many kernels it compiles to**. That is a fusion
442guard: numbl's lowering emits one statement per *operator* and its inline pass
443folds them back into per-line expression trees, and if that stops happening the
444results stay correct while every operator becomes its own dispatch. It is
445invisible in the numbers, so it is asserted directly. (It has already caught one
446regression.)
448[`test/transformChecks.ts`](test/transformChecks.ts) is the one remaining
b689087Benchmark the WGSL transforms against upstream SHTNSJeremy Magland 449implementation-vs-implementation check inside the suite, comparing the WGSL
450transforms against shtns-webgpu's f64 CPU twin. Comparing them against *upstream*
451SHTNS is a separate, opt-in step, because it needs a native toolchain — see
452[Against upstream SHTNS](#against-upstream-shtns).
454All three modules run in **both** environments, so the two GPU stacks get the same
455guarantees:
457- `npm run test:node` — under Dawn on the desktop, via `vite-node`. Needs a GPU;
458 pass `--skip-without-gpu` to let a machine without one say so and move on
459 (which is what CI does, since the browser suite covers the same modules).
460- `npm run test:gpu` — builds and drives headless Chrome, on SwiftShader in CI.
461 Also runs the soak.
463Other commands:
465- `npm run bench -- --help` — the desktop benchmark (see
15a77e2Add a desktop WebGPU benchmark and show its command in the appJeremy Magland 466 [Desktop vs browser](#desktop-vs-browser)).
b689087Benchmark the WGSL transforms against upstream SHTNSJeremy Magland 467- `npm run bench:sht -- --help` — the transforms alone, with no solver around
468 them, for comparing against upstream SHTNS.
30ed90fAdd scripts/diagnose-sht.ts: which stage of the transform is wrong?Jeremy Magland 469- `npx vite-node scripts/diagnose-sht.ts` — when the transform tests fail on a GPU,
470 say *which* stage is wrong. It reads the intermediate `fm` back out and scores
471 the Legendre and Fourier stages of each direction separately against the f64
472 reference, then breaks the error down by order `m` and by latitude.
4166b48Tidy up after the SHTNS comparisonJeremy Magland 473- `npx vite-node scripts/diagnose-leg.ts [--m 0]` — the follow-up to that: read the
474 Legendre recurrence out of the production shader term by term, by synthesizing a
475 spectrum that is 1 at a single coefficient, and compare each `ỹ_l^m` with the f64
476 reference. The first term that disagrees names the culprit.
35d91faDelete the TypeScript solver; the .m models are the only implementationJeremy Magland 477- `npx vite-node scripts/longrun-node.ts [lmax]` — run to t = 100 and confirm the
478 pattern saturates into O(1)-contrast spots rather than decaying or diverging.
479- `node scripts/soak.mjs [steps] [lmax]` — drive the demo for many steps,
480 sampling JS heap and catching crashes.
481- `node scripts/screenshot.mjs out.png [light|dark] [minSteps]` — screenshot the
482 demo after a number of steps.
e7bcd70Add soak, live-check and solver-only soak toolingJeremy Magland 483- `node scripts/check-live.mjs [url]` — smoke-check a deployed URL in a real
484 browser: load, press Run, confirm the solver advances.
0f3abbdSeparate solver time from frame time, and add a cross-environment checkJeremy Magland 485- `node scripts/compare-env.mjs` — run one identical spec on the desktop and in a
486 browser and compare the final state (see
487 [Is it really the same computation?](#is-it-really-the-same-computation)).
17db8f1Add scripts/compare-perf.mjs, and rule out CPU command encodingJeremy Magland 488- `node scripts/compare-perf.mjs` — measure the same solver work in both and split
489 the difference (see
490 [Why the browser is slower](#why-the-browser-is-slower-and-how-to-find-out-by-how-much)).
b689087Benchmark the WGSL transforms against upstream SHTNSJeremy Magland 491- `node scripts/compare-native.mjs` — run one spec through the WGSL transforms and
492 through upstream SHTNS, and line the numbers up (see
493 [Against upstream SHTNS](#against-upstream-shtns)). Needs
494 [`bench/shtns/`](bench/shtns/) built first.
e7bcd70Add soak, live-check and solver-only soak toolingJeremy Magland 495- `test.html?soak=<steps>&lmax=<n>` — solver-only soak with no rendering.
497### A note on canvas resizing
499Early long runs killed the browser after ~700–800 steps. The cause was the
500colorbar's min/max labels changing width as their digit count changed, which
501reflowed the panel, fired the `ResizeObserver`, and called
502`renderer.setSize()` — reallocating the WebGL drawing buffer. Assigning
503`canvas.width` also blanks the canvas even when the value is unchanged, so the
504same bug caused visible flicker. Fixed by giving the colorbar column a fixed
505width and making `SphereScene.resize()` return early on no-op resizes.
4166b48Tidy up after the SHTNS comparisonJeremy Magland 507### A note on the Legendre recurrence on Blackwell
509The first run on an Nvidia GPU — an RTX PRO 6000, driver 590.48, reached through
510Dawn's Vulkan backend — failed 11 of the tests. `synth` was off by 5.5e+3 while
511`analys` was accurate to 7.3e-7, and the solver produced NaN within 40 steps.
513The two diagnostic scripts above were written for it and localized it in two
514steps: `leg_synth` was the only wrong shader, and within it the recurrence was
515right at `l = m` and `l = m+1` and then returned *exactly zero* at `l = m+2`, at
516every latitude. That is not a precision failure. It is
518```wgsl
519let c0 = ab[base + (l + 2u - m)];
520y0 = c0.x * ct * y1 + c0.y * y0; // c0 reads as (0, 0) on the first iteration
521```
523with the `ab` read two lines later working fine. The buffer was not at fault:
524`leg_analys` reads the same array correctly on the same device, and `m = 62, 63`
525— the only orders whose loop breaks before that line — were the only correct
526ones. Nothing about that WGSL is invalid, so it was a miscompiled load.
528Fixed by giving the advance the shape `leg_analys` already used, which that
529driver compiles correctly: both coefficients fetched unconditionally, and the new
530`y0` carried in a temporary rather than assigned and then read back by the `y1`
531update. Two shaders doing the same recurrence should have agreed on form anyway.
533Worth knowing for what it says about the transforms in general: nothing had
534exercised them on Nvidia hardware before, and the existing test caught it
535immediately — it just could not say where. That is what the diagnostics are for.
2dedc35turing-sphere: reaction-diffusion on the sphere, spectral solver on WebGPUJeremy Magland 537## Development
539```
540npm install
541npm run dev # local dev server
542npm run build # type-check + production build to dist/
543```
61e12f1Write the solver in MATLAB and compile it to WebGPUJeremy Magland 545### The numbl dependency
547numbl is a local `file:../../numbl` dependency, so a sibling checkout of
548[numbl](https://github.com/flatironinstitute/numbl) is required. We use its
549compiler internals — parser, lowerer, IR, inline pass — which its package
550`exports` map does not publish, so they are reached through the `numbl-src` path
551alias in [`vite.config.ts`](vite.config.ts).
553The exact surface we depend on is written down in
554[`src/mgpu/numbl.d.ts`](src/mgpu/numbl.d.ts) and TypeScript checks against
555*that*, not against numbl's sources. This keeps this project's compiler settings
556independent of numbl's (its sources do not type-check under the stricter options
557used here), and means a change to one of those shapes upstream breaks the build
558here with a clear diff rather than deep inside numbl's tree.
560The compiler is ~395 kB gzipped and lands in its own chunk. That is the cost of
561compiling MATLAB in the page; a build-time lowering step could remove it at the
562price of no longer being editable live.
564CI clones numbl to the sibling path that `file:` dependency expects, pinned to a
565commit. Two details make that work, both verified by building against a checkout
566that had none of numbl's own dependencies installed:
568- **numbl's `node_modules` are not needed.** The slice we import — parser,
569 lowering, IR, inline pass — is self-contained TypeScript. (Other parts of numbl
570 do import `three`, `react` and `fflate`; we never reach them.)
571- **the install must pass `--ignore-scripts`.** npm runs a linked package's
572 `prepare` script, and numbl's is `husky`, which is not installed in CI.
35d91faDelete the TypeScript solver; the .m models are the only implementationJeremy Magland 574The `scripts/*.ts` entry points that touch the compiler (the benchmark, the node
575tests, the long run) go through `vite-node`, so they resolve imports exactly as the
576browser build does — the `numbl-src` alias and the `?raw` model imports included.
577Plain `node` cannot: numbl's sources import each other as `./foo.js` while the
578files are `.ts`, which needs a bundler's resolution. Scripts that do not touch the
579compiler (`soak.mjs`, `screenshot.mjs`, `check-live.mjs`, `test-gpu.mjs`) are plain
580`.mjs` and run under `node` directly.
2dedc35turing-sphere: reaction-diffusion on the sphere, spectral solver on WebGPUJeremy Magland 582Deployed to GitHub Pages by `.github/workflows/deploy.yml` on push to `main`.
584## License
586CECILL-2.1 (inherited from SHTNS via shtns-webgpu, whose sources are vendored).