An Overview of WebAssembly Engines: Architecture, Common Implementations, and Comparative Analysis

In this article we discuss the core components that drive WebAssembly program execution, first outlining the typical parts of a language engine and constructing a conceptual model, then reviewing several widely used open‑source WebAssembly engines.

General Engine Architecture

An engine (or virtual machine) loads a program into memory, resolves symbols, and provides a loader and linker. It then executes the program either by interpreting the instruction stream or by compiling it to native code via a JIT/AOT compiler. Concurrency is handled by a thread scheduler, memory allocation and reclamation are performed by a memory manager, and external resources are accessed through language extensions or external interfaces.

Figure 1 shows the conceptual model of an engine.

Below we examine five prominent WebAssembly engines.

wasmtime

wasmtime, developed by the Bytecode Alliance in Rust, is a high‑performance compiled engine. Its architecture consists of three layers: compilation, runtime, and tooling (see Figure 2).

The compilation stage includes four components: wasm-environ , wasm-cranelift , wasm-jit , and wasm-obj , reflecting the compilation pipeline. The runtime is centered on wasm-runtime , which maintains a Store and an InstanceHandle (see Table 1).

Name

Purpose

Store

Container for functions, memories, tables, etc.

Isolation unit similar to V8 isolates.

InstanceHandle

Underlying representation of a wasm module instance.

Associated with a Store and holds a VMContext.

wasmtime also provides tooling modules such as wasm-cache , wasm-debug , and wasm-profiling . By leveraging Cranelift, it achieves roughly four times the CoreMark performance of wasm3.

wasm3

wasm3 is a lightweight interpreter written in C. It executes WebAssembly instructions purely via interpretation, using a threaded‑code design that enables tail‑call optimisation. It translates wasm stack‑machine instructions into register‑based M3 instructions, as illustrated in Figure 4.

Because it is interpreter‑only, wasm3 runs on iOS and other constrained platforms, with a binary size under 70 KB. It offers language bindings for C/C++, Python, Rust, Go, Zig, Perl, and supports WASI for standalone execution.

WasmEdge

WasmEdge, hosted by the CNCF, targets edge computing, cloud‑native, and decentralized applications. It is a compiled engine that can operate in JIT or AOT mode using LLVM as the backend, delivering higher performance than Cranelift‑based engines. Its rich extension ecosystem includes QuickJS, Node.js compatibility, TensorFlow, React SSR, and networking capabilities, and it is integrated into Docker.

wasm‑micro‑runtime (WAMR)

WAMR, also a Bytecode Alliance project, is designed for embedded, IoT, smart‑contract, and cloud‑native environments. It supports both interpretation and compilation (JIT/AOT) using LLVM, achieving near‑native speeds and being the fastest engine in 2023 benchmarks. It fully implements MVP and many post‑MVP proposals, though some JS‑API features remain unsupported.

V8

V8, the JavaScript engine used in Chrome and Node.js, also runs WebAssembly via its TurboFan or LiftOff JIT backends. While it does not implement WASI, it fully supports the WebAssembly JS API, MVP, and many experimental proposals, making it a strong choice for web and Node.js environments.

Conclusion

The article presented a generic engine model and then compared five major WebAssembly runtimes—wasmtime, wasm3, WasmEdge, wasm‑micro‑runtime, and V8—covering their execution strategies, performance, standards compliance, and typical deployment scenarios. Additional engines such as wasmer, wavm, and fizzy exist but were omitted for brevity.

The accompanying course "Build Your Own WebAssembly Interpreter" provides a hands‑on guide for deeper exploration.

Reference Table

Engine

Key Features

wasmtime

High‑performance compilation

Bytecode Alliance project

Used in Serverless scenarios

wasm3

High‑performance interpreter

Cross‑platform (iOS, etc.)

Lightweight engine

WasmEdge

Integrated into Docker

LLVM‑based compilation

Rich extension ecosystem

wasm‑micro‑runtime

Interpretation & compilation modes

LLVM backend

Fastest runtime (2023)

Suitable for resource‑constrained devices

V8

TurboFan/LiftOff JIT backend

Supports many experimental proposals

Optimized for Web/JavaScript environments