Repository navigation
ZIPP v0.0.34
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,
charCodeAtscans, switches andDataViewloops 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,call0takes 0.78x 0.0.33's time,
class_method0.83x,calls-closures0.84x,calls-baseline0.86x,
call_method0.87x,call_closureandrecursion-shapes0.88x. - The rest of the language is reachable from it. String, array,
Map,
Setand 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,tryblocks and every
kind offor…ofrun 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-v2takes 0.68x,
property-ic-shapes0.75x andshapes-megamorphic0.79x. DataViewaccessors in the interpreter are found by their place in
DataView.prototyperather than by name, fused or split
(dv.getUint32(o, le)with a global among its arguments). With the
runner,dv_gettakes 0.54x anddv_get_glob0.56x.- Inherited properties and accessors, and
superaccessors, answer on
one compare of a chain epoch instead of a walk that re-proves every hop.
proto_readtakes 0.47x interpreted andclass-prototype-hot0.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=1keeps every loop in the ordinary interpreter
loop, andZIPP_NO_LOOP_FRAMES=1keeps 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
withObject.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. WithZIPP_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-properties0.1.5 for the Python front end's lexer; the site's
build tools (vite 8.3.6,@vitejs/plugin-react6.2.1,
@cloudflare/vite-plugin1.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 arearr_write(0.44x),arr_readandproto_read
(0.47x),g_counterandprop_read(0.51x),dv_get(0.54x),
dv_get_glob(0.56x),f64_write(0.58x),f64_readandglob_loop
(0.60x),typedarray-math(0.62x),i32_rw(0.63x),prop_write
(0.64x),g_f64(0.67x),bytecode-vmandpolymorphic-objects-v2
(0.68x),branch-control(0.72x),str_charcode(0.73x),
arguments_lenandtry_catch(0.74x) andproperty-ic-shapes
(0.75x). Slower by more than 2%:generators-iterators(1.13x),
class-features(1.05x),expr-compiler(1.03x) andbabel(1.02x).
Two profile-guided builds of the same source can differ on
generators-iteratorsby 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_readandrecursion-shapes. Node is still
ahead onbabel(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) andtypedarray-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 (burstandproperty-ic-shapes0.92x,
async-promise-chainandpolymorphic-objects-v20.95x,
accessors-proxyandephemeral0.96x), slower on 9:sparse-array
(1.14x),class-prototype-hot(1.09x),sparse-array-v2(1.05x),
old-to-youngandparse-large-js(1.04x), Vue server rendering and
babel(1.03x),math_imulandnbody(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-proxychanged sides). Node is still ahead onbabel
(3.81x),expr-compiler(2.06x),class-features(1.99x),
recursion-shapes(1.77x),collections(1.76x), the eight libraries
anddataview-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-sustainedandraytracer(1.25x),large-heap-churn(1.24x),
Prettier (1.12x), Vue server rendering (1.07x),strings-unicode-scan
(1.02x) andjson-small-many(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 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.85xnode --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:
- sets
zippEngineReleaseinlanding/package.jsonto0.0.34; - refreshes
landing/public/playground-runtimeandlanding/public/wasmfrom
zipp-0.0.34-javascript-python.wasmandzipp-0.0.34-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.