Engineering journal

An embedded script's stack positions are now counted from its own text, a sandbox's host requests and redirects are bounded and checked, a large script keeps one copy of its source and its compiled code between runs, and a heap ceiling collects before it convicts.

Eleven more issues from @takahashim, among them import.meta.url, unhandled-rejection reports and V8-format stacks, are fixed, and v0.0.28's interpreter runs Babel and the TypeScript compiler more than twice as fast as v0.0.27.

Bundled applications became the interpreter's yardstick: generators run as frames, a large module compiles in linear time, a bundle's object literals are planned again, and a program of 256 or more functions runs with its JIT off, which every bundle measured ran faster without.

Deleting from a large dictionary leaves a hole instead of shifting every later slot, a switch case on a literal dispatches once, and f.call, class statics, WeakMap methods and private fields skip the general paths.

v0.0.26 ships plain native files and one .wasm per engine with a default-deny sandbox loader, passes the latest Test262 unmodified on 64-bit and 32-bit builds, and imports torch in WebKit in under 0.4 s instead of about 32 s.

As 0.0.26 ships it: each WebAssembly engine is one .wasm carrying its own bindings, one loader runs any of them in a default-deny sandbox, and native downloads are plain files, Linux arm64 and armv7 included.

Seven more issues from @takahashim, from a regex that never finished compiling to an abort flag that slowed every instruction, are fixed, and v0.0.27 adds a Brotli copy of every WebAssembly engine.

The Test262 pin moves to tc39/test262 d53ebc8b of 13 October 2026, with iterator chunks, windows and includes, Promise.try and module sources passing: 96,229 of 96,230 executions, one documented expected failure, no corrections.

Each language's parser, compiler, runtime and native tier now live under src/lang/, a language is one entry of a table, docs/LANGUAGES.md describes how a language plugs into the shared VM, and the documentation moves under docs/.

The interpreter runs common instruction pairs as one dispatch, pushes and pops the common frame inline, and runs simple functions and loops in a small second loop that keeps its state in registers.

A diagnostic expansion suite of 21 workloads, run with the hostile suite against QuickJS, found where Zipp's interpreter still loses; Proxy traps, private names, Unicode strings, number formatting and eval were the first fixes.

After v0.0.25: the hostile bytecode-vm row back from 170 to 49 ms, a property cache's own-data hit taken inline in the interpreter, sorts and bitwise array callbacks without a call per element, and eval code that sees a replaced builtin.

Torch matrix products use AVX2 when the CPU has it, slice stores and index gradients run in native loops, short-lived tensor buffers are reclaimed by minor collections, and Python strings and instances recycle their buffers.

Ten more issues from @takahashim, from a Proxy on the global object's prototype chain to a heap ceiling a VM could not recover from, are fixed, and v0.0.25's safe-sandbox interpreter runs the benchmark rows in 0.84× Bellard's QuickJS's time.

Loops that build literals, create closures, destructure, spread, pop or hold a for-of compile now, with rest and arguments functions and the Object statics; construction and Object.assign run several times faster.

The repository's first eight GitHub issues, from typed-array own indices to a derived class's newTarget.prototype, are fixed with tests and answered, and v0.0.24 ships with smaller WebAssembly engines.

Python on the command line runs at 1.09x CPython 3.13 with fifteen programs faster than CPython, and torch training and tensor programs at 4.2x PyTorch's warm time, from 17x.

Memory that grows in place reaches the collector, an appending loop stops rewriting typeof's strings, builtins call compiled functions without the interpreter loop, and v0.0.23 ships with Python at 1.30x CPython.

A first profile of the WebAssembly modules makes four quadratic string workloads linear, Lite stops making every register access a call, and v0.0.22 ships with ZIPP Lite as an asset.

The native tiers serve the member calls the strict call order split apart, taking 11% off the 13 native rows; Unicode normalization moves to compact tables, and zipp py opens project files lazily.

Hosts can answer application-defined synchronous calls through an app bridge, and ZIPP Lite arrives: the JavaScript core without Intl and Temporal, built for size first.

Native dict, set and instance storage, direct calls and inlined attribute access take Python to about 1.75x CPython 3.13 with the JIT; a hello-world starts in 20 ms; the compiler reads Zipp's own syntax tree and emits the same bytecode every run.

Direct calls, fused Python-only instructions, native helpers, a JIT tier for hot loops, per-VM caches and small integers in the value word take the Python benchmark suite from 22.3x CPython 3.13 to about 2.1x.

Python without torch becomes a smaller WebAssembly variant with torch as a verified package, the Python parser becomes hand-written and then Zipp's own, and a prepared GPU step falls to 0.27 ms against PyTorch's 0.78.

Graph protocol versions 3 and 4 add masks, dropout, slicing and gathers bit for bit on five backends, and zipp py runs the same graphs on Vulkan, Direct3D 12 or Metal through wgpu.

Silent errors in eager torch are fixed, the layers, optimizers, dtypes, linalg, fft and distributions ordinary training code uses are added, and eager torch's heavy loops run natively: about 4.8x faster, same bytes.

Before building further, a pass over the model host, gpu-lab sessions, the WebAssembly host boundary, the dev server, the Python frontend and the JIT fixes the defects found, each with a regression test.

Qwen3 splits into stages that reproduce the whole model bit for bit, matmul_fixed accumulates in integers so every backend gives the same bits, the kernels build reproducibly, and v0.0.20 ships.

An experimental local-model plugin overlay arrives, and the GPU protocol learns to keep a checkpoint's Q4_K and Q6_K blocks and decode them inside the matmul on every backend.

v0.0.19 was held because the README promised more of torch.compile than it did; four tracks made it true - protocol-v2 capture, resident GPU sessions, native kernels, a second pass over the Python hot paths - and the release shipped with the two longest gate jobs run locally.

The pinned Test262 corpus passes 95,671 of 95,680 executions unmodified and 95,680 of 95,680 with five documented corrections; the DateTimeFormat shard passes 488 of 488; v0.0.18 is published.

zipp.org gains crawlable pages for the engine, Python, WebAssembly, GPU compute, Test262, benchmarks and architecture, all rendered from one JSON file, plus this journal with an RSS feed.

The experimental Python 3 frontend lands, compiling to the same register bytecode as JavaScript, together with WASM build variants, a folder-based playground, GPU graphs from Python and a Torch subset with GPU training.

Two releases close 38 tickets from the 11 September audits: VM rooting, coercion, TypedArray semantics, parser, GC and metadata, while preserving the exact 95,939 of 95,942 result on the previous corpus.

Embedding-API and host-boundary audit findings are fixed, browser Worker smoke tests and a reference host adapter land, releases are gated on the exact tagged commit, and a fresh benchmark capture shows the cost of strict call order.

Method calls now evaluate in specification order by default; the fused lowering that could be observed by a getter or proxy trap is used only where argument shapes provably cannot see it.

v0.0.14 adds the accel bridge; paired A/B measurements close five WASM interpreter pathologies, including a join with 300K retained strings from 8,423 ms to 138 ms.

v0.0.11 and v0.0.12 land register classes for tokenizer loops and inline stores into young dense arrays; the clean PGO capture at 8229b3fc becomes the public benchmark, with 21 of 30 rows faster than Node.

Six releases in one day, each raising a ceiling a real embedder had hit: a 32 MiB ArrayBuffer, a renewable instruction budget, byte-scheduled collections, a 512 MB heap.

The host boundary stops walking the whole heap per re-entry; an O(heap) walk is removed from the interpreter-only WASM build; JSON.stringify ×4000 drops from 919 ms to 8.5 ms; wasm-opt is dropped after measurement.

The first native and WebAssembly release; B249 takes bytecode-vm from 3.68× to 0.93× Node; module cycle roots restore 95,939 of 95,942; the performance ledger is archived at 881 KB.

A de-fused CallMethod lowering spikes the headline to 2.157× Node and drifts 24 Test262 rows; both are traced to one commit and reversed.

The 17-row hostile suite, built to make JavaScript stop looking like an ideal reducer, records a geomean of 0.961× Node for the first time.

The native and WebAssembly sandboxes are hardened for arbitrary hostile input, one day after ARM64 gets its first JIT tier.

Wave 19 decomposes the three rows that were 60% of the remaining gap on 23 August; the next day the headline ten rows record 0.9695× Node.

Running the same programs through the interpreter and every JIT tier and diffing the outputs finds five classes of silent wrong answers.

1.196× on the headline ten, with typedarray-math reaching Node parity for the first time.

After a two-week pause, the non-moving generational nursery is enabled by default, taking the headline capture from 1.283× to 1.212× Node.

The generational nursery's first stage is refuted by its own measurements before the third stage lands with a prover; the first landing page is committed the same day.

Profile-guided optimization takes the headline from 1.749× to 1.451× Node in one build change; two more waves the same day reach 1.330×.

Benchmark artifacts begin recording engine commit, dirty flag, competitor hashes and per-repetition schedules, after a harness was found able to name a commit it had never measured.

The README points at the repository's permanent address; the day before, the corpus refresh had left Test262 at 95,939 of 95,942.

Two phantom executions removed, then 22 of 30 remaining failures traced to the repository or runner rather than the engine; 99.995% on 95,846 executions.

Non-ISO Temporal calendars take Intl402 from 63.6% to 96.9% in a day; the core suite reaches 99.91%.

A new front end cuts parse-negative failures from 607 files to 80; honouring YAML list-form flags drops the denominator by 181 executions and the score is republished.

The WebAssembly embedding lands as a persistent VM that compiles once and re-enters later; fat LTO with one codegen unit buys about 2%; regex literals validated at compile time add 712 executions.

After six silent weeks, the Test262 runner is found to have been scoring a single execution mode; the honest pass rate is 96.97%. The same day, every crate but zipp-vm is deleted and the docs are rewritten against measurements.

The whole-function JIT tier is enabled by default (parse 4.1× → 3.3× Node) and docs/PERF_ROADMAP.md is written as a checkable path to V8 parity. Then the log goes quiet for six weeks.

Strings gain real lone-surrogate support, BigInt gains a two-tier i128 plus num-bigint implementation, and bench/real arrives as a ten-workload five-engine suite.

Module mode lands with top-level await and a Test262 module runner; modules become runtime structures on the explicit frame stack like everything else.

Indirect and global-scope eval land, followed by ShadowRealm, both as runtime structures rather than native recursion.

A forked regress engine for regular expressions, eleven TypedArray constructors, Proxy traps, Temporal type by type, the whole Intl namespace, a mark-sweep GC, and a 17,400-line vm.rs split into a folder.

The conformance runner lands one day after the pivot, and async generators are implemented as the largest single block of failing executions.

The register VM gets an x86-64 JIT for hot integer functions, OSR loop regions, call-free inline caches, scalar replacement, rope strings and a microtask loop, and beats V8 on loop.js at 26.5 ms against 28.0.

The ES5 object model arrives, a bytecode compiler and VM are built, two engines are tried, and by evening the clean-sheet explicit-frame register VM exists. So does the first retraction of a false performance claim.

The initial commit is a tree-walking interpreter for a small typed language; by the end of the day it has a Cranelift JIT, an LLVM tier, a mark-sweep GC, a gas-metered WebAssembly profile, a zero-knowledge back end and a TypeScript front end.