v0.1.32628 Sep 2026·JavaScript & JIT

Recursive code calls itself directly, and building text in a loop beats the reference browser

Three JavaScript speed changes. Recursive functions that pass objects around call each other directly and run about 40 percent faster, building text piece by piece in a loop now runs as machine code and beats the reference browser on our benchmark, and a slowdown in text-scanning loops introduced two releases ago is gone.

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	Compiled functions call each other directly. When a function Floati has already compiled calls another one that is compiled too, the call now goes straight to it instead of through the general call path, which checked every other kind of callable thing first. A recursive walk over objects (the shape of tree walkers and many parsers) runs about 40 percent faster.
JavaScript & JIT	Building text in a loop is compiled. A loop like s += 'item ' + i + ';' used to run on Floati's interpreter-style tier because the right-hand side is a small concatenation of its own. It is now rewritten into a chain of appends to one growing piece of text, which the machine-code tier already handles: 9.9 to 2.8 milliseconds on our benchmark, against the reference browser's 3.4. Anything unusual (an object with its own toString in the mix) still takes the exact slower path.
JavaScript & JIT	Text-scanning loops are fast again. The fix for long nested loops in 0.1.324 added a check inside every compiled inner loop, and that alone cost a tokenizer-style loop about 20 percent. The check now lives outside the loop: an inner loop that runs past its time slice simply restarts that step with a bigger one, which is safe because compiled loops only write their results at the end of each step.