WebAssembly Vocabulary: Wasm, WASI, and the Runtime Model Explained

WebAssembly has moved from browser novelty to serious infrastructure technology. It runs Python interpreters in the browser, powers plugin systems in databases and proxies, and is emerging as a universal compute substrate. Engineers who can discuss Wasm confidently — its memory model, component model, and runtime ecosystem — are increasingly valuable across frontend, backend, and platform roles.

The WebAssembly Format

WebAssembly (Wasm) is a binary instruction format designed as a portable compilation target for languages like C, C++, Rust, and Go. It runs in a browser sandbox — isolated from the host system, with no direct access to the OS or filesystem unless explicitly granted.

The human-readable text representation of WebAssembly is called WAT (WebAssembly Text format). WAT uses S-expressions and is primarily used for debugging and understanding compiled output. Engineers rarely write WAT by hand but read it when inspecting compiled binaries: “Let me disassemble this Wasm module to WAT and check what’s being exported.”

Linear memory is WebAssembly’s memory model — a single, contiguous, resizable array of bytes. Wasm modules read from and write to this linear memory using load and store instructions. This design is intentionally simple and sandboxed — a Wasm module cannot access memory outside its own linear memory region without explicit host cooperation.

Module Structure

A Wasm binary is divided into sections. The import section declares what the module needs from the host environment (functions, memory, tables, globals). The export section declares what the module makes available to the host. This import/export boundary is the interface between Wasm and its host.

wasm-bindgen is a Rust tool that generates JavaScript bindings for Wasm modules compiled from Rust, handling the type conversions between JavaScript’s type system and Wasm’s numeric types. Engineers say: “We’re using wasm-bindgen to expose the image processing functions to the JavaScript layer.”

Emscripten is a compiler toolchain that compiles C and C++ to Wasm, also generating the JavaScript glue code needed to integrate the module into a browser or Node.js environment.

WASI and Beyond the Browser

WASI (WebAssembly System Interface) is a standard interface that gives Wasm modules access to operating system capabilities — files, network sockets, clocks, environment variables — in a capability-based security model. WASI makes Wasm useful outside the browser.

A Wasm runtime is the engine that executes Wasm modules outside the browser. Common runtimes include Wasmtime (developed by Bytecode Alliance, used in production at many companies), WasmEdge (optimised for cloud-native and edge deployments), and Wasmer. Engineers say: “We’re running the data validation logic in Wasmtime on the server — the same Wasm binary that runs in the browser.”

A host function is a function provided by the runtime to the Wasm module — essentially a system call. The Wasm module declares it as an import, and the runtime provides the implementation. This is how WASI exposes file I/O, networking, and other OS capabilities.

Advanced Concepts

The component model is a newer WebAssembly proposal that defines how Wasm modules can be composed together, sharing complex types beyond the numeric primitives Wasm natively supports. It is the foundation for building interoperable Wasm ecosystems.

Wasm64 is a variant with 64-bit linear memory addressing, allowing modules to access more than 4GB of memory — critical for compute-intensive workloads like large ML models.

Wasm for plugins and extensions is one of the fastest-growing use cases. Databases (like SingleStore and Cloudflare D1), proxies (Envoy via proxy-wasm), and editor extensions use Wasm as a sandboxed plugin runtime — safe, portable, and language-agnostic.

Practice

Take any Rust, C, or Go project and compile a small function to Wasm using wasm-pack or Emscripten. Then describe the resulting module in English using the vocabulary from this article: what does it export, what does it import, what is its memory layout? Writing about Wasm in plain English accelerates your understanding of the runtime model significantly.