Chrome M137 Delivers Major Speed Boost for WebAssembly with Speculative Inlining and Deoptimization

Google has released a groundbreaking update for WebAssembly in Chrome M137, introducing speculative call_indirect inlining and deoptimization support that dramatically accelerate execution, especially for programs using the WebAssembly Garbage Collection (WasmGC) proposal. The new optimizations, implemented in the V8 JavaScript engine, leverage runtime feedback to generate more efficient machine code, resulting in performance gains exceeding 50% on Dart microbenchmarks and up to 8% on larger real-world applications.

“This is a significant leap forward for WebAssembly, particularly for languages like Dart, Java, and Kotlin that target WasmGC,” said a V8 team engineer. “By making assumptions based on observed behavior, we can inline and optimize code that was previously impossible to accelerate.” The update shipped with Chrome M137 and is already available to all users.

Background

Speculative optimizations have long been the backbone of fast JavaScript execution. JIT compilers generate optimized machine code by assuming, for example, that a + b always involves integers, based on past feedback. When assumptions fail, V8 performs a deoptimization—throwing away the optimized code and falling back to unoptimized execution, allowing safe and efficient tiering.

Until now, WebAssembly did not require such tactics because its static typing and ahead-of-time compilation from C, C++, or Rust already produced well-optimized binaries. The original WebAssembly 1.0 spec, launched in 2017, offered limited dynamic behavior, making speculative techniques unnecessary. However, the evolution of WebAssembly with WasmGC has changed the landscape.

Why Now?

The WasmGC proposal introduces high-level features like structs, arrays, subtyping, and rich type operations—elements that are less amenable to static optimization. “WasmGC bytecode is much closer to the source language’s object model, which means the compiler can benefit hugely from runtime feedback,” explained the engineer. Speculative inlining and deopts, originally developed for JavaScript, now become essential tools for WebAssembly.

One critical optimization is inlining—replacing a function call with the function’s body itself. Combined with deoptimization, V8 can aggressively inline indirect calls (like call_indirect) by predicting the target function, then gracefully handle mismatches with a deopt. This eliminates overhead and unlocks further optimizations.

Performance Impact

Testing on a suite of Dart microbenchmarks showed average speedups of more than 50% when both optimizations were enabled. For larger, realistic applications and industry benchmarks, the improvements ranged from 1% to 8%. The team expects these numbers to grow as future V8 releases build on the deoptimization framework.

• Dart microbenchmarks: >50% average speedup
• Large applications: 1–8% speedup
• Future potential: Foundation for even more aggressive optimizations

What This Means

For developers compiling managed languages to WebAssembly, Chrome M137’s speculative optimizations promise faster load times and smoother execution. WasmGC applications—which previously suffered from slower performance compared to hand-optimized C++ WebAssembly—now close the gap significantly. The deoptimization infrastructure also paves the way for upcoming V8 features, such as on-stack replacement and speculative multi-tier compilation.

“This update is not just about today’s speedups,” the engineer noted. “Deopts are the cornerstone for many advanced JIT techniques we plan to bring to WebAssembly. It’s a foundational change that will keep accelerating WebAssembly for years to come.”

Users and developers can immediately benefit by updating to the latest Chrome version. For those curious about the technical details, V8’s official blog post offers an in-depth explanation of the implementation.