Code that loads on demand starts at once, images decode beside their downloads, writes run compiled
Pages load and react faster and hold less memory. Code a page loads on demand now starts downloading the moment the page asks for it, images decode alongside their downloads instead of on the page's main thread, and animated pages keep their styles current without recomputing every rule. Large scripts load with a third less memory, inline boxes laid out again are reused, and a page that styles an element by what it contains restyles only that element. Functions that write object properties now run compiled, small helpers run inside their callers, and the performance profiler shows the layout and style a script forced as their own entries under the function that caused them. Three answers now match the reference browser: strict writes to plain values throw, a regular expression's lastIndex set through a computed key moves it, and setters on built-in prototypes run for plain values.
Code loaded on demand starts downloading at once
A page that loads part of its code only when it needs it asks for that code with a dynamic import. The browser used to fetch each such request one after another on the page's main thread when its turn came, so three imports on a slow connection meant three waits in a row with the page frozen. Now each import starts fetching on a background thread the moment it is called, imports asked for together download together, and the page keeps running meanwhile.
Images decode beside their downloads
Every image was decoded on the thread that loads the page, one after another once its bytes had arrived. Each image now decodes on the background thread that downloaded it, as soon as it lands, so a page with many large pictures is ready sooner and the loading thread stays free for the page's own work.
Animated pages keep their styles current cheaply
When a script measured a page while something on it was animating, every animating element had all its style rules recomputed, because an animation's previous frame left no record of the styles underneath it. Each element now keeps its styles from before the animation, so a new frame starts from them directly, and an animation that ended in between is dropped exactly. Style maps are also shared until something changes them, instead of copied whole.
Property writes and small helpers run compiled
Any function that wrote to an object, as in o.x = v or o[key] = v, was refused by the compiled tiers and ran in the interpreter, however often it was called. Writes now run compiled, through the very same rules the interpreter applies (setters, frozen and sealed objects, proxies, arrays), and every one of those rules is checked against the reference engine in every tier. Small helper functions such as type checks now run inside the compiled code that calls them, with a guard that falls back to a real call if the helper is ever replaced.
The profiler tells you where layout time really goes
When a script reads a size right after changing the page, the browser lays the page out before answering. The performance profiler used to charge that layout to whichever function happened to run next, so a one-line type check could look like the slowest function on a news site. Forced layout and style now appear as their own entries, directly under the function that forced them, and the rest of the profile is unchanged.
What changed 10 changes
Try it in your browser
Each check runs live in the browser you are reading with. Nothing is sent anywhere.