Boosting WebAssembly Performance with Speculative Optimizations and Deopts in V8

Introduction

Recent advancements in the V8 JavaScript engine have brought speculative optimizations and deoptimization support to WebAssembly, leading to significant speed improvements—especially for garbage-collected languages compiled via WasmGC. With the release of Chrome M137, V8 now employs runtime feedback to generate more efficient machine code for WebAssembly modules, mirroring techniques long used for JavaScript. This article explores how these optimizations work, why they are now relevant for WebAssembly, and the performance gains they deliver.

Background: Speculative Optimizations in JavaScript Engines

Speculative optimization is a cornerstone of modern JIT compilation. By collecting feedback from previous executions, a JIT compiler can make educated guesses about future behavior—for example, assuming that an expression like a + b involves two integers rather than strings or floats. This allows the compiler to generate streamlined, type-specific machine code rather than a generic, slower implementation.

If a program later violates these assumptions (e.g., a string appears instead of an integer), the engine must revert to unoptimized code. This fallback mechanism is called deoptimization (or deopt). Deopts discard the optimized code and resume execution with simpler, less performant code while collecting more feedback for future re-optimization. JavaScript engines like V8 have relied on this pattern for years to deliver fast execution.

Why WebAssembly Was Different

Initially, WebAssembly did not require such speculative techniques. The first version of WebAssembly (Wasm 1.0) was designed with static typing and a low-level instruction set that allowed ahead-of-time optimization. Languages like C, C++, and Rust—commonly compiled to WebAssembly—already benefit from static analysis in toolchains like Emscripten (based on LLVM) and Binaryen. As a result, the generated binaries were already fairly optimized, reducing the need for runtime speculation.

Why Speculative Optimizations Are Now Needed for WebAssembly

The landscape changed with the introduction of WasmGC, the WebAssembly Garbage Collection proposal. WasmGC extends WebAssembly to support managed languages such as Java, Kotlin, and Dart. Its bytecode operates at a higher level of abstraction than Wasm 1.0, featuring rich types like structs and arrays, subtyping, and operations on these types. Such high-level constructs benefit greatly from speculative optimizations because the compiler can no longer rely solely on static information.

The Role of Speculative Inlining

One of the most impactful optimizations is speculative inline caching for indirect function calls (call_indirect). In WasmGC, polymorphic call sites are common, and inlining a specific callee based on runtime feedback can dramatically reduce overhead. Combined with deoptimization support, the engine can safely assume a particular target and deopt if the assumption fails.

Implementation in V8 and Chrome M137

The V8 team implemented two key features: speculative call_indirect inlining and deoptimization support for WebAssembly. Together, they enable the compiler to act on runtime feedback, generating better machine code that is tailored to actual program behavior.

Measured Performance Improvements

On a set of Dart microbenchmarks, the combination of both optimizations yields an average speedup of more than 50%. For larger, realistic applications and benchmarks, the speedup ranges from 1% to 8%. While the gains are modest on typical C++-compiled Wasm modules, they are transformative for WasmGC workloads.

Implications and Future Directions

Deoptimization support is not just a one-time improvement; it is a foundational building block for further optimizations. With the ability to speculatively inline and fall back gracefully, V8 can apply more aggressive transformations to WebAssembly code in the future—potentially closing the performance gap with native code even further.

As WebAssembly continues to evolve beyond its original niche, speculative optimizations will become increasingly important. The work done for Chrome M137 marks a significant step toward making WebAssembly a first-class target for dynamically typed and managed languages.

For more details, see the original V8 blog post on this topic.