v0.1.41815 Nov 2026·Rendering, JavaScript & JIT, Memory & reading
Scripts run faster on busy pages
A speed release for the engine. Loops, calls and classes stay on the compiled paths more often, bitwise math and array callbacks do less work per step, and a class made inside a function no longer keeps that function's whole scope alive. On nine real pages, script, style and layout time fell by 5% overall against 0.1.417, and no page got slower.
Three of nine recorded real pages got measurably faster and the other six held level, measured on the same recorded network traffic for both versions. The gain comes from many small changes: compiled code that keeps more loops and calls, fewer copies of short values, and faster name checks.
A code-hosting page2.20 -> 1.97 sA technology news page1.82 -> 1.68 sA browser-support tables page156 -> 146 msNine real pages together8.33 -> 7.91 s, none slower
Classes, calls and loops on faster paths
A derived class made in a loop is built from a template again, calls between compiled functions pass their arguments in registers, functions with a rest parameter compile, and wide object literals stay in the fastest loop tier.
Derived class with super(), hot loop80 -> 0.9 msCalls between compiled helpers52 -> 19 msRest parameters in a hot call137 -> 25.5 msJSON.parse of many objects6.4 -> 3.9 ms
A class per call no longer piles up
A class or method defined inside a function used to keep that function's whole scope alive, with everything the scope held, even when the method used none of it. Methods that need no outer name now hang off the outermost scope, once a literal has made a few of them.
A class made per call, 400k instances, 10 calls797 -> 311 MB peak
What changed 34 changes
JavaScript & JIT
Speed: a derived class made in a hot loop is built from its template again (super(...) into a templated parent stores nothing new): 80 -> 0.9 ms.
JavaScript & JIT
Speed: a method loop handed between two compiled tiers races both and keeps the faster one, and stale method checks are rebuilt once they cost more than they save (method loop 6.4 -> 0.26 ms, a class per call 33 -> 0.5 ms). Switches: FLOATI_NO_HANDOFF_RACE, FLOATI_NO_STALE_AMORTISE.
Memory & reading
Memory: a class or method that reads no outer name hangs off the outermost scope instead of keeping the function's whole scope alive, judged at a literal's fourth closure (a class per call: 797 -> 311 MB). Switches: FLOATI_NO_FREE_TRIM, FLOATI_FREE_JUDGE_AFTER.
JavaScript & JIT
Speed: a helper declared inside a function that is called again and again no longer re-runs the choice of compiled tier for each new copy of it. Switch: FLOATI_NO_RACE_VERDICT_SHARE.
JavaScript & JIT
Speed: the fastest loop tier builds object literals with up to 32 keys (was 8): a 9-key literal no longer drops its loop to a slower tier, 6.8 -> 1.7 ms. Switch: FLOATI_NATIVE_OBJ_KEYS.
JavaScript & JIT
Speed: loops on the register tier keep their body compiled, and compiled code converts values to strings or numbers inline: array pushes 4.8 -> 0.6 ms, destructuring 59 -> 35 ms, sorting objects 7.8 -> 4.1 ms, template strings 14.3 -> 9.1 ms. Switches: FLOATI_NO_LOOP_AHEAD_NATIVE_ONLY, FLOATI_NO_PLAN_TO_PRIM_INLINE.
Memory & reading
Speed: string methods are remembered per call site, and s.replace(regex, text) skips the general call path.
JavaScript & JIT
Speed: functions with a rest parameter compile, and the rest array is made at entry: 137 -> 25.5 ms. Switch: FLOATI_NO_PLAN_REST.
JavaScript & JIT
Speed: calls between compiled functions pass their arguments in registers, and small numeric helpers are copied into their callers: 52 -> 19 ms. Switches: FLOATI_NO_CROSS_LEAN, FLOATI_NO_PEEL_ARITH.
JavaScript & JIT
Speed: JSON.parse checks for repeated keys with a set once an object has more than 16 keys: 6.4 -> 3.9 ms. Switch: FLOATI_NO_JSON_SEEN_SET.
JavaScript & JIT
Speed: Map and Set lookups with number keys and short string splits run inside compiled loops.
JavaScript & JIT
Speed: /regex/.test(x) on a regex literal runs inside compiled loops.
JavaScript & JIT
Speed: helpers that write their locals after a branch, read an array argument, or run a loop of their own are copied into compiled loops (a numeric helper loop 7.4 -> 0.9 us). Switches: FLOATI_NO_INLINE_LOOPS, FLOATI_NO_INLINE_LOOPS_NATIVE.
JavaScript & JIT
Speed: the optimizing compiler is 2.6 times faster on large functions.
JavaScript & JIT
Speed: a global regex replace for simple repeated patterns runs in one pass, and short indexOf and charCodeAt calls stay in compiled loops (regex row 10.2 -> 8.8 ms).
Memory & reading
Memory: function values point straight at their code, and the record each function carries shrank from 112 to 80 bytes. Switch: FLOATI_NO_FN_DIRECT.
Memory & reading
Speed: code run through indirect eval, new Function or an inserted script remembers where its names live, like a normal script. Switch: FLOATI_GLOBAL_EVAL_DYNAMIC.
JavaScript & JIT
Speed: bitwise operators convert their numbers to 32-bit integers without a floating-point division (a bitwise loop with the compiler off: 2.16 -> 1.81 s). Switch: FLOATI_NO_INT_WRAP.
Rendering
Speed: names up to 16 letters are compared without a library call, which every cached property and global lookup does. Switch: FLOATI_NO_SHORT_COMPARE.
JavaScript & JIT
Speed: map, filter, forEach, reduce and the other array methods pass each callback its value, index and array without allocating a list per element (compiler off: 4.3 -> 3.4 s). Switch: FLOATI_NO_CB_ARGS_STACK.
Rendering
Speed: a large style sheet is parsed in memoized runs of top-level rules, and selector plans are reused when the rule index is rebuilt.
Memory & reading
Speed: getComputedStyle reuses its property names and remembers converted colours.
Rendering
Speed: checking a class body for super walks the syntax tree instead of copying and printing it.
Memory & reading
Speed: the memory allocator takes back blocks freed by other threads only for pages whose own free list is empty.
JavaScript & JIT
Speed: promises and async resume records are built from one cached layout. Switch: FLOATI_NO_FIXED_SHAPES.
JavaScript & JIT
Fix: Object.keys of a promise no longer lists an internal handled mark after then() was called.
Rendering
Fix: an anonymous class has no name, and a property key names a class value as it names a function.
Rendering
Fix: a plain function call sees new.target as undefined, so a nested function no longer sees an outer constructor's. Switch: FLOATI_NO_PLAIN_NEWTARGET.
Rendering
Fix: var arguments inside a function keeps the arguments object instead of resetting it. Switch: FLOATI_VAR_ARGUMENTS_RESETS.
Rendering
Fix: computed keys in an object literal are converted in source order.
Rendering
Fix: [].slice.call(arguments) reads the current values of the parameters.
Rendering
Fix: a class name is in its dead zone until the class is declared, so typeof before the declaration throws as in the reference browser. Switch: FLOATI_NO_CLASS_TDZ.
Rendering
Fix: in strict code a function declared inside a block is not visible outside it. Switch: FLOATI_NO_ANNEXB_SCOPE_FIX.
Rendering
Engine: a new register interpreter now covers classes, generators, async functions, eval code, super and spread calls; it stays switched off (FLOATI_LAMINAR=1 turns it on) until it is faster on real pages.