WebAssembly: Browser Support, Features, Use Cases

What is WebAssembly?

WebAssembly is a W3C binary instruction format for a stack-based virtual machine that runs inside every modern browser. It serves as a portable compilation target for C, C++, Rust, Go, AssemblyScript, and Kotlin, and runs in a memory-safe sandbox at near-native speed. The W3C Working Group, with members from Google, Mozilla, Microsoft, Apple, Fastly, and Intel, ratified WebAssembly Core 1.0 as a Recommendation on December 5, 2019, and Wasm 2.0 in December 2024.

Which browsers does WebAssembly support?

WebAssembly works in every modern desktop and mobile browser. Chrome, Firefox, Safari, Edge, and Opera all shipped support in 2017, and about 96% of global browser sessions can now run a Wasm module.

What are the key features of WebAssembly?

WebAssembly 1.0 covers the core MVP that every browser ships, and Wasm 2.0 layers on the popular post-MVP proposals. Wasm 3.0 launched in September 2025 with 64-bit memory and a full garbage collection model.

• Compact binary format: WebAssembly modules ship as a binary .wasm file that browsers can decode and compile far faster than equivalent JavaScript.
• Stack-based virtual machine: The Wasm runtime is a simple stack machine, so every browser engine can implement and optimize it without language-specific quirks.
• Linear memory and sandbox: Each module gets a sandboxed linear memory buffer that the host JavaScript controls. Wasm code cannot read or write outside this buffer.
• Multi-language source support: C, C++, Rust, Go, AssemblyScript, Kotlin, Swift, .NET (via Blazor), and Python (via Pyodide) all compile to WebAssembly today.
• SIMD (Wasm 2.0): 128-bit SIMD instructions give image filters, audio processing, and ML kernels a 2x to 4x speedup. Chrome, Firefox, Edge, and Safari 16.4+ support it.
• Threads and atomics (Wasm 2.0): SharedArrayBuffer plus atomic instructions let Wasm modules run real worker threads. The page must send Cross-Origin-Opener-Policy and Cross-Origin-Embedder-Policy headers to enable threads.
• Reference types and multi-value: Modules can return multiple values from one function and pass JavaScript references directly, which removes a lot of glue code.
• Exception handling (Wasm 2.0): Native try and catch instructions let C++ and other languages throw exceptions across the JavaScript boundary without expensive workarounds.
• Garbage collection (Wasm 3.0): Wasm GC lets languages like Java, Kotlin, and Dart reuse the host garbage collector instead of bundling their own runtime, which cuts binary size by 50% or more.

What are the use cases of WebAssembly?

WebAssembly powers more production sites than most QA teams realize. The format hits its sweet spot anywhere a workload needs more compute than JavaScript can deliver, and it is now common on both the client and the server.

• Design and creative tools: Figma rebuilt its rendering engine in C++ and ships it to every browser as Wasm. AutoCAD Web, Photopea, and the web build of Adobe Photoshop use the same path.
• In-browser games: Unity WebGL and Unreal Engine 5 export Wasm builds. Doom 3, the Bevy game engine, and the Godot HTML5 export all run as Wasm modules.
• Video, audio, and image processing: FFmpeg.wasm, Veed.io, and Mozilla's Firefox Profiler use WebAssembly for codecs, filters, and waveform rendering.
• Cryptography and password managers: 1Password and Bitwarden use Rust compiled to Wasm so the same audited code runs on web, desktop, and mobile.
• Machine learning inference: TensorFlow.js, ONNX Runtime Web, and Whisper.cpp ship Wasm builds with SIMD enabled for in-browser model inference.
• Database engines on the client: DuckDB-Wasm, SQLite Wasm, and PGlite let developers run a real SQL engine inside the browser tab without a server round trip.
• Edge and serverless platforms: Cloudflare Workers, Fastly Compute, Wasmer Edge, and Shopify's Oxygen runtime use WebAssembly outside the browser to run untrusted code with strong sandboxing.

What are the known issues with WebAssembly?

WebAssembly has near-universal browser support, but a few real edge cases still bite production teams. The biggest hits are post-MVP feature gaps, mobile constraints around threads, and the cost of crossing the JavaScript boundary.

Use this snippet in DevTools to confirm both core support and the Wasm 2.0 features that newer code paths rely on:

// Run in the DevTools console of any browser to check WebAssembly support.
const supportsWasm = typeof WebAssembly === "object";
console.log("WebAssembly:", supportsWasm ? "supported" : "not supported");

if (supportsWasm) {
  // SIMD detection: validate a tiny module that uses v128.const.
  const simdModule = new Uint8Array([
    0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 123,
    3, 2, 1, 0, 10, 10, 1, 8, 0, 65, 0, 253, 15, 253, 98, 11
  ]);
  const supportsSimd = WebAssembly.validate(simdModule);
  const supportsThreads = typeof SharedArrayBuffer === "function";
  const supportsStreaming = typeof WebAssembly.compileStreaming === "function";

  console.log("WebAssembly SIMD:", supportsSimd ? "yes" : "no");
  console.log("WebAssembly threads:", supportsThreads ? "yes" : "no");
  console.log("Streaming compile:", supportsStreaming ? "yes" : "no");
}

• Threads need cross-origin isolation: Modern Chrome, Firefox, and Safari only enable WebAssembly threads when the page sends Cross-Origin-Opener-Policy: same-origin and Cross-Origin-Embedder-Policy: require-corp headers. Without them, SharedArrayBuffer is unavailable and Wasm runs single-threaded.
• SIMD lag on Safari: Safari did not enable Wasm SIMD until Safari 16.4 in March 2023. iOS 16.3 and earlier silently fall back to scalar code, which can cut performance in half.
• DOM access has a JavaScript bridge cost: WebAssembly cannot touch the DOM directly. Every getElementById or fetch call hops through JavaScript, so chatty UI code stays JavaScript-first.
• Binary size grows fast: A C++ build of OpenCV or FFmpeg can balloon to several megabytes. Use wasm-opt, dynamic linking, and Brotli compression on every release.
• Garbage collection support is uneven: Wasm GC only shipped to a stable Chrome 119 in October 2023, Firefox 120 in November 2023, and Safari 18.2 in December 2024. Apps targeting older Safari still bundle a runtime.
• Internet Explorer is a hard miss: IE never added Wasm support and the IE engine is end-of-life. There is no polyfill that runs Wasm on IE.
• Source maps and stack traces are still rough: DWARF debugging works in Chrome DevTools but not in every browser, so debugging a production crash often means reproducing the bug locally first.

In my experience, the most surprising failure happens with threads. Modern Chrome, Firefox, and Safari only enable WebAssembly threads when the page is cross-origin isolated, so a snippet that works in localhost silently single-threads on production CDNs that strip those headers. Always test the threaded path on a real staging URL with the COOP and COEP response headers in place.

Citations

All WebAssembly version numbers and platform notes in this guide come from these primary sources:

• MDN Web Docs - WebAssembly: developer.mozilla.org/en-US/docs/WebAssembly
• MDN Web Docs - WebAssembly Concepts: developer.mozilla.org/en-US/docs/WebAssembly/Guides/Concepts
• W3C - WebAssembly Core Specification 1.0 (Recommendation, December 5, 2019): w3.org/TR/wasm-core-1
• W3C - WebAssembly Core Specification 2.0: w3.org/TR/wasm-core-2
• WebAssembly.org - Feature Status: webassembly.org/features
• Wikipedia - WebAssembly: en.wikipedia.org/wiki/WebAssembly
• WebKit blog - Assembling WebAssembly (June 6, 2017): webkit.org/blog/7691/webkit-support-for-webassembly
• Mozilla Hacks - A cartoon intro to WebAssembly: hacks.mozilla.org/2017/02/a-cartoon-intro-to-webassembly
• Chrome for Developers - WebAssembly SIMD origin trial: developer.chrome.com/blog/wasm-simd
• Chrome for Developers - WebAssembly garbage collection: developer.chrome.com/blog/wasmgc
• WebAssembly.org - WebAssembly 2.0 announcement: webassembly.org/news/2025-03-20-wasm-2.0
• Microsoft Learn - Microsoft Edge release notes: learn.microsoft.com/en-us/deployedge/microsoft-edge-relnote-stable-channel