Skip to content

ZIPP v0.0.34

Choose a tag to compare

@github-actions github-actions released this 11 Nov 03:43
· 33 commits to main since this release

ZIPP 0.0.34

An interpreter release, with two fixes for compiled code. On the x86-64
command lines, interpreted loops and the calls they make now run through a
second, leaner form of the interpreter. That speeds up a program run with
the JIT off, and the loops of a large program, which is interpreted either
way. Over 90 benchmark programs 0.0.34 interpreted takes 0.83x 0.0.33's
time and is ahead of node --jitless on 71 of the 89 that Node runs,
where 0.0.33 is ahead on 56; with the JIT it is level with 0.0.33 and
ahead of Node 24 on 70 of the 89. The bundled applications, whose time is
in calls between many functions rather than in loops, are level with
0.0.33, within 3% either way. One bug
that 0.0.31 to 0.0.33 shipped is fixed: a global that was deleted, or
given a getter, a setter or read-only attributes, by something a running
compiled loop or function itself called went on being read and written as
the plain variable it had been until that code returned. And the
experimental optimizing tier (ZIPP_OPT=1, off by default) no longer runs
forever on a function whose body starts with a loop.

This build replaces the 0.0.34 published on 10 November and withdrawn
within the hour. In that build's profile-guided compilation the runner's
handlers had been turned into nested calls in places, and a request loop
(warm-router) ran 22% slower than in 0.0.33; it also did not have the
optimizing tier's fix. The files, sizes and checksums below are this
build's.

New in 0.0.34

  • Interpreted loops run through handlers that jump from one to the
    next.
    The interpreter's dispatch loops are each one large function,
    and an instruction there costs about fifty machine instructions. At a
    loop that has run a while the interpreter now hands the frame to a
    runner in which every instruction is a small function of its own, its
    operands decoded once, that does the work for the operand kinds a loop
    usually has and jumps straight to the next. Arithmetic and bitwise
    loops, typed-array and array loops, property reads and writes,
    charCodeAt scans, switches and DataView loops take between 0.44x and
    0.80x the time they took. The runner is in the x86-64 builds for now;
    the Arm builds and the WebAssembly engines run loops as before.
  • Calls stay in it. A small function whose body only computes is run
    without a frame; any other plain function or method gets its frame
    pushed and popped by the runner itself, so a loop that calls functions
    which call functions keeps its speed, and so does one whose calls go to
    a different closure each time (a router's handlers, a table of
    callbacks). Interpreted, call0 takes 0.78x 0.0.33's time,
    class_method 0.83x, calls-closures 0.84x, calls-baseline 0.86x,
    call_method 0.87x, call_closure and recursion-shapes 0.88x.
  • The rest of the language is reachable from it. String, array, Map,
    Set and number methods, element reads and writes of every kind, string
    building (a + b + c, s += x, template literals), getters and
    setters, object and array literals, closures, try blocks and every
    kind of for…of run from inside the runner, with errors, callbacks that
    re-enter it and garbage collection handled where they arise. Whatever it
    does not do is handed to the ordinary loop for that one instruction, and
    a loop that keeps being handed over is left to the ordinary loop for
    good, so a program the runner does not suit runs as it did.
  • Sites that many object layouts reach. A property read, write or
    method call in such a loop asks every layout its site has seen, as the
    ordinary loop does, so code over objects of several classes or shapes
    gains with the rest. polymorphic-objects-v2 takes 0.68x,
    property-ic-shapes 0.75x and shapes-megamorphic 0.79x.
  • DataView accessors in the interpreter are found by their place in
    DataView.prototype rather than by name, fused or split
    (dv.getUint32(o, le) with a global among its arguments). With the
    runner, dv_get takes 0.54x and dv_get_glob 0.56x.
  • Inherited properties and accessors, and super accessors, answer on
    one compare of a chain epoch instead of a walk that re-proves every hop.
    proto_read takes 0.47x interpreted and class-prototype-hot 0.81x.
  • Compiled code. A method whose body makes an instance is inlined with
    the instance made in place; a typed lane multiplies an integer by a
    positive constant as integers.

Downloads

File What it is
zipp-0.0.34-windows-x86_64-portable.exe The Windows command line; run it from anywhere.
zipp-0.0.34-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.34-linux-x86_64 The Linux command line, x86-64 (glibc 2.35 or later). chmod +x it after downloading.
zipp-0.0.34-linux-arm64 The same for 64-bit Arm.
zipp-0.0.34-linux-armv7 The same for 32-bit Arm (hard float); interpreter only, and WebAssembly on wasmi.
zipp-0.0.34-javascript.wasm The JavaScript engine for browsers, Node, Deno and Bun.
zipp-0.0.34-javascript-typescript.wasm The same with TypeScript and TSX.
zipp-0.0.34-javascript-lite.wasm The JavaScript core without Intl and Temporal, built for size.
zipp-0.0.34-javascript-python.wasm JavaScript and Python, torch built in.
zipp-0.0.34-javascript-python-base.wasm JavaScript and Python without torch.
zipp-0.0.34-torch-package.wasm The torch package for the -python-base engine.
zipp-0.0.34-<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.34-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.33's, in bytes (the 0.0.34 figures are
the release build's dry run at the release's engine source). The loop
runner is not in them, and nothing else in this release is large:

Module 0.0.33 0.0.34 Change
javascript.wasm 4,854,369 4,855,173 +0.02%
javascript.wasm.br 1,253,579 1,254,064 +0.04%
javascript-typescript.wasm 5,191,705 5,192,496 +0.02%
javascript-typescript.wasm.br 1,325,199 1,324,684 −0.04%
javascript-lite.wasm 2,832,203 2,832,741 +0.02%
javascript-lite.wasm.br 778,621 778,813 +0.02%
javascript-python.wasm 8,616,452 8,617,562 +0.01%
javascript-python.wasm.br 2,020,183 2,021,249 +0.05%
javascript-python-base.wasm 6,579,140 6,580,465 +0.02%
javascript-python-base.wasm.br 1,644,825 1,645,410 +0.04%
torch-package.wasm 2,163,109 2,163,109 unchanged

Changes in behaviour

  • ZIPP_NO_LOOP_RUNNER=1 keeps every loop in the ordinary interpreter
    loop, and ZIPP_NO_LOOP_FRAMES=1 keeps the runner from pushing frames;
    both are for comparison. Nothing else changes.
  • Building: the profile-guided builds compile their optimized stage with
    LLVM's indirect-call promotion off (-Cllvm-args=-disable-icp): the
    benchmark build (tools/pgo.sh, whose build contract is now v3) and, on
    x86-64, the release build (tools/release/pgo-build.sh). With it on, a
    build's training profile could turn the runner's hand-offs from one
    handler to the next into nested calls. tools/release/smoke-native.sh
    now runs a loop through the runner on x86-64 and fails if that happened.

Fixes

  • A global changed under running compiled code kept its old meaning.
    Compiled code reads and writes a global through its slot, and checked
    that the slot was still the variable only when the code was entered. If
    something that code called (a callback, a function, a getter) deleted
    the global, or put a getter, a setter or read-only attributes behind it
    with Object.defineProperty(globalThis, …), the running loop or function
    went on using the slot until it returned: reads answered the old value,
    a read of a deleted global returned instead of throwing a
    ReferenceError, writes skipped the setter and the read-only check, and
    a call through a replaced global function went to the old one. The
    interpreter was always right, and so was the next call of the compiled
    function; only the activation already running was wrong. Compiled code
    now notices the change at its next access of any global and hands that
    instruction to the interpreter.
  • The experimental optimizing tier never left a loop at a function's
    first instruction.
    With ZIPP_OPT=1 (off by default), a function whose
    body starts with a loop over its parameters, such as
    function f(n) { while (n > 0) n--; return n; }, was compiled with the
    values the loop carries read as the parameters again on every
    iteration: a release build never finished the call, and a debug build
    failed an assertion. 0.0.33 has it too. The tier now leaves such a
    function to the baseline compiler. Reported with its reduction by
    codeandsolder (#93).

Dependencies

  • unicode-properties 0.1.5 for the Python front end's lexer; the site's
    build tools (vite 8.3.6, @vitejs/plugin-react 6.2.1,
    @cloudflare/vite-plugin 1.68 with wrangler 4.157). Dependabot now
    leaves wrangler to the Cloudflare plugin, which pins its version.

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.33 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.33 and 0.0.34 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.

  • Interpreted (ZIPP_NOJIT=1 ZIPP_NO_RX_JIT=1, no native code at all):
    0.833x 0.0.33's time, faster on 72 of 87 and by more than 2% on 63. The
    largest gains are arr_write (0.44x), arr_read and proto_read
    (0.47x), g_counter and prop_read (0.51x), dv_get (0.54x),
    dv_get_glob (0.56x), f64_write (0.58x), f64_read and glob_loop
    (0.60x), typedarray-math (0.62x), i32_rw (0.63x), prop_write
    (0.64x), g_f64 (0.67x), bytecode-vm and polymorphic-objects-v2
    (0.68x), branch-control (0.72x), str_charcode (0.73x),
    arguments_len and try_catch (0.74x) and property-ic-shapes
    (0.75x). Slower by more than 2%: generators-iterators (1.13x),
    class-features (1.05x), expr-compiler (1.03x) and babel (1.02x).
    Two profile-guided builds of the same source can differ on
    generators-iterators by a tenth: the published binary, built after
    this measurement from the same source by the same recipe, takes 0.89x
    the measured binary's time on it, which puts it level with 0.0.33, and is
    level with it or faster on the seven other programs compared that way (7
    interleaved runs). warm-router, 1.22x in the withdrawn build, takes
    0.99x.
  • Against node --jitless, interpreted: 0.786x its time, ahead on 71
    of the 89 programs Node runs, where 0.0.33 in the same runs takes 0.943x
    and is ahead on 56. Fifteen programs changed sides and none went back:
    bytecode-vm, call_method, calls-closures, class_method,
    dataview-binary, dv_get, dv_get_glob, f64_write, g_f64,
    i32_rw, numbers-format-parse, polymorphic-objects,
    property-ic-shapes, proto_read and recursion-shapes. Node is still
    ahead on babel (1.80x), the eight libraries (1.62x), Prettier (1.50x),
    expr-compiler (1.45x), class-features (1.36x), class-prototype-hot
    (1.33x), destructuring-spread (1.27x), new_obj (1.25x),
    generators-iterators (1.22x), old-to-young (1.18x), new_class
    (1.17x), sparse-array (1.15x), await-sustained (1.14x),
    large-heap-churn (1.13x), upval_rw (1.07x), obj_literal (1.06x),
    strings-unicode-scan (1.05x) and typedarray-math (1.03x).
  • With the JIT: 0.997x 0.0.33's time; this release's work is the
    interpreter's, and a small program's hot code is compiled. Faster by more
    than 2% on 14 of 87 (burst and property-ic-shapes 0.92x,
    async-promise-chain and polymorphic-objects-v2 0.95x,
    accessors-proxy and ephemeral 0.96x), slower on 9: sparse-array
    (1.14x), class-prototype-hot (1.09x), sparse-array-v2 (1.05x),
    old-to-young and parse-large-js (1.04x), Vue server rendering and
    babel (1.03x), math_imul and nbody (1.02x).
  • Against Node 24, with the JIT: 0.615x Node's time, ahead on 70 of
    the 89, where 0.0.33 in the same runs takes 0.616x and is ahead on 69
    (accessors-proxy changed sides). Node is still ahead on babel
    (3.81x), expr-compiler (2.06x), class-features (1.99x),
    recursion-shapes (1.77x), collections (1.76x), the eight libraries
    and dataview-binary (1.67x), generators-iterators (1.53x),
    old-to-young (1.47x), destructuring-spread (1.44x),
    regex-unicode-sticky (1.40x), numbers-format-parse (1.34x),
    await-sustained and raytracer (1.25x), large-heap-churn (1.24x),
    Prettier (1.12x), Vue server rendering (1.07x), strings-unicode-scan
    (1.02x) and json-small-many (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 0.99x 0.0.33's time with the JIT and 0.96x interpreted. The two
    ES-module programs take 0.98x and 1.02x 0.0.33's time with the JIT
    (entry, nanoid-non-secure) and 0.90x and 0.92x interpreted, and are
    ahead of Node in both lanes: 0.38x and 0.94x Node's time with the JIT,
    0.79x and 0.85x 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.33 ZIPP 0.0.34 Node 24
Babel: @babel/standalone transforms about 20 KB of modern JSX twice 2.87 s 2.94 s 0.77 s
TypeScript: transpileModule on about 40 KB of classes, generics and enums 1.04 s 1.02 s fails: its bundled os is a stub
Prettier: formats JavaScript, TypeScript and Markdown 400 ms 400 ms 357 ms
marked, lodash, acorn, terser, three.js, immer, RxJS and date-fns 575 ms 584 ms 349 ms
Vue server rendering 75 ms 77 ms 72 ms
Preact server rendering 64 ms 62 ms 66 ms
React server rendering 60 ms 59 ms 67 ms

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

Program ZIPP 0.0.33 ZIPP 0.0.34 Node 24
Babel 2.89 s 2.96 s 1.64 s
TypeScript 1.09 s 1.04 s fails
Prettier 395 ms 401 ms 268 ms
The eight libraries 569 ms 578 ms 356 ms
Vue server rendering 74 ms 75 ms 80 ms
Preact server rendering 59 ms 58 ms 67 ms
React server rendering 61 ms 62 ms 69 ms

The bundles are level with 0.0.33, within 3% either way: their time is in
calls between many functions, where the runner is entered for a few
thousand loops and no more.

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.34;
  2. refreshes landing/public/playground-runtime and landing/public/wasm from
    zipp-0.0.34-javascript-python.wasm and zipp-0.0.34-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.