jz 0.5.1 → 0.7.0

package/bench/README.md

@@ -0,0 +1,369 @@
+# jz benchmark suite
+
+Cross-target workload suite for jz codegen quality. Each benchmark is a case
+folder under `bench/`:
+
+```txt
+bench/<case>/<case>.js      JavaScript source used by V8, jz, etc.
+bench/<case>/<case>.c       optional native C baseline
+bench/<case>/<case>.rs      optional Rust baseline
+bench/<case>/<case>.go      optional Go baseline
+bench/<case>/<case>.zig     optional Zig baseline
+bench/<case>/<case>.as.ts   optional AssemblyScript baseline
+bench/<case>/<case>.npy.py  optional NumPy baseline
+bench/<case>/<case>.wat     optional hand-written WAT baseline
+```
+
+Every case prints the same line:
+
+```txt
+median_us=<int> checksum=<u32> samples=<int> stages=<int> runs=<int>
+```
+
+The orchestrator runs selected cases against selected targets and flags checksum
+drift as `DIFF`.
+
+## Run
+
+```sh
+npm run bench
+node bench/bench.mjs --targets=nat,rust,go,numpy,v8,jz
+node bench/bench.mjs --targets=jz --cases=biquad,mat4,poly,bitwise
+node bench/bench.mjs --targets=v8,deno,bun,spidermonkey,graaljs
+node bench/bench.mjs --cases=biquad,fft,synth,bytebeat,blur
+node bench/bench.mjs biquad
+node bench/bench.mjs mat4 --targets=nat,v8,jz
+```
+
+## Cases
+
+| id | purpose |
+| --- | --- |
+| [`biquad`](biquad/biquad.js) | DSP filter cascade; dense f64 typed-array loop and offset-fusion baseline |
+| [`mat4`](mat4/mat4.js) | fixed-size typed-array loops; exposes loop unrolling and offset fusion gaps |
+| [`poly`](poly/poly.js) | same `sum` called with `Float64Array` and `Int32Array`; exposes bimorphic typed-array dispatch |
+| [`bitwise`](bitwise/bitwise.js) | long `i32` narrowing chains with `Math.imul`, shifts, and unsigned conversion |
+| [`tokenizer`](tokenizer/tokenizer.js) | string-heavy scan with `charCodeAt`, branches, and integer token accumulation |
+| [`callback`](callback/callback.js) | `Array.map` callback path; exposes closure/call-indirect and array allocation cost |
+| [`aos`](aos/aos.js) | array-of-object rows copied into typed arrays; exposes schema-slot read cost |
+| [`mandelbrot`](mandelbrot/mandelbrot.js) | 256×256 escape-time iteration; dense f64 hot loop with conditional break and i32 counter |
+| [`json`](json/json.js) | runtime `JSON.parse` of one module-local source plus heterogeneous object/array walk with a stable inferred JSON shape |
+| [`sort`](sort/sort.js) | in-place heapsort over a typed array; exposes call-heavy nested loops and typed-array index propagation |
+| [`crc32`](crc32/crc32.js) | table-driven CRC-32 over a mutable byte buffer; exposes integer narrowing and typed-array parameter propagation |
+| [`dotprod`](dotprod/dotprod.js) | multiply-accumulate reduction; jz reassociates to 4 SIMD accumulators, beating strict-fp serial native |
+| [`bytebeat`](bytebeat/bytebeat.js) | classic integer "bytebeat" one-line-song synthesis to 8-bit PCM; pure i32, bit-exact everywhere |
+| [`fft`](fft/fft.js) | radix-2 Cooley–Tukey FFT over a transcendental-free twiddle table; the canonical numeric/audio kernel |
+| [`synth`](synth/synth.js) | minisynth audio pipeline — polynomial oscillator + ADSR + biquad per sample; loop-carried f64 |
+| [`blur`](blur/blur.js) | separable box blur on an RGBA8 image; integer stencil with edge clamp, the canonical image pipeline |
+| [`watr`](watr/watr.js) | watr's WAT-to-wasm compiler on a small WAT corpus; compares jz-compiled compiler code with raw V8 |
+| [`jessie`](jessie/jessie.js) | the subscript/jessie JS parser over a realistic source corpus; branch-, allocation- and recursion-heavy front-end work |
+| [`jz`](jz/jz.js) | the jz compiler itself (scripts/self.js pipeline) compiling three small programs at L2 — the self-host row runs jz.wasm compiling JavaScript; output bytes are checksummed so the parity gate doubles as a determinism proof |
+
+The `watr`, `jessie`, and `jz` rows are self-referential — jz (or its deps)
+compiling code. They stay runnable (`--cases=watr,jessie,jz`) and gated in
+`test/bench.js`, but are hidden from the bench page and the headline geomean SVG:
+they answer a different question (compiler throughput on itself) from the
+cross-language kernel comparison the page is about.
+
+Native rows for `json` are fixed-source references, not semantic equivalents
+of JavaScript `JSON.parse`: C/Rust/Zig hand-parse the known schema from a
+compile-time string, and Zig may constant-fold the whole parse+walk under
+ReleaseFast; Go uses `encoding/json` but still unmarshals the same compile-time
+string. The jz row parses a `let` source at runtime so `JSON.parse` is not
+compile-time folded, while the compiler can still specialize the stable literal
+shape. External unknown-shape JSON still uses the generic runtime parser.
+
+Native-language rows are intentionally per case. NumPy rows are used only
+where a vectorized array implementation is a meaningful Python convention.
+
+Pure interpreters (CPython, QuickJS, Hermes, Javy's embedded-QuickJS) are not
+benchmarked: this suite measures compiled-code quality, and an interpreter row
+inflates jz's lead for free without answering a question a user actually has.
+The headline field is wasm-vs-wasm, apples-to-apples: jz against the other
+languages compiled to the same target — WebAssembly run in V8 — i.e. Rust, Go,
+and C (`wasm32-wasi`), AssemblyScript, and Porffor, plus the JS JITs it replaces
+(V8/Bun/Deno/SpiderMonkey/GraalJS). Native C/Rust/Zig/Go and NumPy's vectorized
+C are kept only as a speed-of-light reference, never presented as the wasm peer.
+
+### Parity classes
+
+The `parity` column is `ok` when the run's checksum matches the most common
+checksum across all targets, `DIFF` when it diverges in a way that suggests
+a bug, and `fma` when the divergence is the documented FMA-fusion class.
+The Go arm64 backend auto-fuses `a*b + c` to `FMADDD` (mandatory in ARMv8,
+no compiler flag to disable it), which alters bit-level rounding on
+recurrence-style loops like `biquad`. Result is still IEEE-754
+correctly-rounded; cascade is the same algorithm.
+
+## Targets
+
+| id | what it measures |
+| --- | --- |
+| `nat` | clang `-O3` native C baseline, when a matching C workload exists |
+| `natgcc` | gcc `-O3`, when real gcc is installed |
+| `rust` | Rust `rustc -C opt-level=3 -C target-cpu=native` — native baseline; the headline rival is `rust-wasm` |
+| `go` | Go native compiler — native baseline; the headline rival is `go-wasm` |
+| `zig` | Zig `build-exe -O ReleaseFast` — native baseline |
+| `numpy` | vectorized NumPy, when a matching `.npy.py` exists |
+| `v8` | raw JavaScript on Node/V8 |
+| `deno` | raw JavaScript on Deno/V8 |
+| `bun` | raw JavaScript on Bun/JavaScriptCore |
+| `spidermonkey` | raw JavaScript on SpiderMonkey shell (`spidermonkey`, `sm`, `js128`, `js115`, `js102`, or `js`) |
+| `shermes` | Static Hermes — JS AOT-compiled to a native binary (`shermes -O`), when installed |
+| `graaljs` | raw JavaScript on GraalJS |
+| `jz` | jz output with host imports for timing/logging (measures wasm size without WASI console/perf bloat) |
+| `as` | AssemblyScript `asc -O3 --runtime stub`, when a matching `.as.ts` exists |
+| `rust-wasm` | Rust → `wasm32-wasip1` (`rustc --target wasm32-wasip1 -C opt-level=3`), run in node's V8 — the apples-to-apples Rust rival |
+| `go-wasm` | Go → `wasm32-wasip1` (`GOOS=wasip1 GOARCH=wasm go build`), run in node's V8 |
+| `c-wasm` | C → `wasm32-wasi` (`zig cc -target wasm32-wasi -O3`, no emcc/wasi-sdk needed), run in node's V8 |
+| `jz-wasmtime` | jz output on wasmtime |
+| `jz-w2c` | jz wasm translated by wabt `wasm2c`, then clang `-O3` |
+| `wat` | hand-written WAT baseline when a case provides `run-wat.mjs` |
+| `porf` | Porffor (`porf run`) when installed |
+| `jawsm` | jawsm when installed |
+
+The `size` column reports the artifact size each target measures: the
+compiled native binary for `nat`/`rust`/`go`/`zig`, the produced
+`.wasm` for `jz`/`as`/`rust-wasm`/`go-wasm`/`c-wasm`/hand-WAT/jawsm/`jz-w2c` (the C-translated
+executable), or the source file for raw-JS interpreters where there is no
+compile step. For source files with imports, raw-JS size is only the entry file;
+jz size is the bundled wasm artifact.
+
+Note the preset trade: these speed tables build jz at the default
+(`optimize: 2`, speed-leaning — loop unroll + SIMD lift), while the dedicated
+size comparison (`npm run bench:size`) builds with `optimize: 'size'` —
+typically ~2× smaller on the same kernel (biquad: 3.5 kB default vs 1.6 kB
+size-tuned). Pick the preset for what you ship; the two tables are not the
+same artifact.
+
+Runtime command overrides:
+
+`watr` is intentionally compiled by jz with a size-oriented pass config
+(`watr:false`, `smallConstForUnroll:false`): on a large compiler bundle, the
+default WAT-level optimizer and small-loop unroll grow code more than they help.
+This keeps the target measuring the best current jz artifact for that workload.
+
+```sh
+BUN_BIN=/path/to/bun \
+DENO_BIN=/path/to/deno \
+SPIDERMONKEY_BIN=/path/to/js \
+SHERMES_BIN=/path/to/shermes \
+GRAALJS_BIN=/path/to/graaljs \
+PORF_BIN=/path/to/porf \
+node bench/bench.mjs --targets=bun,deno,spidermonkey,shermes,graaljs,porf
+```
+
+## Reading the numbers (darwin/arm64, M-class)
+
+Snapshots from `node bench/bench.mjs --targets=v8,jz,as`.
+Where jz lands relative to **V8 raw JS** (`v8/node`) and **AssemblyScript**
+(`as`) is the headline comparison. Native and hand-WAT rows are shown where
+available from earlier runs.
+
+### biquad — f64 typed-array DSP cascade
+
+| target | median | ×v8 | size | parity |
+| --- | ---: | ---: | ---: | --- |
+| **jz → V8 wasm** | **4.64 ms** | **1.94×** | **3.4 kB** | **ok** |
+| AssemblyScript (asc -O3 --runtime stub) | 6.51 ms | 1.38× | 1.9 kB | ok |
+| V8 (node) raw JS | 8.98 ms | 1.00× | 3.2 kB | ok |
+| native C (clang -O3) | 3.86 ms | 2.32× | 32.7 kB | ok |
+| hand-WAT → V8 wasm | 6.49 ms | 1.90× | 767 B | ok |
+
+jz beats V8 raw JS by 2.1× and AS by 1.4×. The typed-array scalarization,
+offset-fusion, and base-hoisting pipeline delivers dense-f64 loop codegen
+that matches the hand-WAT floor.
+
+### mat4 — fixed-size Float64Array multiply
+
+| target | median | ×v8 | size | parity |
+| --- | ---: | ---: | ---: | --- |
+| **jz → V8 wasm** | **1.49 ms** | **5.75×** | **3.1 kB** | **ok** |
+| AssemblyScript (asc -O3 --runtime stub) | 6.71 ms | 1.28× | 1.6 kB | ok |
+| V8 (node) raw JS | 8.57 ms | 1.00× | 1.2 kB | ok |
+| native C (clang -O3) | 1.97 ms | 4.35× | 32.8 kB | ok |
+| hand-WAT → V8 wasm | 8.12 ms | 1.47× | 414 B | ok |
+
+jz is 5.9× faster than V8 raw JS and 4.6× faster than AS. The scalarized
+SIMD hot path (unrolled 4×4 multiply) is the win; V8's JIT doesn't vectorize
+this from JS source.
+
+### poly — bimorphic typed-array reduce
+
+| target | median | ×v8 | size | parity |
+| --- | ---: | ---: | ---: | --- |
+| **jz → V8 wasm** | **0.13 ms** | **12.67×** | **1.4 kB** | **ok** |
+| AssemblyScript (asc -O3 --runtime stub) | 0.81 ms | 2.07× | 1.3 kB | ok |
+| V8 (node) raw JS | 1.67 ms | 1.00× | 1014 B | ok |
+
+jz is 12.9× faster than V8 raw JS and 5.9× faster than AS. The bimorphic
+`sum` (called with both `Float64Array` and `Int32Array`) stays on typed
+paths without falling back to generic dispatch.
+
+### bitwise — i32 narrowing chains (`Math.imul`, shifts, FNV-1a)
+
+| target | median | ×v8 | size | parity |
+| --- | ---: | ---: | ---: | --- |
+| **jz → V8 wasm** | **1.01 ms** | **3.84×** | **1.2 kB** | **ok** |
+| V8 (node) raw JS | 3.87 ms | 1.00× | 1005 B | ok |
+| AssemblyScript (asc -O3 --runtime stub) | 9.15 ms | 0.42× | 1.5 kB | ok |
+| native C (clang -O3) | 0.95 ms | 4.08× | 32.9 kB | ok |
+| hand-WAT → V8 wasm | 3.59 ms | 1.11× | 355 B | ok |
+
+jz is 4.0× faster than V8 raw JS and 8.8× faster than AS. The i32 hot path
+(`Math.imul`, `|0`, `>>>0`) now lowers to raw `i32` ops without NaN-box
+overhead on every operation.
+
+### tokenizer — string scan with `charCodeAt` and integer accumulation
+
+| target | median | ×v8 | size | parity |
+| --- | ---: | ---: | ---: | --- |
+| **jz → V8 wasm** | **0.06 ms** | **2.26×** | **2.2 kB** | **ok** |
+| AssemblyScript (asc -O3 --runtime stub) | 0.06 ms | 2.15× | 1.6 kB | ok |
+| V8 (node) raw JS | 0.13 ms | 1.00× | 2.0 kB | ok |
+
+jz is 2.4× faster than V8 raw JS and now edges out AS by ~1.2× on this
+`charCodeAt`-heavy scan. Both are well ahead of V8.
+
+### callback — `Array.map` closure + i32 fold
+
+| target | median | ×v8 | size | parity |
+| --- | ---: | ---: | ---: | --- |
+| **jz → V8 wasm** | **0.26 ms** | **2.37×** | **1.4 kB** | **ok** |
+| V8 (node) raw JS | 0.62 ms | 1.00× | 1.3 kB | ok |
+| AssemblyScript (asc -O3 --runtime stub) | 0.80 ms | 0.78× | 1.9 kB | ok |
+
+jz is 2.3× faster than V8 raw JS and 2.9× faster than AS. Closure +
+`Array.map` lowers to a preallocated typed loop with no per-iteration alloc.
+V8's JIT does not inline the closure across the `map` boundary.
+
+### aos — array-of-object rows to typed arrays
+
+| target | median | ×v8 | size | parity |
+| --- | ---: | ---: | ---: | --- |
+| **jz → V8 wasm** | **0.69 ms** | **1.93×** | **1.8 kB** | **ok** |
+| V8 (node) raw JS | 1.33 ms | 1.00× | 1.1 kB | ok |
+| AssemblyScript (asc -O3 --runtime stub) | 1.40 ms | 0.95× | 2.1 kB | ok |
+
+jz is 1.9× faster than V8 raw JS and 2.0× faster than AS. Schema-slot
+reads are direct field offsets; the gap is small because the workload is
+memory-bound.
+
+### mandelbrot — 256×256 escape-time iteration
+
+| target | median | ×v8 | size | parity |
+| --- | ---: | ---: | ---: | --- |
+| AssemblyScript (asc -O3 --runtime stub) | 8.90 ms | 1.11× | 1.3 kB | ok |
+| **jz → V8 wasm** | **8.45 ms** | **1.17×** | **1.4 kB** | **ok** |
+| V8 (node) raw JS | 9.90 ms | 1.00× | 1.8 kB | ok |
+
+jz is 1.1× faster than V8 raw JS and ties AS. The dense f64 hot loop with
+conditional break compacts to 1.0 kB — the smallest wasm in the suite.
+
+### json — runtime `JSON.parse` plus stable-shape walk
+
+| target | median | ×v8 | size | parity |
+| --- | ---: | ---: | ---: | --- |
+| **jz → V8 wasm** | **0.21 ms** | **1.28×** | **9.9 kB** | **ok** |
+| V8 (node) raw JS | 0.27 ms | 1.00× | 1.2 kB | ok |
+
+jz is 1.3× faster than V8 raw JS. The runtime parser is specialized to the
+inferred JSON shape; AS is skipped because it cannot parse JSON at runtime.
+
+### sort — in-place heapsort over typed array
+
+| target | median | ×v8 | size | parity |
+| --- | ---: | ---: | ---: | --- |
+| **jz → V8 wasm** | **4.65 ms** | **1.67×** | **1.8 kB** | **ok** |
+| AssemblyScript (asc -O3 --runtime stub) | 7.96 ms | 0.98× | 1.9 kB | ok |
+| V8 (node) raw JS | 7.79 ms | 1.00× | 1.6 kB | ok |
+
+jz is 1.6× faster than V8 raw JS and 1.4× faster than AS. Call-heavy
+nested loops with typed-array index propagation stay on the i32 path.
+
+### crc32 — table-driven CRC-32 over byte buffer
+
+| target | median | ×v8 | size | parity |
+| --- | ---: | ---: | ---: | --- |
+| **jz → V8 wasm** | **8.74 ms** | **1.11×** | **1.5 kB** | **ok** |
+| AssemblyScript (asc -O3 --runtime stub) | 8.76 ms | 1.11× | 1.4 kB | ok |
+| V8 (node) raw JS | 9.71 ms | 1.00× | 1.8 kB | ok |
+
+jz is 1.2× faster than V8 raw JS and ties AS. Integer narrowing and
+typed-array parameter propagation keep the LUT lookup on raw i32.
+
+### Audio + image showcase (cross-language, bit-exact)
+
+Four standard kernels added to make the audio story concrete. All are written so
+the output is **bit-identical** across every engine and native target — integer
+math (bytebeat, blur) or transcendental-free f64 (fft, synth: in-source Taylor
+polynomials, not `Math.sin`, which differs per libm). Go's arm64 auto-FMA gives
+the documented `fma` parity class on the f64 cases.
+
+| case | jz | vs V8 | vs AS | vs fastest native | jz wasm |
+| --- | ---: | ---: | ---: | --- | ---: |
+| **synth** — osc + ADSR + biquad | **2.32 ms** | **1.33×** | **1.07×** | **beats all** (Rust 0.89×) | 2.0 kB |
+| **fft** — radix-2 Cooley–Tukey | **1.14 ms** | **1.27×** | **1.13×** | **ties** (Rust 1.07×) | 2.3 kB |
+| **blur** — RGBA box blur | **0.90 ms** | **9.4×** | **5.8×** | trails (native SIMDs the stencil, 1.5×) | 3.4 kB |
+| **bytebeat** — integer one-liner | **0.67 ms** | **3.7×** | **5.4×** | trails (native vectorizes, 1.3×) | 1.5 kB |
+
+The headline: jz beats the JS field (V8, AssemblyScript) on **every** audio/image
+case, **ties native on FFT**, and is the **fastest of all targets on the synth
+pipeline** — its per-sample loop is loop-carried (oscillator phase + biquad
+feedback), so native can't auto-vectorize it either, and jz's tight scalar f64
+codegen with no NaN-box overhead wins outright. The two stateless integer kernels
+(bytebeat, blur) are where `clang`/`zig`/`rustc` auto-vectorize an
+embarrassingly-parallel loop jz emits as scalar — native is the floor there, but
+jz still beats the JS field by 3.7–9.4× there. (Numbers: darwin/arm64, Apple M4 Max; the live snapshot
+is [results.json](results.json).)
+
+### watr — WAT-to-wasm compiler on small corpus
+
+| target | median | ×v8 | size | parity |
+| --- | ---: | ---: | ---: | --- |
+| V8 (node) raw JS | 1.38 ms | 1.00× | 2.6 kB | ok |
+| **jz → V8 wasm** | **1.17 ms** | **1.17×** | **238.4 kB** | **ok** |
+
+jz is 1.07× slower than V8 raw JS on this large compiler bundle. The size
+(144 kB) is the full jz-compiled watr parser + encoder + optimizer; V8's JIT
+has the advantage of profile-guided tiering on a long-running compiler.
+
+### Where the gaps live
+
+Aggregate geomean (jz / target):
+
+| target | speed | size |
+| --- | ---: | ---: |
+| V8 (node) | **0.40×** | — |
+| AssemblyScript | **0.36×** | **1.16×** |
+
+jz wins or ties V8 on every kernel case; the only V8 losses are the
+self-hosting rows `watr` (1.07×) and `jessie` (1.28×). AS is beaten on
+speed across the shared cases. On size jz is ~1.1× AS (geomean 1.16×,
+median 1.10×) — jz wins on speed, AS on bytes.
+
+Against the systems languages compiled to the same target — **WebAssembly, run in
+V8** — jz is **2.4× faster than C, 2.6× than Rust, and 4.9× than Go** (geomean),
+and **competitive with native C** itself (1.07×, the lone non-wasm reference).
+That apples-to-apples wasm field is the headline chart above.
+
+Case-by-case summary:
+
+* **biquad, mat4, poly, bitwise, callback: large wins.** jz beats V8 by
+  2.0–12.9× and AS by 1.4–9.1×. Typed-array scalarization, i32 narrowing,
+  and closure lowering are the drivers.
+* **tokenizer, aos, mandelbrot, sort, crc32: modest wins.** jz beats V8 by
+  1.1–2.4× and ties or beats AS. These are memory-bound or branch-heavy
+  workloads where codegen quality matters less than data layout.
+* **json: solid win.** jz beats V8 by 1.3× on runtime JSON parsing; AS
+  cannot run this case.
+* **alpha: the native floor.** jz beats V8 2.0× and every wasm rival (Rust/C/Go
+  → wasm), but trails the native-C reference ~14× (374 µs vs 26 µs) — alpha's hot
+  path is an unsigned i32 multiply. jz already lifts it to 128-bit SIMD (an i16x8
+  widening byte-map); native C pulls ahead on width alone — 256-bit AVX2 with a
+  fused byte multiply-add, run as native code with no per-load bounds checks. The
+  residual is the wasm-v128-vs-AVX2 ceiling, not a missing pass. A known gap we
+  publish rather than hide.
+* **watr: near parity.** jz is 1.07× slower than V8 on a 144 kB compiler
+  bundle. It is one of two self-host rows (with jessie) where V8's
+  profile-guided JIT tiers beat jz's AOT wasm.

package/bench/bench.svg

@@ -0,0 +1,102 @@
+<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 720 474" width="720" height="474" role="img" aria-label="jz benchmark — every rival compiled to WebAssembly, run in V8 · native C = reference; geometric mean across 22 benchmark cases · lower is faster, jz = 1.00× baseline; each ball's speed is proportional to that engine's geometric-mean runtime across the corpus">
+  <rect width="720" height="474" rx="12" fill="#ffffff"/>
+
+  <g font-family="-apple-system,BlinkMacSystemFont,'Segoe UI',Roboto,sans-serif">
+    <rect x="174" y="43.5" width="476" height="3" rx="1.5" fill="#edf0f2"/>
+    <line x1="174" y1="38" x2="174" y2="52" stroke="#ced4da" stroke-width="2"/>
+    <line x1="650" y1="38" x2="650" y2="52" stroke="#ced4da" stroke-width="2"/>
+    <text x="156" y="41" text-anchor="end" font-size="14" font-weight="700" fill="#000000">jz</text>
+    <text x="156" y="56" text-anchor="end" font-size="10" fill="#aeb4ba">-O3</text>
+    <text x="662" y="49" font-size="13" font-weight="700" fill="#000000">1.00×</text>
+    <circle cx="182.0" cy="45" r="8" fill="#000000">
+      <animate attributeName="cx" dur="1.6s" repeatCount="indefinite" calcMode="linear"
+        keyTimes="0;0.5;1" values="182.0;642.0;182.0" begin="-0.00s"/>
+    </circle>
+  </g>
+  <g font-family="-apple-system,BlinkMacSystemFont,'Segoe UI',Roboto,sans-serif">
+    <rect x="174" y="93.5" width="476" height="3" rx="1.5" fill="#edf0f2"/>
+    <line x1="174" y1="88" x2="174" y2="102" stroke="#ced4da" stroke-width="2"/>
+    <line x1="650" y1="88" x2="650" y2="102" stroke="#ced4da" stroke-width="2"/>
+    <text x="156" y="91" text-anchor="end" font-size="14" font-weight="500" fill="#343a40">native C</text>
+    <text x="156" y="106" text-anchor="end" font-size="10" fill="#aeb4ba">clang -O3 · ref</text>
+    <text x="662" y="99" font-size="13" font-weight="500" fill="#868e96">1.07×</text>
+    <circle cx="182.0" cy="95" r="8" fill="#adb5bd">
+      <animate attributeName="cx" dur="1.7120000000000002s" repeatCount="indefinite" calcMode="linear"
+        keyTimes="0;0.5;1" values="182.0;642.0;182.0" begin="-0.41s"/>
+    </circle>
+  </g>
+  <g font-family="-apple-system,BlinkMacSystemFont,'Segoe UI',Roboto,sans-serif">
+    <rect x="174" y="143.5" width="476" height="3" rx="1.5" fill="#edf0f2"/>
+    <line x1="174" y1="138" x2="174" y2="152" stroke="#ced4da" stroke-width="2"/>
+    <line x1="650" y1="138" x2="650" y2="152" stroke="#ced4da" stroke-width="2"/>
+    <text x="156" y="141" text-anchor="end" font-size="14" font-weight="500" fill="#343a40">C</text>
+    <text x="156" y="156" text-anchor="end" font-size="10" fill="#aeb4ba">zig cc → wasm</text>
+    <text x="662" y="149" font-size="13" font-weight="500" fill="#868e96">2.43×</text>
+    <circle cx="182.0" cy="145" r="8" fill="#adb5bd">
+      <animate attributeName="cx" dur="3.8880000000000003s" repeatCount="indefinite" calcMode="linear"
+        keyTimes="0;0.5;1" values="182.0;642.0;182.0" begin="-0.82s"/>
+    </circle>
+  </g>
+  <g font-family="-apple-system,BlinkMacSystemFont,'Segoe UI',Roboto,sans-serif">
+    <rect x="174" y="193.5" width="476" height="3" rx="1.5" fill="#edf0f2"/>
+    <line x1="174" y1="188" x2="174" y2="202" stroke="#ced4da" stroke-width="2"/>
+    <line x1="650" y1="188" x2="650" y2="202" stroke="#ced4da" stroke-width="2"/>
+    <text x="156" y="191" text-anchor="end" font-size="14" font-weight="500" fill="#343a40">Rust</text>
+    <text x="156" y="206" text-anchor="end" font-size="10" fill="#aeb4ba">rustc → wasm</text>
+    <text x="662" y="199" font-size="13" font-weight="500" fill="#868e96">2.63×</text>
+    <circle cx="182.0" cy="195" r="8" fill="#adb5bd">
+      <animate attributeName="cx" dur="4.208s" repeatCount="indefinite" calcMode="linear"
+        keyTimes="0;0.5;1" values="182.0;642.0;182.0" begin="-1.23s"/>
+    </circle>
+  </g>
+  <g font-family="-apple-system,BlinkMacSystemFont,'Segoe UI',Roboto,sans-serif">
+    <rect x="174" y="243.5" width="476" height="3" rx="1.5" fill="#edf0f2"/>
+    <line x1="174" y1="238" x2="174" y2="252" stroke="#ced4da" stroke-width="2"/>
+    <line x1="650" y1="238" x2="650" y2="252" stroke="#ced4da" stroke-width="2"/>
+    <text x="156" y="241" text-anchor="end" font-size="14" font-weight="500" fill="#343a40">V8</text>
+    <text x="156" y="256" text-anchor="end" font-size="10" fill="#aeb4ba">Node (JS)</text>
+    <text x="662" y="249" font-size="13" font-weight="500" fill="#868e96">2.69×</text>
+    <circle cx="182.0" cy="245" r="8" fill="#adb5bd">
+      <animate attributeName="cx" dur="4.304s" repeatCount="indefinite" calcMode="linear"
+        keyTimes="0;0.5;1" values="182.0;642.0;182.0" begin="-1.64s"/>
+    </circle>
+  </g>
+  <g font-family="-apple-system,BlinkMacSystemFont,'Segoe UI',Roboto,sans-serif">
+    <rect x="174" y="293.5" width="476" height="3" rx="1.5" fill="#edf0f2"/>
+    <line x1="174" y1="288" x2="174" y2="302" stroke="#ced4da" stroke-width="2"/>
+    <line x1="650" y1="288" x2="650" y2="302" stroke="#ced4da" stroke-width="2"/>
+    <text x="156" y="291" text-anchor="end" font-size="14" font-weight="500" fill="#343a40">AssemblyScript</text>
+    <text x="156" y="306" text-anchor="end" font-size="10" fill="#aeb4ba">asc -O3</text>
+    <text x="662" y="299" font-size="13" font-weight="500" fill="#868e96">2.80×</text>
+    <circle cx="182.0" cy="295" r="8" fill="#adb5bd">
+      <animate attributeName="cx" dur="4.4799999999999995s" repeatCount="indefinite" calcMode="linear"
+        keyTimes="0;0.5;1" values="182.0;642.0;182.0" begin="-2.05s"/>
+    </circle>
+  </g>
+  <g font-family="-apple-system,BlinkMacSystemFont,'Segoe UI',Roboto,sans-serif">
+    <rect x="174" y="343.5" width="476" height="3" rx="1.5" fill="#edf0f2"/>
+    <line x1="174" y1="338" x2="174" y2="352" stroke="#ced4da" stroke-width="2"/>
+    <line x1="650" y1="338" x2="650" y2="352" stroke="#ced4da" stroke-width="2"/>
+    <text x="156" y="341" text-anchor="end" font-size="14" font-weight="500" fill="#343a40">Porffor</text>
+    <text x="156" y="356" text-anchor="end" font-size="10" fill="#aeb4ba">runs 3 / 22</text>
+    <text x="662" y="349" font-size="13" font-weight="500" fill="#868e96">3.49×</text>
+    <circle cx="182.0" cy="345" r="8" fill="#adb5bd">
+      <animate attributeName="cx" dur="5.5840000000000005s" repeatCount="indefinite" calcMode="linear"
+        keyTimes="0;0.5;1" values="182.0;642.0;182.0" begin="-2.46s"/>
+    </circle>
+  </g>
+  <g font-family="-apple-system,BlinkMacSystemFont,'Segoe UI',Roboto,sans-serif">
+    <rect x="174" y="393.5" width="476" height="3" rx="1.5" fill="#edf0f2"/>
+    <line x1="174" y1="388" x2="174" y2="402" stroke="#ced4da" stroke-width="2"/>
+    <line x1="650" y1="388" x2="650" y2="402" stroke="#ced4da" stroke-width="2"/>
+    <text x="156" y="391" text-anchor="end" font-size="14" font-weight="500" fill="#343a40">Go</text>
+    <text x="156" y="406" text-anchor="end" font-size="10" fill="#aeb4ba">gc → wasm</text>
+    <text x="662" y="399" font-size="13" font-weight="500" fill="#868e96">4.91×</text>
+    <circle cx="182.0" cy="395" r="8" fill="#adb5bd">
+      <animate attributeName="cx" dur="7.856000000000001s" repeatCount="indefinite" calcMode="linear"
+        keyTimes="0;0.5;1" values="182.0;642.0;182.0" begin="-2.87s"/>
+    </circle>
+  </g>
+  <text x="360" y="440" text-anchor="middle" font-family="-apple-system,BlinkMacSystemFont,'Segoe UI',Roboto,sans-serif" font-size="11" font-weight="600" fill="#495057">every rival compiled to WebAssembly, run in V8 · native C = reference</text>
+  <text x="360" y="458" text-anchor="middle" font-family="-apple-system,BlinkMacSystemFont,'Segoe UI',Roboto,sans-serif" font-size="11" fill="#868e96">geometric mean across 22 benchmark cases · lower is faster, jz = 1.00× baseline</text>
+</svg>