v0.1.29516 Sep 2026·Rendering, JavaScript & JIT, Networking, Tabs & interface

Class-based JavaScript runs dramatically faster: calling a method through a list of objects is now many times quicker

This release makes one of the most common shapes in modern JavaScript much faster: looping over a list of objects and calling the same method on each. That pattern is everywhere - a component framework walking its elements, a game or physics loop stepping through its entities, a data grid rendering its rows, a scene graph visiting its nodes. Until now every such call took the browser's slow path: look the method up on the object, walk its class chain, then call it, once per item. Floati now learns the exact shape of the objects the first time the loop runs hot and compiles the call straight to native machine code, checking cheaply on each call that the object is still what it expects and instantly falling back if a page does something unusual. In a tight loop that calls a class method on each element of an array, the work now finishes many times sooner. As always the speed is proven: an independent check confirms the fast answer is identical to the slow one before it is trusted, and it all runs on your device.

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 4 changes

JavaScript & JIT	Calling a method on each object in a list is many times faster. The everyday pattern of looping over an array of objects and calling the same method on each one - the heart of component frameworks, game and physics loops, data grids and scene graphs - now compiles straight to native code once the loop runs hot, so it finishes many times sooner while returning exactly the same result.
JavaScript & JIT	Reading a field off those objects inside the loop got faster too. Once the browser knows the object's shape, reading one of its properties becomes a direct fetch from a fixed place rather than a lookup, which speeds up the field access that sits inside almost every such loop.
Rendering	It stays correct when your objects differ. Two different classes that happen to share the same field layout are now told apart precisely, so the fast path always calls the right method; and if a page changes an object's behaviour partway through, the very next call notices and adjusts safely.
Tabs & interface	Speed you can trust, by construction. Every one of these shortcuts is checked on each call and validated against an independent proof before the fast code is allowed to run, so the browser goes faster without ever risking a wrong answer, and falls back instantly and safely if a page does something unexpected.