Wasmtime wins on cold starts in new 2026 WebAssembly runtime benchmarks

A new, detailed benchmark of five major WebAssembly runtimes reveals a clear leader for serverless functions, but the choice for long-running, high-throughput services is more complex.

For founders building serverless or edge functions where cold start time is the critical metric, Wasmtime is the clear choice according to this new analysis. Teams building long-running, compute-intensive services should favor Wasmer for its superior throughput. This benchmark from author fanf provides the most detailed public data on the Wasm runtime landscape in years, making it essential reading for infrastructure decisions.

Methodology

This v0 review analyzes the performance benchmarks of five WebAssembly runtimes (Wasmtime 21.0, Wasmer 4.3, WasmEdge 0.14, V8 13.2, WAVM) as published on June 23, 2026. The review is based entirely on the claims, data, and test harness described by the author, fanf, in the source post at https://00f.net/2026/06/23/webassembly-runtimes-2026/. We have not independently reproduced these results. This analysis covers the author's reported findings on startup time, memory usage, and execution speed for a synthetic Rust program compiled to a WASI 0.2 component. It does not cover performance on other guest languages, I/O-bound workloads, or long-term stability in a production environment. Update cadence: This review will be updated if new, conflicting benchmarks emerge or when we conduct our own independent testing.

The benchmark's findings

The author's goal was to measure performance characteristics relevant to two common server-side Wasm use cases: ephemeral, latency-sensitive functions (like edge compute) and long-running, throughput-sensitive services (like microservices).

Three key performance metrics

The benchmark focused on three areas. First, P99 cold start time, measuring the duration from invocation to the first line of guest code execution. Second, idle memory consumption after initialization. Third, sustained throughput, measured in requests per second for a simple HTTP request handler workload running inside the Wasm module. The test environment was specified as an AWS c7g.metal instance to ensure a consistent hardware baseline.

Wasmtime leads on startup

For latency-sensitive workloads, the results are stark. The author reports that Wasmtime achieved a P99 cold start of 4.8ms. Its closest competitor, WasmEdge, clocked in at a claimed 9.1ms. Wasmer was further behind on this metric at 14.5ms. This positions Wasmtime as the default choice for applications where minimizing invocation latency is paramount.

Wasmer excels in raw throughput

In the sustained workload test, which ran for 10 minutes after a warmup period, the rankings inverted. Wasmer processed a claimed 18,200 requests per second. This was roughly 15% faster than Wasmtime's 15,800 RPS. This suggests Wasmer's JIT compiler produces more highly optimized machine code over time, making it better suited for services that are continuously active and where amortization of startup cost is not a concern.

What's interesting / what's not

The most interesting finding is the clear bifurcation of the market. Wasmtime, backed by the Bytecode Alliance, appears heavily optimized for the serverless use case, and these numbers validate that focus. Wasmer seems to be targeting the container-alternative space, where raw performance on long-running tasks is more important than sub-millisecond startup. The author's methodology is also a strength; publishing the source code for the test harness and Wasm module allows for public scrutiny and potential reproduction, which is a welcome departure from opaque vendor benchmarks.

What's less clear is how these results translate to real-world applications. The workload is entirely synthetic and CPU-bound. An application that spends most of its time waiting on network I/O or database queries may see these performance differences disappear entirely. The benchmark also uses a single guest language (Rust). The performance characteristics could differ significantly for modules compiled from Go, C++, or other languages with different runtime characteristics. The relatively poor performance of V8 was surprising and may point to a test configuration that doesn't play to its strengths.

Pricing

All runtimes tested (Wasmtime, Wasmer, WasmEdge, V8, WAVM) are open-source projects and free to use under permissive licenses like Apache 2.0. Commercial pricing typically applies to managed platforms that build on these runtimes, such as Fermyon Cloud (which uses Wasmtime) or Wasmer Edge. This analysis focuses only on the performance of the open-source cores. (Pricing assessment as of June 23, 2026).

Verdict

The choice of a Wasm runtime in 2026 is a direct trade-off between startup latency and sustained throughput. fanf's benchmarks make a compelling, data-backed case for Wasmtime as the default for latency-sensitive serverless and edge applications. Its sub-5ms P99 cold start is a meaningful competitive advantage. However, for services where throughput is the primary metric and instances are long-lived, Wasmer's claimed 15% performance edge is difficult to ignore. Teams must choose based on which metric directly impacts their product's user experience and cost model.

What we'd test next

A v2 analysis would require independent reproduction of fanf's results on different cloud hardware to verify the claims. We would prioritize creating a benchmark for an I/O-bound workload, like a database-backed API endpoint, as this better reflects common web service patterns. Additionally, we would test Wasm modules compiled from Go and Zig to assess how runtime performance is affected by language-specific toolchains and features. Finally, a long-duration stability and memory leak test would be critical for evaluating production-readiness.

The investor read

The Wasm runtime space is maturing into a two-tiered market where the top tier (Wasmtime, Wasmer) is highly optimized and others lag. This suggests the core technology is stabilizing. The next competitive front is the developer experience and commercial platforms built on top (e.g., Fermyon, Wasmer Inc.), not the runtimes themselves. An investor should look for companies building differentiated, managed platforms that abstract away Wasm's complexity for the average enterprise developer. The key risk is that Wasm remains a niche for performance-critical edge cases, failing to displace containers in mainstream backend development. The investable play is not in building a new runtime, but in building the dominant PaaS that makes Wasm easy to adopt.

Pull quote: “For founders building serverless or edge functions where cold start time is the critical metric, Wasmtime is the clear choice according to this new analysis.”