Skip to content

ZIPP v0.0.35

Latest

Choose a tag to compare

@github-actions github-actions released this 11 Nov 09:16
· 24 commits to main since this release

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. Under ZIPP_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-hot takes 0.81x 0.0.34's
    time, sparse-array 0.85x, nbody 0.86x, dataview-binary 0.95x and
    recursion-shapes 0.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 of node --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_obj and obj_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 are class-prototype-hot (0.81x),
    sparse-array (0.85x), nbody (0.86x), prop_write (0.88x),
    branch-control (0.90x), calls-closures and raytracer (0.93x),
    warm-router (0.94x), and dataview-binary, old-to-young and
    numbers-format-parse (0.95x). Slower by more than 2% in this pass:
    arr_write (1.18x), proto_read and lived (1.04x), eval-function
    and survival (1.03x) and calls-baseline (1.02x). Timed again with 15
    interleaved runs, arr_write and proto_read take 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-many changed sides). Node is still ahead on babel
    (3.83x), class-features (2.10x), expr-compiler (2.02x), the eight
    libraries (1.68x), collections and recursion-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) and strings-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-router and class-features (1.04x),
    regex-compile-exec and ephemeral (1.03x), and eval-function,
    large-heap-churn, collections-map-mixed and strings-build-slice
    (1.02x). Timed again with 15 interleaved runs, call_closure takes
    0.99x and warm-router 1.05x; plain builds of the two sources take
    1.00x on both. warm-router is 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_rw changed 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-scan and
    typedarray-math (1.05x), obj_literal (1.04x) and dv_get_glob
    (1.01x).
  • The other three (medians of 7 runs, a pass of their own): the
    TypeScript bundle, which Node cannot run (its bundled os is 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.87x node --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:

  1. sets zippEngineRelease in landing/package.json to 0.0.35;
  2. refreshes landing/public/playground-runtime and landing/public/wasm from
    zipp-0.0.35-javascript-python.wasm and zipp-0.0.35-javascript.wasm
    (node crates/zipp-wasm/embed-kit/package.mjs extract, then
    sync-playground.mjs --refresh-engine), SHA256SUMS-verified;
  3. syncs the sandbox playground (node landing/scripts/sync-sandbox.mjs with
    the release's files) and rewrites the site's Brotli copies
    (npm run compress:engines);
  4. updates the version, size and SHA-256 that landing/src/App.tsx and
    landing/README.md state about the bundled engine.

Full Changelog: v0.0.34...v0.0.35