Repository navigation
ZIPP 0.0.35
A patch release. The experimental optimizing tier (ZIPP_OPT=1, off by
default) compiles a function whose body starts with a loop instead of
handing it back, with the fix codeandsolder contributed for #93. Compiled
loops that read and write globals are faster again: 0.0.34's guard for
globals changed under running code had made some of them slower than in
0.0.33. And the interpreter's frameless calls and object allocation do
less work per call. Over 90 benchmark programs 0.0.35 takes 0.98x 0.0.34's
time with the JIT and is ahead of Node 24 on 72 of the 89 that Node runs,
where 0.0.34 is ahead on 71 in the same runs; interpreted it is level with
0.0.34 and ahead of node --jitless on 71 (0.0.34: 70). The bundled
applications are level with 0.0.34.
Thank you to @codeandsolder, who
reported #93 with a program reduced to the few lines that showed it, and
then worked out, tested and contributed the fix this release ships, with
its test.
New in 0.0.35
- The optimizing tier compiles loops at a function's start. 0.0.34
fixed #93 by having Tier O decline any function whose first instruction
is a loop's head (a release build ran such a function forever under
ZIPP_OPT=1). codeandsolder's fix gives such a function a preheader
that merges the values it is entered with and the values the loop
carries back, so Tier O compiles it. UnderZIPP_OPT=1, plain builds of
the same engine, 200,000 calls each: an integer loop at the start of a
function 62 ms against 69 with the decline, a floating-point one 16 ms
against 21, and a function that runs its loop once per call 2.4 times
faster. A loop nested in another runs slower under Tier O than under
the baseline tier, wherever it stands in the function; that is Tier O's
own code for the inner loop, and is for a later release. - Compiled code keeps its bail-outs out of the way. Every compiled
operation that can hand control back to the interpreter had its exit
block right behind it, jumped over on every successful run; 0.0.34 gave
one to every compiled global access. The blocks now come after the
function's code. With the JIT,class-prototype-hottakes 0.81x 0.0.34's
time,sparse-array0.85x,nbody0.86x,dataview-binary0.95x and
recursion-shapes0.97x. The first two, which 0.0.34 had made 1.09x and
1.14x slower than 0.0.33, take 211 and 75 ms, where 0.0.33 took 238 and
78 in the 0.0.34 notes' runs. - Frameless calls read captured variables once. A small function the
interpreter runs without a frame fetched its closure's list of captured
variables at every read and write; it now reads it once per call, and a
write of a number to a captured variable skips the garbage collector's
write barrier. Interpreted,upval_rw(a closure that writes a captured
counter, 20 million calls) takes 0.88x 0.0.34's time, 303 ms against
346, and is now ahead ofnode --jitless. - Allocation no longer reserves 32 KB of stack. The code that adds a
32 KB chunk to the heap's value storage built the chunk on the stack,
and as it was inlined, five functions that allocate objects reserved
and probed those 32 KB at every call. The chunk is now built where it
lives, out of line, and the release binary has none of those five
frames. Object-making rows gain 1 to 2% (new_objandobj_literal
interpreted 0.98x).
Downloads
| File | What it is |
|---|---|
zipp-0.0.35-windows-x86_64-portable.exe |
The Windows command line; run it from anywhere. |
zipp-0.0.35-windows-x86_64-installer.msi |
The same binary, installed for the current user into %LOCALAPPDATA%\Programs\ZIPP and added to PATH; no administrator rights. Uninstall from Settings > Apps. |
zipp-0.0.35-linux-x86_64 |
The Linux command line, x86-64 (glibc 2.35 or later). chmod +x it after downloading. |
zipp-0.0.35-linux-arm64 |
The same for 64-bit Arm. |
zipp-0.0.35-linux-armv7 |
The same for 32-bit Arm (hard float); interpreter only, and WebAssembly on wasmi. |
zipp-0.0.35-javascript.wasm |
The JavaScript engine for browsers, Node, Deno and Bun. |
zipp-0.0.35-javascript-typescript.wasm |
The same with TypeScript and TSX. |
zipp-0.0.35-javascript-lite.wasm |
The JavaScript core without Intl and Temporal, built for size. |
zipp-0.0.35-javascript-python.wasm |
JavaScript and Python, torch built in. |
zipp-0.0.35-javascript-python-base.wasm |
JavaScript and Python without torch. |
zipp-0.0.35-torch-package.wasm |
The torch package for the -python-base engine. |
zipp-0.0.35-<engine>.wasm.br |
Each WebAssembly module compressed with Brotli (quality 11), about a quarter of its size. Serve it with Content-Encoding: br and Content-Type: application/wasm, or let zipp.mjs load it; the plain .wasm is the default. |
zipp-0.0.35-wasm-embed-kit.zip |
zipp.mjs (the loader and sandbox, version 1.5.0, unchanged) and its types, the host SDK (1.4.0), the engine's TypeScript declarations, the browser GPU adapter, docs and three examples. |
SHA256SUMS |
Checksums of every file. |
The WebAssembly modules against 0.0.34's, as published, in bytes. Most of
this release's changes are in the native tiers, which the modules do not
have: each module is within 19 bytes of 0.0.34's, and each Brotli copy
within 0.02%. Part of that is the version and commit every module
records: they moved the torch package's Brotli copy by 70 bytes, though
its code did not change.
| Module | 0.0.34 | 0.0.35 | Change |
|---|---|---|---|
javascript.wasm |
4,855,173 | 4,855,175 | +2 B |
javascript.wasm.br |
1,253,897 | 1,253,800 | −0.01% |
javascript-typescript.wasm |
5,192,496 | 5,192,500 | +4 B |
javascript-typescript.wasm.br |
1,324,468 | 1,324,793 | +0.02% |
javascript-lite.wasm |
2,832,741 | 2,832,722 | −19 B |
javascript-lite.wasm.br |
778,582 | 778,494 | −0.01% |
javascript-python.wasm |
8,617,562 | 8,617,556 | −6 B |
javascript-python.wasm.br |
2,020,345 | 2,020,289 | −0.00% |
javascript-python-base.wasm |
6,580,465 | 6,580,459 | −6 B |
javascript-python-base.wasm.br |
1,645,580 | 1,645,492 | −0.01% |
torch-package.wasm |
2,163,109 | 2,163,109 | unchanged |
torch-package.wasm.br |
403,122 | 403,192 | +0.02% |
Performance
Measured on 11 November 2026 on native Windows x86-64 (Ryzen 9 9950X3D),
with no builds or test runs going: the published 0.0.34 Windows binary
against this release's Windows binary from the release build's dry run
(the source and the profile-guided recipe the release is built from), with
Node 24.19.0 in the same runs. Both ZIPP binaries run with address-space
randomization turned off and the code cache off, pinned to one core; the
figures are medians of 9 interleaved runs (7 for the three programs timed
separately). Every one of the 90 programs prints the same output under
0.0.34 and 0.0.35 in both lanes.
The 90 benchmark programs (the 78 of earlier releases, the seven
bundled applications and five TypeScript benchmarks compiled to
JavaScript). The geometric means are over the 87 programs one pass timed
with all three engines; the other three (the TypeScript bundle, which Node
cannot run, and two ES-module programs) were timed separately and are
given below, and the counts against Node include the two modules.
- With the JIT: 0.984x 0.0.34's time, faster on 49 of 87 and by more
than 2% on 32. The largest gains areclass-prototype-hot(0.81x),
sparse-array(0.85x),nbody(0.86x),prop_write(0.88x),
branch-control(0.90x),calls-closuresandraytracer(0.93x),
warm-router(0.94x), anddataview-binary,old-to-youngand
numbers-format-parse(0.95x). Slower by more than 2% in this pass:
arr_write(1.18x),proto_readandlived(1.04x),eval-function
andsurvival(1.03x) andcalls-baseline(1.02x). Timed again with 15
interleaved runs,arr_writeandproto_readtake 0.99x 0.0.34's time,
and plain builds of the two sources (no profile-guided compilation) are
between 0.95x and 1.02x on all six. - Against Node 24, with the JIT: 0.595x Node's time, ahead on 72 of
the 89, where 0.0.34 in the same runs takes 0.605x and is ahead on 71
(json-small-manychanged sides). Node is still ahead onbabel
(3.83x),class-features(2.10x),expr-compiler(2.02x), the eight
libraries (1.68x),collectionsandrecursion-shapes(1.65x),
generators-iterators(1.62x),dataview-binary(1.40x),
regex-unicode-sticky(1.37x),old-to-young(1.35x),
numbers-format-parse(1.31x),destructuring-spread(1.27x),
await-sustained(1.26x),large-heap-churn(1.20x),raytracer
(1.16x), Prettier (1.12x) andstrings-unicode-scan(1.01x). - Interpreted (
ZIPP_NOJIT=1 ZIPP_NO_RX_JIT=1, no native code at all):
0.997x 0.0.34's time, faster on 47 of 87 and by more than 2% on 11:
upval_rw(0.88x),dv_get_glob(0.90x), Preact server rendering
(0.91x),typedarray-math(0.95x),math_imul(0.97x) and six more by
2 to 3%. Slower by more than 2% in this pass:old-to-young(1.05x),
call_closure,warm-routerandclass-features(1.04x),
regex-compile-execandephemeral(1.03x), andeval-function,
large-heap-churn,collections-map-mixedandstrings-build-slice
(1.02x). Timed again with 15 interleaved runs,call_closuretakes
0.99x andwarm-router1.05x; plain builds of the two sources take
1.00x on both.warm-routeris the request loop whose speed depends
most on how the profile-guided build lays out the interpreter, as in
0.0.34. - Against
node --jitless, interpreted: 0.781x its time, ahead on 71
of the 89 programs Node runs, where 0.0.34 in the same runs takes 0.783x
and is ahead on 70 (upval_rwchanged sides). Node is still ahead on
babel(1.79x), the eight libraries (1.60x), Prettier (1.49x),
expr-compiler(1.44x),class-features(1.37x),class-prototype-hot
(1.34x),destructuring-spread(1.28x),new_obj(1.23x),
sparse-array(1.18x),await-sustained(1.16x),new_class(1.14x),
old-to-young(1.13x),large-heap-churn(1.10x),
generators-iterators(1.07x),strings-unicode-scanand
typedarray-math(1.05x),obj_literal(1.04x) anddv_get_glob
(1.01x). - The other three (medians of 7 runs, a pass of their own): the
TypeScript bundle, which Node cannot run (its bundledosis a stub),
takes 1.005x 0.0.34's time in both lanes. The two ES-module programs
take 0.96x and 0.91x 0.0.34's time with the JIT (entry,
nanoid-non-secure) and 0.95x and 1.00x interpreted, and are ahead of
Node in both lanes: 0.37x and 0.86x Node's time with the JIT, 0.73x and
0.87xnode --jitless's.
The published binary, built after this measurement from the same source by
the same recipe, was compared with the measured one on 20 of the programs
(9 interleaved runs in each lane): it prints the same output as 0.0.34 on
all 90 programs in both lanes, and is within 2% of the measured binary on
35 of the 40 comparisons. It is faster on Babel (0.98x in both lanes) and
on warm-router interpreted (0.96x, which leaves that program level with
0.0.34), and slower on nbody interpreted (1.04x) and dv_get_glob
interpreted (1.12x, which leaves it level with 0.0.34 rather than 0.90x,
and behind node --jitless by 1.12x rather than 1.01x).
Bundled applications, against Node 24.19.0. Each figure is the whole
run of one process, including compiling the bundle, the median of 9 runs
(TypeScript: 7, in the separate pass) with the engines interleaved, pinned
to one core, ZIPP's code cache off. A bundle is a large program, which ZIPP
interprets with or without the JIT.
With the JIT:
| Program | ZIPP 0.0.34 | ZIPP 0.0.35 | Node 24 |
|---|---|---|---|
Babel: @babel/standalone transforms about 20 KB of modern JSX twice |
2.93 s | 2.94 s | 0.77 s |
TypeScript: transpileModule on about 40 KB of classes, generics and enums |
916 ms | 921 ms | fails: its bundled os is a stub |
| Prettier: formats JavaScript, TypeScript and Markdown | 396 ms | 402 ms | 359 ms |
| marked, lodash, acorn, terser, three.js, immer, RxJS and date-fns | 570 ms | 576 ms | 344 ms |
| Vue server rendering | 75 ms | 75 ms | 75 ms |
| Preact server rendering | 63 ms | 63 ms | 65 ms |
| React server rendering | 59 ms | 58 ms | 65 ms |
Interpreter against interpreter (ZIPP_NOJIT=1 ZIPP_NO_RX_JIT=1, node --jitless):
| Program | ZIPP 0.0.34 | ZIPP 0.0.35 | Node 24 |
|---|---|---|---|
| Babel | 2.93 s | 2.90 s | 1.62 s |
| TypeScript | 889 ms | 893 ms | fails |
| Prettier | 391 ms | 399 ms | 268 ms |
| The eight libraries | 566 ms | 565 ms | 353 ms |
| Vue server rendering | 73 ms | 73 ms | 76 ms |
| Preact server rendering | 62 ms | 56 ms | 67 ms |
| React server rendering | 58 ms | 58 ms | 66 ms |
The bundles are level with 0.0.34, within 2% either way, except Preact
server rendering interpreted (0.91x).
Publishing
As for earlier releases, the engines the site serves are refreshed AFTER this
release exists, in one commit that:
- sets
zippEngineReleaseinlanding/package.jsonto0.0.35; - refreshes
landing/public/playground-runtimeandlanding/public/wasmfrom
zipp-0.0.35-javascript-python.wasmandzipp-0.0.35-javascript.wasm
(node crates/zipp-wasm/embed-kit/package.mjs extract, then
sync-playground.mjs --refresh-engine), SHA256SUMS-verified; - syncs the sandbox playground (
node landing/scripts/sync-sandbox.mjswith
the release's files) and rewrites the site's Brotli copies
(npm run compress:engines); - updates the version, size and SHA-256 that
landing/src/App.tsxand
landing/README.mdstate about the bundled engine.
Full Changelog: v0.0.34...v0.0.35