Same JS,
native WASM

Compile the numeric code you already test — no rewrite, no second toolchain.
No runtime, no GC, tiny output.

What is JZ?

JZ compiles the numeric JavaScript you already test into native-grade WASM.

Valid JZ is valid JS. The same source remains your JS implementation and fallback, or compiles to sandboxed, portable .wasm. No rewrite, runtime, GC, or type annotations; auto-SIMD and deterministic output.

Good for Not for
DSP, audio, synthesis UI, DOM, the frontend
Image, video, pixels Serving HTTP, hot I/O
Simulation, physics, games I/O-bound orchestration
Parsers, codecs, compression Dynamic, polymorphic, OOP
Scientific, numeric, ML Security crypto, big-ints
Hashing, checksums, RNG Glue, plumbing, orchestration
What is supported?

A minimal modern functional JS subset — no dynamic constructs or reflection. The jzify layer lowers legacy patterns, generators, and async/await.

Not supported evalProxy ReflectdefinePropertygetters/settersDOMNode Intl
Compat varfunctionswitchclass extendsthis superstatic #privatefunction* yieldasync/awaitasync function*for awaitPromiseusingprototype== !=instanceof
Strict let/const=>…spreaddestructuringimport/exportif/for/whiletry/catchnumbersstringsarrays objectstyped arraysMath JSON RegExpMap Setiterator helpersAtomics

Full list → · what's out by design, and why →

Why no types?
Ordinary code already carries useful type evidence: let x = 0.5, Float32Array, an array index, a loop counter. JZ infers it instead of turning the file into another language. Ambiguous values take a slower, always-correct dynamic path.
Why not AssemblyScript, Porffor?

AssemblyScript is a TypeScript dialect — can’t run in a JS engine. Porffor chases the whole JS spec that affects performance and cannot compile itself yet.

Why not Rust, Go, or C?

Rust, Go, and C are excellent when a rewrite and second toolchain make sense. JZ is for the hot path you want to keep in JavaScript: one source, one test suite, a JS fallback, and comparable WASM or native performance.

Is it fast?

The performance bar is uncompromising: on the cross-target corpus, the same source runs over 2× faster than V8 and Rust→WASM at near-native speed (geomean; per-case numbers and every loss are on the bench page). JZ auto-vectorizes where the Rust/C→WASM paths do not. A rival win remains a bug to close, not an exception to hide.

If you hit a slow case, report it →

Can it go native?

jz → wasm2c → clang -O3 produces a standalone native binary. See full pipeline →.

Can it compile itself?
JZ compiles itself to jz.wasm, and CI passes self-compiled build the full test suite. self-host CI status
Is it production ready?

It’s experimental (pre-1.0) — ABI can still shift.

But real code already ships on it: color-space v3 builds its precompiled 27-space WASM backend with JZ.

CI gates the full suite, test262, the bench, and the self-compile. A fuzzer diffs every kernel against the same source in V8.

And the exit is free: valid JZ is valid JS — drop the compile step and the same file keeps running.

How do I use it?
The CLI (jz kernel.js) or the API (compile()) produces a plain .wasm you load like any other module. Setup & options →

Examples