v0.1.29216 Sep 2026·JavaScript & JIT, Networking

Recursive JavaScript runs dramatically faster, so the heaviest in-page computation feels quick

This release is pure speed for a fundamental building block of real web apps: functions that call themselves. A function that works through a tree, a nested list, or a run of numbers by calling itself is the pattern behind code editors, spreadsheets, parsers, JSON processing, and in-page game and graphics logic - and until now that pattern ran on Floati's slowest path, a plain step-by-step interpreter with no acceleration at all. Now Floati recognises the common shapes of that code and either compiles them straight to machine instructions or fast-tracks them, so the same work finishes many times sooner. And it does something no mainstream browser does: before it trusts the fast result, it proves - down to the last bit - that the fast answer is identical to the slow one, so speed never costs correctness. Nothing about how pages LOOK changes; this is raw execution speed, worked out entirely on your device, for the pages that ask the most of the browser.

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

JavaScript & JIT	Math-heavy recursion now compiles to native machine code. A function that calls itself and leans on the built-in math - the shape behind game and puzzle solvers, geometry, and divide-and-conquer number crunching - is turned into real machine instructions once it runs hot, and finishes many times faster than before while returning exactly the same answer.
JavaScript & JIT	Walking a list or array by recursion is much faster. The everyday pattern of a function that reads one item and calls itself for the rest now runs on Floati's fast execution path instead of its slowest one, so processing a run of data this way finishes far sooner.
JavaScript & JIT	Walking a tree of objects by recursion is much faster. Stepping through a nested structure - a document outline, a saved-data tree, a page's own structure - by a function that visits a node and then its children now takes the fast path too. This is one of the most common ways real code moves through structured data, so a lot of everyday in-page work speeds up at once.
JavaScript & JIT	Deep recursion stays fast and steady. A function that calls itself very many levels deep no longer hits a slow patch that could briefly make it crawl - it now stays predictable however far down it goes, and still reports the same clear error if it ever truly runs away.
JavaScript & JIT	Speed you can trust. Every one of these fast paths is held to a machine-checked promise that its result is bit-for-bit identical to the plain interpreter, and the compiled code is generated in a locked-down, tamper-resistant way - so the browser goes faster without opening the door that fast compilers usually do.