7 Key Facts About Speculative Optimizations for WebAssembly with Deopts and Inlining

Speculative optimizations have long powered fast JavaScript execution, but only recently have they been applied to WebAssembly in V8. With the release of Chrome M137, two key techniques—call-indirect inlining and deoptimization support—are now available, delivering dramatic speedups for WasmGC programs and laying the groundwork for future improvements. Here are the seven essential things you need to know about this breakthrough.

1. What Are Speculative Optimizations?

Speculative optimizations are a Just-In-Time (JIT) compiler technique that uses runtime feedback to make educated guesses about a program's behavior. For example, if a variable has always been an integer, the compiler may generate specialized machine code for integer addition instead of generic code that handles all types. If the guess turns out wrong, the compiler must revert to a safe execution path—a process called deoptimization (or deopt). This approach speeds up execution because the specialized code is much faster, while deopts keep correctness intact. In JavaScript, this is essential; for WebAssembly, it was historically unnecessary—until now.

2. Two New Optimizations: Speculative Call-Indirect Inlining and Deoptimization

V8's recent update introduces two complementary optimizations. Speculative call-indirect inlining guesses the target of an indirect function call and inlines it, avoiding the overhead of a generic call. Deoptimization support for WebAssembly provides a safety net: if the guess is wrong, V8 discards the optimized code and falls back to a valid path. Together, they allow the compiler to generate faster machine code by assuming specific call targets based on runtime feedback. This pairing is especially powerful for WasmGC, where indirect calls are common in managed languages like Dart or Kotlin.

3. Why WebAssembly Didn’t Need Deopts Before

WebAssembly 1.0, released in 2017, was designed for ahead-of-time (AOT) compilation from languages like C, C++, and Rust. These languages have strong static types and explicit memory models, so toolchains like Emscripten (based on LLVM) and Binaryen could produce highly optimized binaries without runtime feedback. Static information alone allowed efficient code generation. Deoptimization was irrelevant because there were few runtime ambiguities. This changed with the introduction of WasmGC, which brings higher-level features that benefit from speculation.

4. How WasmGC Changes the Game

The WebAssembly Garbage Collection (WasmGC) proposal adds support for high-level managed languages such as Java, Kotlin, and Dart. WasmGC bytecode includes rich type features like structs, arrays, and subtyping, which are more dynamic than WebAssembly 1.0's flat types. These features introduce runtime variability: for instance, a method call may have different implementations depending on the object's type. Speculative optimizations become crucial here because they can assume the most common type or call target, and deoptimize if a rare case occurs. Without speculation, the compiler must generate generic, slower code for all possibilities.

5. Performance Gains: Up to 50% on Microbenchmarks

The impact of combining speculative inlining and deopts is striking. On a set of Dart microbenchmarks, V8 saw an average speedup of over 50%. For larger, realistic applications and benchmarks, the improvement ranged from 1% to 8%. These numbers show that while the benefit is most dramatic on small, hot loops (common in microbenchmarks), even real-world apps gain noticeable performance. For developers using WasmGC, this means faster startup and smoother execution, especially in compute-intensive tasks.

6. How Deoptimization Works in V8 for WebAssembly

Deoptimization in WebAssembly mirrors the mechanism V8 uses for JavaScript. When a speculative assumption fails (e.g., an inlined function turns out to be the wrong one), V8 triggers a deopt: it abandons the optimized machine code, restores the program state to a safe point, and resumes execution using unoptimized code. Meanwhile, it collects fresh feedback that may trigger re-optimization later. Adding deopt support to WebAssembly required careful integration with V8's existing infrastructure, but the core concept remains the same: trade occasional rollbacks for consistently faster common-case execution.

7. Future Potential: A Building Block for More Optimizations

These optimizations are not just a one-time improvement—they open the door to future work. With deopts in place, V8 can now apply other speculative techniques to WebAssembly, such as type specialization or arithmetic simplification, that were previously too risky. As WasmGC matures and more languages compile to WebAssembly, the need for runtime-adaptive code generation will grow. The current implementation is a foundational step toward making WebAssembly execution as fast and flexible as JavaScript, while retaining its safe, sandboxed model.

In summary, V8's adoption of speculative optimizations for WebAssembly marks a significant evolution. By embracing the same runtime feedback and deoptimization strategies that made JavaScript so fast, WebAssembly—especially WasmGC—can now achieve tighter, more efficient machine code. Developers compiling managed languages to WebAssembly should expect noticeable performance boosts, and the architecture sets the stage for even smarter heuristics in the future.