Breaking: Chrome M137 Introduces Speculative Optimizations for WebAssembly
San Francisco, CA – The V8 JavaScript engine has shipped a set of speculative optimizations for WebAssembly (Wasm) in Google Chrome M137, delivering significant speedups particularly for WasmGC applications. The optimizations—speculative call_indirect inlining and deoptimization support—allow the engine to generate faster machine code by making assumptions based on runtime feedback.
According to V8 engineers, the combination of these two techniques yields an average speedup of over 50% on a suite of Dart microbenchmarks. Larger, real-world applications and benchmarks show improvements between 1% and 8%. "This is a major step forward for WasmGC performance," said a V8 team spokesperson. "We're now able to apply the same speculative strategies that have turbocharged JavaScript to WebAssembly."
Background: Why Speculative Optimizations Were Not Needed for WebAssembly Until Now
Speculative optimizations are a cornerstone of fast JavaScript execution. JIT compilers like V8 collect runtime feedback to make assumptions—for instance, assuming that a + b is an integer addition—and generate specialized machine code. If an assumption later breaks, the engine performs a deoptimization (deopt), discarding optimized code and falling back to slower, generic code.
WebAssembly 1.0, launched in 2017, did not require such techniques. Wasm programs are statically typed and often compiled from C, C++, or Rust—languages that are more amenable to ahead-of-time (AOT) optimization. Toolchains like Emscripten and Binaryen already produce well-optimized binaries, reducing the need for runtime speculation.
WasmGC Changes the Game
The introduction of the WebAssembly Garbage Collection (WasmGC) proposal has altered the landscape. WasmGC targets managed languages such as Java, Kotlin, and Dart, emitting higher-level bytecode with rich types—structs, arrays, and subtyping. This bytecode is less amenable to static optimization, making speculative techniques more valuable.
One critical optimization is inlining—replacing a function call with the function's body. With speculative call_indirect inlining, V8 can inline indirect calls based on previous type information, then deoptimize if the predicted type fails. "Without deopts, we'd have to generate conservative code, leaving performance on the table," the spokesperson added.
What This Means for WebAssembly Developers
Developers using WasmGC can expect noticeably faster execution, especially for Dart-based web apps. The optimizations are automatic in Chrome M137 and later versions. Future work may extend speculative optimizations to other Wasm features, further closing the performance gap with native code.
For projects compiling traditional languages (C/C++/Rust) to Wasm 1.0, the impact is minimal—their code was already well-optimized. But as WasmGC adoption grows, these V8 enhancements provide a foundation for even more aggressive optimizations down the road.
Key Takeaways
- Performance boost: Up to 50% faster on Dart microbenchmarks; 1–8% on larger apps.
- Two-pronged approach: Speculative inlining + deopt support for WebAssembly.
- Shipped in Chrome M137 (stable channel, June 2024).
- Enables future optimizations for WasmGC and beyond.