v0.1.896 Aug 2026·JavaScript & JIT, Web APIs & DOM

Native object writes, and the 64-bit binary arrays

This release is mostly speed and correctness rather than new coverage, and the numbers below are held honestly where the work does not move them. The loop compiler already turned object-heavy loops into a compact instruction stream; it now compiles them all the way to native machine code as well. Writing a field on an object walked out of a list (the everyday 'a[i].total = ...' shape that turns records into results in place) and reading or writing fields on a single hot object (a counter, an accumulator, a configuration object) both used to stop at the register-machine tier; they now reach the native tier, running about two and a half times faster on a warm object, proven equal to the interpreter across more than a hundred thousand fuzzed programs. Because the shapes already compiled, this is a speed-up, not new coverage, so the performance figure is held where it honestly is. Two more fixes round it out: a display:contents wrapper - an element that is meant to vanish and let its children stand in its place - now reports an empty box from getBoundingClientRect exactly as the reference browser does, where before it wrongly reported the union of its children, which can mislead layout-measuring page code; and the two 64-bit binary array types, BigInt64Array and BigUint64Array, are now present, so code that stores whole 64-bit integers (database ids, bitfields, hashes) runs instead of throwing on a missing class. That lifts the measured Web API surface from 519 to 521 of 577 - two members out of 577 is under half a percent and does not move the aspect, so that figure too stays where it honestly is. Every change carries a test and the engine gate holds at 6375 of 6375.

Parity with the reference browser

74overall, as of v0.1.343

Web APIs / DOM surface42

Security architecture66

GPU / graphics acceleration68

DevTools / extensions72

Networking85

Media85

Accessibility85

Real-world site compatibility99

HTML parsing100

CSS parsing + selectors100

Layout: block / flex / grid / tables / writing-modes100

Paint + visual100

JavaScript language100

JavaScript performance (JIT)100

HTML parsing100

What changed 3 changes

JavaScript & JIT	Faster: object-field writes and single-object reads and writes in a hot loop now compile to native machine code. Writing a[i].field across a list, and reading or writing fields on one warm object (a counter or accumulator), previously stopped at the register-machine tier; they now reach the native tier and run about 2.4x faster on a cache-warm object. The fast path defers each write to the end of the pass and drops it if the pass bails, so a mid-loop fallback never writes twice, and it is proven equal to the interpreter across 100,000+ fuzzed programs with the gate at 6375 of 6375. This is a speed-up of an already-compiled shape, so the performance figure is held honestly.
Web APIs & DOM	Fixed: a display:contents element - one that generates no box of its own and lets its children lay out in its place - now returns an empty rectangle from getBoundingClientRect, matching the reference browser, where before it reported the union of its passed-through children. Layout was already correct; this corrects the box-less wrapper's reported geometry, which page code that measures elements reads. Found by a generated geometry sweep that compares every element's box against the reference browser, and carries a regression test.
JavaScript & JIT	New: BigInt64Array and BigUint64Array, the two 64-bit-integer binary array types, whose elements are BigInt rather than Number so they hold whole 64-bit values exactly (past the 2^53 an ordinary number can represent). Verified against the reference browser for 64-bit precision, signed and unsigned wrapping on store, shared-buffer aliasing and out-of-range reads; the loop compiler correctly steps aside to the interpreter for them since its number path cannot represent 64-bit integers. This lifts the measured Web API surface from 519 to 521 of 577 - too small to move the aspect, held honestly.