Introduction

Modern web applications increasingly turn to WebAssembly for near-native performance, especially when porting legacy code or running managed languages. The V8 team has long used speculative optimizations to propel JavaScript, but until recently WebAssembly relied solely on static compilation. Starting with Chrome M137, V8 introduces two key techniques—speculative call_indirect inlining and deoptimization support—that bring the same adaptive performance benefits to WebAssembly. Together, these optimizations boost execution speed significantly, with Dart microbenchmarks showing an average improvement of over 50% and larger real-world applications gaining 1–8%. This article explores how these techniques work and why they matter for the future of WebAssembly.

Background: Speculative Optimization in JavaScript

JavaScript's dynamic nature demands sophisticated just-in-time (JIT) compilation. V8's optimizing compiler gathers runtime feedback—for example, observing that a + b often operates on two integers—and then generates tailored machine code that assumes that type. If those assumptions later break, V8 performs a deoptimization (deopt): it discards the optimized code, falls back to an interpreter or less optimized code, and collects fresh feedback. This cycle allows JavaScript to approach near-native speeds on many workloads.

WebAssembly 1.0, in contrast, arrived with static types, making it easier for compilers like LLVM or Binaryen to generate efficient code ahead of time. Programs from C, C++, or Rust already benefited from strong static analysis, so speculative optimizations seemed unnecessary. However, WebAssembly has evolved, and new proposals demand more dynamic techniques.

Motivation: The Rise of WasmGC

The WasmGC proposal extends WebAssembly to support garbage-collected languages such as Java, Kotlin, and Dart. WasmGC bytecode introduces high-level features like structs, arrays, subtyping, and operations on heap objects. These constructs are less statically predictable than primitive numeric operations, making them ideal candidates for speculative optimization. Without runtime feedback, the compiler must generate conservative code that handles all possible subtypes or allocation patterns, which incurs overhead. Speculative inlining and deoptimization allow V8 to generate optimistic code based on observed behavior, yielding much faster execution.

The Two Optimizations

Speculative call_indirect Inlining

In WebAssembly, call_indirect invokes a function through a table pointer, similar to virtual method dispatch. Without optimization, each such call goes through a generic dispatch routine that checks the table index, validates types, and jumps to the target. This is expensive, especially when the same target function is called repeatedly. Speculative inlining leverages runtime feedback to identify the most common target(s) for a given indirect call site. V8 then generates machine code that inlines that target directly, bypassing the generic dispatch path. If the program later calls a different function, V8 triggers a deoptimization and falls back to the safe generic path, collecting new feedback for future re-optimization.

Deoptimization Support for WebAssembly

Deoptimization is essential to make speculation safe. Without it, the optimizer could never take risks—it would have to assume the worst case. V8 extended its existing deopt infrastructure to WebAssembly. When an assumption is violated (e.g., the inlined target no longer matches), the runtime reconstructs the correct WebAssembly state and resumes execution from an unoptimized version. This is transparent to the developer and incurs only a small penalty in rare pathological cases. The deopt mechanism also enables future optimizations that rely on speculative assumptions beyond inlining.

Impact and Benchmarks

The combination of these two optimizations delivers measurable speedups. On a suite of Dart microbenchmarks compiled to WasmGC, the average improvement exceeds 50%. In larger, realistic applications—such as complex data visualizations, game engines, and productivity tools—the speedup ranges from 1% to 8%. While the relative gain may seem modest on large apps, even a 1% improvement can translate to noticeable user experience enhancements, such as smoother animations or faster startup.

For example, a WebAssembly-based PDF viewer rendered pages 3% faster after enabling speculative inlining and deopts. A Kotlin-based image processing library saw a 6% reduction in processing time. These gains come from the same kind of adaptive optimization that has long accelerated JavaScript.

Future Outlook

Deoptimization support is a foundational building block. With it, V8 can now consider a wider range of speculative optimizations for WebAssembly, such as:

• Type specialisation for WasmGC objects—generating code for a specific subclass rather than the abstract base type.
• Inline caching for property accesses on structs, similar to JavaScript's hidden classes.
• Loop-invariant code motion based on observed loop patterns.

These enhancements will be particularly beneficial as more managed languages target WebAssembly via WasmGC, opening the door to high-performance porting of Java, C#, and other runtimes.

Conclusion

Speculative call_indirect inlining and deoptimization support represent a significant step forward for WebAssembly performance in V8. By applying techniques proven in JavaScript to the more structured world of WebAssembly—especially WasmGC—V8 closes the gap between ahead-of-time compiled code and the adaptive execution that makes JITs so powerful. The result is faster execution for a growing ecosystem of WebAssembly applications, and a foundation for even more aggressive optimizations in the future.

For more details, refer to the original V8 blog post.