In 2017, WebAssembly shipped in browsers as a way to run C, C++, and Rust at near-native speed inside a sandbox. Game engines, codecs, scientific sims — impressive, but mostly a browser story. By 2026 that story has changed almost completely. WebAssembly is now a first-class server and edge runtime, and it got there the way any technology does: someone finally standardized the boring parts.

The turning point: WASI and the Component Model

The two pieces that unlocked the browser exit were WIT (the WebAssembly Interface Types language) and the Component Model built on top of it, plus the WASI system interface that gives Wasm modules a standard way to talk to files, clocks, sockets, HTTP, and the rest of the host.

The practical milestone came in January 2024, when the WASI Subgroup launched WASI 0.2 (also called WASI Preview 2). That gave the ecosystem the Component Model's typed interfaces and the ability to securely compose modules compiled from different languages. Through 2025, the major runtimes shipped full Preview 2 support — Wasmtime, Wasmer, WasmEdge, and the JavaScript toolchain Jco all run 0.2 components today.

The most recent landfall is WASI 0.3, which makes async I/O native. Instead of faking non-blocking behavior with poll loops and host workarounds, components can now describe and await async operations in an interface, and the runtime handles cooperative scheduling. Early previews of 0.3 run in recent Wasmtime releases — a good place to experiment, though the spec is still settling.

Where it's actually running

This isn't theoretical. Cloudflare Workers (which supports WASI modules) and Fastly Compute (built on Wasmtime) now host millions of Wasm edge functions. A big practical draw is cold-start time: a Wasm module can initialize in microseconds, where a typical container or VM-backed function takes hundreds of milliseconds. That's why teams running highly parallel, latency-sensitive workloads are reaching for Wasm.

On the tooling side, Docker already ships Wasm support (an early WasmEdge integration was announced back in 2022), so containers and Wasm compose. Fermyon's Spin framework and the SpinKube stack (both CNCF sandbox projects) target Kubernetes, and Fermyon's managed service runs on Akamai's distributed cloud. Bytecode Alliance projects keep widening the net: Jco runs components natively inside Node.js, and wasm-tools compose fuses separately built components into a single artifact at build time.

Still unfinished business

The honest picture includes gaps. Component Model 1.0 isn't ratified yet — at Wasm I/O in March 2026, Fastly's Luke Wagner walked through the remaining work, including a stable async surface and better upstream language and framework support. Threads and zero-copy are on the roadmap but not fully solved. And while the access model is a real strength — a component that never imports the filesystem interface cannot touch the filesystem at all — debugging and tooling still lag behind conventional runtimes.

Where to start

Pick one runtime you already trust — Wasmtime is a fine default — and compile a small service against the wasm32-wasip2 target. Define a WIT interface, run it, and watch how the typing surfaces bugs before runtime. The browser was the proof of concept; the next decade is everywhere else.