The JetStream benchmark suite has long been a key tool for measuring browser engine performance. Now, in collaboration with Google and Mozilla, the WebKit team has introduced JetStream 3.0—a major update that rethinks how we evaluate speed and efficiency. This new release goes beyond a simple refresh; it represents a fundamental shift in benchmarking, especially for WebAssembly (Wasm) workloads and large-scale web applications. Below, we answer common questions about what changed, why it matters, and how browser engines have evolved to meet modern demands.
What is JetStream 3 and who created it?
JetStream 3 is the latest iteration of the cross-browser benchmark suite developed jointly by engineers from Google, Mozilla, and Apple. It measures the performance of web applications by running a series of tests that simulate real-world tasks. The suite covers a wide range of workloads from JavaScript to WebAssembly, and it is designed to reflect contemporary web development practices. Unlike its predecessor, JetStream 3 incorporates feedback from all major browser vendors to ensure it remains relevant and challenging. The collaborative effort means that improvements seen in one engine are not artificially favored, making the benchmark a fair yardstick for performance comparisons across browsers.
Why was a new version of JetStream needed?
As the web evolves, older benchmarks become outdated. The optimizations that once drove major gains—like speeding up simple loops or reducing memory allocations—become standard. Over time, further improvements tend to be highly specific to the exact test cases, rather than benefiting the broader ecosystem. JetStream 2, for example, was released when WebAssembly was still emerging. Since then, engines have dramatically optimized their Wasm handling, and the benchmark’s scoring formula no longer captured realistic performance. JetStream 3 addresses this by updating workloads and introducing new measurement techniques that reflect how developers actually use web technologies today. It also accounts for the fact that modern web pages are more complex, with heavy use of Wasm for critical tasks.
How does JetStream 3 change the way WebAssembly performance is measured?
In JetStream 2, WebAssembly performance was graded in two phases: startup and runtime. This split was based on the original use case of large C/C++ applications—like video games—where a long initial load was acceptable in exchange for high throughput. However, modern Wasm use has expanded to include small, frequently used modules (e.g., image decoders, UI helpers). JetStream 3 eliminates the separate startup phase and instead integrates Wasm tasks into a unified performance score. This shift recognizes that startups are now so fast that a separate metric is meaningless; a 2‑ms instantiation time is negligible compared to the overall workload. By treating Wasm like any other code, the benchmark better represents real-world scenarios where Wasm is in the critical path.
What was the “infinity problem” in JetStream 2?
The infinity problem arose because browser engines had become extraordinarily good at instantiating WebAssembly modules. In JetStream 2, the time for each iteration was measured using Date.now(), which had a resolution of about 1 millisecond. When engines optimized startup to under 1 ms, the measured time rounded down to zero. Since the scoring formula was Score = 5000 / Time, a zero time produced an infinite score. This broke the benchmark’s ability to compare browsers—an infinite score would overshadow all other results. The situation was so severe that the JetStream 2.2 patch had to clamp the sub-score to 5000. While a “zero” startup sounds like a victory, it actually highlighted that the benchmark was no longer challenging, as optimizations had pushed beyond its ability to measure.
How have browser engines improved beyond JetStream 2’s Wasm tests?
Engine teams, including those at WebKit, have made dramatic strides in WebAssembly instantiation speed. In JetStream 2’s era, optimizing a few milliseconds off a 100 ms startup was meaningful. Today, after years of work, engines can instantiate many modules in under 2 ms—or even zero measurable time. This was achieved through techniques like lazy compilation, caching compiled code, and optimizing the validation pipeline. For smaller workloads, the startup time effectively became zero, rendering the separate “Startup” phase obsolete. Furthermore, engines shifted focus to runtime performance and integration with JavaScript, because Wasm is now used frequently in interactive web pages where startup overhead must be invisible to users. JetStream 3 embraces this new reality by testing Wasm as part of a cohesive workflow, not an isolated startup event.
Why is WebAssembly critical for modern web applications?
WebAssembly has moved well beyond its origins in porting large C++ games. Today, Wasm is embedded in numerous web technologies: it powers high-performance image decoders (like JPEG XL and WebP), runs entire UI frameworks (such as Flutter for web), and accelerates data processing in libraries. Because Wasm now appears in the critical rendering path of many page loads, its performance directly affects user experience. A slow instantiation or poor runtime speed can delay page interaction and reduce responsiveness. JetStream 3 recognizes this reality by designing workloads that reflect these contemporary use cases, ensuring that browsers are optimized for the kinds of tasks developers are deploying in production.
What specific engineering work did WebKit do for JetStream 3?
The WebKit team, especially the JavaScriptCore developers, tackled the challenge of outgrowing JetStream 2 by rethinking their optimization priorities. They focused on making WebAssembly startup invisible—achieving sub‑millisecond instantiation for common module sizes. This involved refining the streaming compilation pipeline, reducing memory allocation overhead, and leveraging tiered compilation to balance speed and resource usage. Additionally, they worked on improving the integration between JavaScript and Wasm, so that calls between the two environments are extremely efficient. The result is an engine that not only scores well in JetStream 3 but also provides a smoother experience for users of modern web applications that rely on Wasm. The collaborative benchmark helped align their efforts with real-world performance needs.
For more details on the collaborative announcement, see our overview. To explore the technical evolution of Wasm benchmarking, jump to the section on measurement changes.