Skip to content

ZIPP v0.0.36

Choose a tag to compare

@github-actions github-actions released this 17 Nov 11:36
· 47 commits to main since this release

ZIPP 0.0.36

A fix release, with speed work in the interpreter and in loading scripts.
A minor garbage collection could free an object a program was still
using: a closure held by one of the first object literals a program built
was swept and its slot handed to something else. It happened in 0.0.33,
0.0.34 and 0.0.35 under zipp js, in the interpreter and, by default, in
large programs such as the bundled applications, which run without the
JIT. The loop runner, the interpreter's tier for hot loops, now takes ten
more kinds of operation, so loops that left it at their first new,
super, in, instanceof, Object.keys or Array.isArray stay in it.
Over 90 benchmark programs 0.0.36 takes 0.997x 0.0.35's time with the JIT
and is ahead of Node 24 on 70 of the 89 that Node runs (0.0.35: 71 in the
same runs); interpreted it takes 0.984x 0.0.35's time and is ahead of
node --jitless on 75 (0.0.35: 70). The bundled applications are within
3% of 0.0.35.

Fixed in 0.0.36

  • A live closure could be swept. The command line's Node-compatible
    runtime builds object literals of its own while it starts, and an object
    literal takes its object from a batch the heap makes ahead of time. When
    setup finished, the collector marked everything allocated so far as old,
    the batch's unused objects with them, while they stayed in the batch.
    The program's first object literals then took those objects: old objects
    whose first values, all young, were recorded nowhere a minor collection
    looks, so a minor collection could free what they held while they still
    held it. A Proxy whose handler was { ownKeys: function () { ... } },
    built early in a program, later threw "proxy handler's ownKeys trap is
    not a function": the slot held an array by then. 0.0.36 gives the batch
    up before setup's objects are marked old, as every collection does before
    it runs. With the nursery verifier on (ZIPP_NURSERY_VERIFY=1, which
    checks every minor collection against a full one), 0.0.35 reports a
    missed object on 16 of the 90 benchmark programs in the interpreter and
    on Babel, Prettier, the eight libraries and React server rendering by
    default; 0.0.36 on none. A new test runs the first literals of a program
    through 300,000 allocations under zipp js against Node's output, in the
    interpreter and by default, with and without the verifier.

New in 0.0.36

  • The loop runner takes more of what loops do. Every new sent a loop
    back to the dispatch loop; the runner now constructs with a plain
    constructor function and with a base class whose constructor has no
    field initializers, and pushes the constructor's frame itself. It also
    reads and writes through super (class-prototype-hot's call loops
    never entered it), answers i in array, takes the computed key of
    o[k] += v and o[k]++, inverts a number (~x), and answers
    Array.isArray, instanceof and Object.keys in the cases their fast
    paths do; a property read no cache answers (a class instance's
    constructor, a function's own property) is finished in the runner
    instead of sending the loop out. An object literal's key plan is checked
    once per function rather than once per object. Interpreted,
    sparse-array takes 0.59x 0.0.35's time, typedarray-math 0.85x,
    obj_literal 0.89x, new_class 0.90x and new_obj 0.92x; the first
    three are now ahead of node --jitless.
  • toUpperCase and toLowerCase search less. Mapping a non-ASCII
    character searched the whole table of case runs (186 or 303 entries);
    native builds now index the runs by 256-code-point page and search only
    those that reach the character's page. A program that upper- and
    lower-cases 13,172 characters of Latin, Greek and Cyrillic text 200 times
    takes 29.4 ms against 35.0 (plain builds of the two sources). The
    WebAssembly modules keep the plain search, which is smaller.
  • Loading a script does less. The index of line starts that error
    positions use skips eight plain bytes at a time instead of reading one;
    a string literal with no escape is copied from the source in one step
    instead of being decoded into UTF-16 and encoded back; and an ASCII
    identifier is not checked as UTF-8 a second time. Loading Prettier's
    bundle runs 7% fewer instructions and Vue's 4%; on Windows, compiling
    Prettier, Babel and the eight libraries without running them takes 2 to
    5% less time (plain builds).
  • Dependencies: wgpu 30.0.2 and bumpalo 3.20.4 in the engine; vite
    8.3.8, @vitejs/plugin-react 6.3.0 and @cloudflare/vite-plugin 1.69.1
    on the site.
  • CI: the Python lane runs on Ubuntu 24.04. GitHub's ubuntu-latest
    moved to an image whose CPython (3.14) accepts syntax that ZIPP's Python
    3.13 front end does not yet parse (except A, B: without parentheses,
    template strings), and the front end's conformance check compares with
    the runner's own CPython.

Downloads

File What it is
zipp-0.0.36-windows-x86_64-portable.exe The Windows command line; run it from anywhere.
zipp-0.0.36-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.36-linux-x86_64 The Linux command line, x86-64 (glibc 2.35 or later). chmod +x it after downloading.
zipp-0.0.36-linux-arm64 The same for 64-bit Arm.
zipp-0.0.36-linux-armv7 The same for 32-bit Arm (hard float); interpreter only, and WebAssembly on wasmi.
zipp-0.0.36-javascript.wasm The JavaScript engine for browsers, Node, Deno and Bun.
zipp-0.0.36-javascript-typescript.wasm The same with TypeScript and TSX.
zipp-0.0.36-javascript-lite.wasm The JavaScript core without Intl and Temporal, built for size.
zipp-0.0.36-javascript-python.wasm JavaScript and Python, torch built in.
zipp-0.0.36-javascript-python-base.wasm JavaScript and Python without torch.
zipp-0.0.36-torch-package.wasm The torch package for the -python-base engine.
zipp-0.0.36-<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.36-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.35's, as published, in bytes. The
loop runner and the case-mapping index are native only; what the
modules gained, a few hundred bytes raw, is mostly the faster reading of
string literals and source positions; each Brotli copy is within 0.04% of
0.0.35's.

Module 0.0.35 0.0.36 Change
javascript.wasm 4,855,175 4,855,614 +439 B
javascript.wasm.br 1,253,800 1,254,271 +0.04%
javascript-typescript.wasm 5,192,500 5,192,939 +439 B
javascript-typescript.wasm.br 1,324,793 1,324,540 −0.02%
javascript-lite.wasm 2,832,722 2,833,088 +366 B
javascript-lite.wasm.br 778,494 778,499 +0.00%
javascript-python.wasm 8,617,556 8,618,110 +554 B
javascript-python.wasm.br 2,020,289 2,020,983 +0.03%
javascript-python-base.wasm 6,580,459 6,581,225 +766 B
javascript-python-base.wasm.br 1,645,492 1,644,977 −0.03%
torch-package.wasm 2,163,109 2,163,109 unchanged
torch-package.wasm.br 403,192 403,222 +0.01%

Performance

Measured on 17 November 2026 on native Windows x86-64 (Ryzen 9 9950X3D),
with no builds or test runs going: the published 0.0.35 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.35 and 0.0.36 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.997x 0.0.35's time, faster on 53 of 87 and by more
    than 2% on 16. The largest gains are shapes-megamorphic (0.95x),
    warm-router, collections-map-mixed, raytracer and shapes-stable
    (0.96x), and strings-unicode-scan, ephemeral and finally-labels
    (0.97x). Slower by more than 2% in this pass: lived (1.08x),
    dict-churn (1.06x), await-sustained (1.05x), accessors-proxy and
    markdown-render (1.04x), dv_get, sparse-array-v2, misc and
    regex-unicode-sticky (1.03x) and recursion-shapes (1.02x). Timed again
    with 15 interleaved runs, six of them are level (0.98x to 1.01x);
    lived takes 1.07x, accessors-proxy 1.04x, regex-unicode-sticky
    1.03x and misc 1.02x, and plain builds of the two sources (no
    profile-guided compilation) are level on all four (0.98x to 1.01x): the
    difference is the profile-guided build's layout, not the code.
  • Against Node 24, with the JIT: 0.602x Node's time, ahead on 70 of the
    89, where 0.0.35 in the same runs takes 0.603x and is ahead on 71.
    strings-unicode-scan changed sides to ZIPP; accessors-proxy (1.01x)
    and Vue server rendering (1.00x) changed sides to Node by a hair, and in
    the 15-run pass accessors-proxy is ahead again (0.99x). Node is still
    ahead on babel (3.79x), class-features (2.14x), expr-compiler
    (2.10x), the eight libraries (1.70x), recursion-shapes (1.66x),
    collections (1.65x), generators-iterators (1.56x), dataview-binary
    and old-to-young (1.41x), regex-unicode-sticky (1.39x),
    numbers-format-parse (1.36x), await-sustained and
    destructuring-spread (1.34x), large-heap-churn (1.22x), raytracer
    (1.13x), Prettier (1.10x) and f64_write (1.05x).
  • Interpreted (ZIPP_NOJIT=1 ZIPP_NO_RX_JIT=1, no native code at all):
    0.984x 0.0.35's time, faster on 50 of 87 and by more than 2% on 18:
    sparse-array (0.59x), dv_get_glob (0.84x), typedarray-math
    (0.85x), obj_literal (0.89x), new_class (0.90x), new_obj and
    try_catch (0.92x), mutators (0.93x) and ten more by 2 to 4%. Slower
    by more than 2% in this pass: accessors-proxy, proto_read,
    preact-ssr, class_method and survival (1.04x to 1.05x), misc
    (1.03x) and regex-unicode-sticky (1.02x). Timed again with 15
    interleaved runs, proto_read, Preact and survival are level (0.99x
    to 1.01x), accessors-proxy takes 1.05x, regex-unicode-sticky 1.04x,
    class_method 1.03x and misc 1.02x; plain builds of the two sources
    take 0.95x, 0.99x and 1.02x on the middle three and 1.03x on misc,
    whose small loss is the code's.
  • Against node --jitless, interpreted: 0.759x its time, ahead on 75
    of the 89 programs Node runs, where 0.0.35 in the same runs takes 0.772x
    and is ahead on 70. Five programs changed sides to ZIPP: sparse-array,
    typedarray-math, obj_literal, dv_get_glob and
    strings-unicode-scan; none changed sides to Node. Node is still ahead
    on babel (1.86x), the eight libraries (1.65x), Prettier (1.55x),
    expr-compiler (1.43x), class-features (1.37x),
    class-prototype-hot (1.33x), destructuring-spread (1.29x),
    await-sustained (1.18x), old-to-young (1.14x), new_obj and
    large-heap-churn (1.13x), generators-iterators (1.07x), new_class
    (1.04x) and warm-router (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.01x 0.0.35's time with the JIT and 1.02x interpreted. The two
    ES-module programs take 1.00x 0.0.35's time with the JIT (entry,
    nanoid-non-secure) and 0.98x and 0.97x interpreted, and are ahead of
    Node in both lanes: 0.38x and 0.88x Node's time with the JIT, 0.64x and
    0.78x node --jitless's.

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.35 ZIPP 0.0.36 Node 24
Babel: @babel/standalone transforms about 20 KB of modern JSX twice 2.85 s 2.88 s 0.76 s
TypeScript: transpileModule on about 40 KB of classes, generics and enums 967 ms 975 ms fails: its bundled os is a stub
Prettier: formats JavaScript, TypeScript and Markdown 395 ms 389 ms 354 ms
marked, lodash, acorn, terser, three.js, immer, RxJS and date-fns 562 ms 578 ms 341 ms
Vue server rendering 74 ms 74 ms 74 ms
Preact server rendering 62 ms 61 ms 62 ms
React server rendering 58 ms 58 ms 62 ms

Interpreter against interpreter (ZIPP_NOJIT=1 ZIPP_NO_RX_JIT=1, node --jitless):

Program ZIPP 0.0.35 ZIPP 0.0.36 Node 24
Babel 3.04 s 3.09 s 1.67 s
TypeScript 951 ms 969 ms fails
Prettier 410 ms 418 ms 270 ms
The eight libraries 580 ms 595 ms 362 ms
Vue server rendering 76 ms 75 ms 77 ms
Preact server rendering 58 ms 60 ms 69 ms
React server rendering 60 ms 58 ms 67 ms

The bundles are within 3% of 0.0.35. Timed again with 15 interleaved runs,
Babel takes 1.01x 0.0.35's time in both lanes, Prettier 1.00x with the JIT
and 0.99x interpreted, the eight libraries 1.02x in both lanes and Preact
server rendering interpreted 1.01x.

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.36;
  2. refreshes landing/public/playground-runtime and landing/public/wasm from
    zipp-0.0.36-javascript-python.wasm and zipp-0.0.36-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.35...v0.0.36