v0.1.41711 Nov 2026Latest·Rendering, JavaScript & JIT, Web APIs & DOM, Memory & reading

Pages wait less for their own scripts and styles

A speed and correctness release for the engine. A script that loads a module with import() no longer stops the page while the module downloads, a class change restyles only what a :has() rule can actually see, and loops with try/catch, class constructors and Object.keys run several times faster. On three real pages, script, style and layout time fell by 16% overall against 0.1.416, and no page got slower.

Parity with the reference browser

75overall, as of v0.1.417

Security architecture72

DevTools / extensions73

Web APIs / DOM surface75

Networking85

Media85

Accessibility85

GPU / graphics acceleration95

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

No more waiting inside a script

When a page loaded a module with import(), the engine thread waited for the download before it went on, so timers and other scripts stood still. The download now finishes in the background and the import resolves from the event loop, as in the reference browser. A test fails if the engine thread ever waits for a module again.

A developer-docs page, style time1.31 -> 1.11 sThree real pages together10.9 -> 9.1 s, none slower

Restyle only what can change

A stylesheet with a :has() rule made every class toggle restyle and lay out the whole page, because the engine could not tell which :has() rules the change could flip. It now knows which attributes, class names and tags each rule reads, and skips the rules a change cannot reach. Text changes restyle their own element, not the page.

A code-hosting page, layout time3.36 -> 2.18 s

Faster loops, classes and lookups

Loops with try/catch, derived class constructors, Object.keys over an object and calls across many closures of one function all run on faster paths.

try/catch hot loop, 1e6143 -> 2 ms (a leading JavaScript runtime: 2.2)Object.keys/entries, 20 keys14.2 -> 7.5 ms (7.2)class super + getter230 -> about 75 ms

What changed 13 changes

JavaScript & JIT	Speed: a dynamic import() loads its module in the background and settles from the event loop; the engine thread no longer waits for the download. Switch: FLOATI_NO_ASYNC_DYN_IMPORT.
JavaScript & JIT	Speed: a try/catch inside a hot loop no longer nests deeper at every throw, and a function whose try keeps catching moves to the faster loop path. try/catch loop: 143 -> 2 ms. Switches: FLOATI_NO_OSR_CATCH_LOOP, FLOATI_NO_PLAN_CATCH_RETIRE.
Rendering	Speed: a class, attribute or child change skips every :has() rule it cannot flip, so it restyles only the part of the page it touched. Switches: FLOATI_NO_HAS_ATTR_HINT, FLOATI_NO_HAS_MIXED_HINT, FLOATI_NO_HAS_COMPOUND_MATCH.
Rendering	Speed: a text change restyles its own element instead of the whole page. Switch: FLOATI_NO_TEXT_AS_CHILDLIST.
Web APIs & DOM	Speed: selector parses, class keys, @property scans, the page's style text for getComputedStyle and a module's import scan are each made once instead of at every use. Switches: FLOATI_NO_DOC_STYLES_MEMO, FLOATI_NO_STATIC_DEPS_MEMO.
Memory & reading	Speed: a loop over getElementsByClassName or getElementsByTagName reads a remembered answer while the page is unchanged, instead of searching the page at every index. Switch: FLOATI_NO_COLLECTION_MEMO.
JavaScript & JIT	Speed: class constructors run compiled, super(...) goes straight to the parent, and a new instance gets room for its fields up front; a derived new is about 3.5 times faster. Switches: FLOATI_NO_PLAN_CLASS_CTOR, FLOATI_NO_FAST_SUPER, FLOATI_NO_FINAL_SHAPE, FLOATI_NO_ADD_IC.
JavaScript & JIT	Speed: a function whose inner loop is compiled but whose outer loop is not moves to its faster compiled path (Object.keys then a loop over the keys: 14.2 -> 7.5 ms). Switch: FLOATI_NO_LOOP_AHEAD_OUTER.
JavaScript & JIT	Speed: a call site that calls many closures of one function reuses its checks for all of them. Switch: FLOATI_NO_TEMPLATE_CALL_HIT.
JavaScript & JIT	Speed: the interpreter frees numbers and other simple values without a function call, 15 to 30% faster with the compiler off.
Rendering	Fix: querySelectorAll and getElementsByClassName see a class written between two queries; they could answer with the old class list.
Rendering	Fix: removing an element counts everything inside it for :has() rules, so a rule like ul:has(li) updates when a box holding the li is removed.
Rendering	Fix: class C extends a value that is not a constructor (a number, an arrow function, a plain object) throws a TypeError where the class is defined, as in the reference browser. Switch: FLOATI_NO_HERITAGE_CHECK.