Styles read once, layouts redone only where they changed, built-ins in compiled loops
Pages that measure themselves, read their styles and run large scripts get faster. Reading a computed style no longer re-reads the whole style sheet, a page that measures its layout while animating, using container queries, holding focus or building shadow trees restyles only what changed, and selectors are parsed once instead of on every match. Large scripts are read about a fifth faster with 40 percent less memory. Many everyday built-in calls now run inside compiled loops, functions that create callbacks or check instanceof run on the compiled tier, and regular expressions over long accented text no longer slow to a crawl. Several answers now match the reference browser exactly: built-in prototypes list their methods, arrays and invalid dates convert as scripts expect, and instanceof throws and follows bound functions as the standard says.
Style reads and forced layouts do only the work that changed
When a script reads a size or a computed style right after changing the page, the browser has to restyle and lay out first. That step re-read the whole style sheet on every style read, and it restyled and relaid the entire page whenever any element was animating, the sheet used container queries, an element had focus or a change sat in a shadow tree. Each of those now restyles only the parts that changed and reuses the parsed sheet, and every shortcut is checked against the full computation on a corpus of real pages, with a switch to turn it off.
Built-in calls inside compiled loops
A loop that called indexOf, hasOwnProperty, a Date getter, Number.isInteger, Array.isArray or Object.keys dropped out of compiled code at that call. These methods only read their arguments, so compiled loops now call them in place, and the commonest ones run as machine code that scans bytes or reads a cached shape directly. Each one is checked against the method a script actually sees, so a script that replaces a built-in still gets its own version.
Large scripts start sooner and use less memory
Every script is read character by character before it runs. The reader kept a line number for every character of the file, compared each word against the whole keyword list and each operator against every operator, and a later step walked whole functions repeatedly to look for generators. Each token is now a third of its old size, line numbers are counted as the reader goes, and the generator check skips functions that declare none.
Callbacks and instanceof on the compiled tier
A function that created a callback over its own parameters, or that used instanceof, always ran in the interpreter, however often it was called. A style library on a news site calls one such function over 800,000 times while loading. Both now run on the compiled tier: a callback gets a scope built from the function's registers whenever the parameters it reads are never written, and instanceof shares one implementation with the interpreter. While at it, instanceof now throws for a right side that is not a function, follows bound functions, and no longer calls an object with a null prototype an Object.
What changed 12 changes
Try it in your browser
Each check runs live in the browser you are reading with. Nothing is sent anywhere.