Repository navigation
ZIPP v0.0.36
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 underzipp jsagainst 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
newsent 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 throughsuper(class-prototype-hot's call loops
never entered it), answersi in array, takes the computed key of
o[k] += vando[k]++, inverts a number (~x), and answers
Array.isArray,instanceofandObject.keysin 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-arraytakes 0.59x 0.0.35's time,typedarray-math0.85x,
obj_literal0.89x,new_class0.90x andnew_obj0.92x; the first
three are now ahead ofnode --jitless. toUpperCaseandtoLowerCasesearch 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-react6.3.0 and@cloudflare/vite-plugin1.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 areshapes-megamorphic(0.95x),
warm-router,collections-map-mixed,raytracerandshapes-stable
(0.96x), andstrings-unicode-scan,ephemeralandfinally-labels
(0.97x). Slower by more than 2% in this pass:lived(1.08x),
dict-churn(1.06x),await-sustained(1.05x),accessors-proxyand
markdown-render(1.04x),dv_get,sparse-array-v2,miscand
regex-unicode-sticky(1.03x) andrecursion-shapes(1.02x). Timed again
with 15 interleaved runs, six of them are level (0.98x to 1.01x);
livedtakes 1.07x,accessors-proxy1.04x,regex-unicode-sticky
1.03x andmisc1.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-scanchanged 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 passaccessors-proxyis ahead again (0.99x). Node is still
ahead onbabel(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
andold-to-young(1.41x),regex-unicode-sticky(1.39x),
numbers-format-parse(1.36x),await-sustainedand
destructuring-spread(1.34x),large-heap-churn(1.22x),raytracer
(1.13x), Prettier (1.10x) andf64_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_objand
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_methodandsurvival(1.04x to 1.05x),misc
(1.03x) andregex-unicode-sticky(1.02x). Timed again with 15
interleaved runs,proto_read, Preact andsurvivalare level (0.99x
to 1.01x),accessors-proxytakes 1.05x,regex-unicode-sticky1.04x,
class_method1.03x andmisc1.02x; plain builds of the two sources
take 0.95x, 0.99x and 1.02x on the middle three and 1.03x onmisc,
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_globand
strings-unicode-scan; none changed sides to Node. Node is still ahead
onbabel(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_objand
large-heap-churn(1.13x),generators-iterators(1.07x),new_class
(1.04x) andwarm-router(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.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.78xnode --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:
- sets
zippEngineReleaseinlanding/package.jsonto0.0.36; - refreshes
landing/public/playground-runtimeandlanding/public/wasmfrom
zipp-0.0.36-javascript-python.wasmandzipp-0.0.36-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.35...v0.0.36