English for WebAssembly Systems Engineers: WASI, Components, Runtimes

WebAssembly has moved well beyond the browser. If you’re working on edge compute, plugin systems, or portable tooling, you’re operating in a vocabulary space that’s dense even for native English speakers. This post focuses on the English you need to discuss WASM systems clearly — in design documents, code reviews, conference talks, and architecture discussions.

Core Vocabulary

WASI — WebAssembly System Interface

WASI (pronounced “WAH-see”) is a standardized interface that allows WebAssembly modules to interact with the host operating system — accessing files, environment variables, clocks, and network sockets — in a portable, capability-controlled way.

“We’re targeting WASI preview 2 so the module can run on both Wasmtime and WasmEdge without any platform-specific shims.”

Key verbs: target WASI, implement WASI imports, the module exposes WASI-compatible interfaces.

Do not confuse “WASI” and “Wasm” in conversation — WASI is the system interface standard, while Wasm is the binary format. Engineers notice this distinction and it marks your level of expertise.

Component Model

The component model is a higher-level specification for WebAssembly that introduces a standard way to compose modules, define interfaces between them, and share types across language boundaries.

“We’re moving from core modules to the component model so that our Rust plugin can expose a typed API that the Go host can consume without writing any glue code manually.”

Phrases to know: compose components, the component boundary, cross-language interop via the component model, adapt a core module to a component.

WIT — WebAssembly Interface Types

WIT (WebAssembly Interface Types, pronounced as individual letters “W-I-T”) is the IDL (interface definition language) used to describe the interfaces of a component — the functions it exports and the functions it imports.

“The WIT file defines the contract between the host and the plugin. Once we agree on the WIT, both teams can work independently — the host team in Go, the plugin team in Rust.”

Natural phrases: write a WIT definition, the WIT describes the interface, generate bindings from the WIT, the WIT contract.

Runtime

A runtime is the environment that executes a WebAssembly module. Major runtimes include Wasmtime (Rust, from Bytecode Alliance), WasmEdge (C++, cloud-native focus), and wasmer.

“We evaluated Wasmtime and WasmEdge for this use case. Wasmtime has better WASI preview 2 support right now, but WasmEdge has lower latency for short-lived edge functions.”

Engineers use “runtime” both as a noun (“the Wasmtime runtime”) and adjectively (“runtime performance,” “runtime overhead”).

Linear Memory

Linear memory is the contiguous, flat address space that a WebAssembly module can read from and write to. It’s a key concept for understanding performance and security in WASM.

“The Rust library writes its output into linear memory and passes a pointer and length back to the host. The host then reads those bytes out. It’s the classic WASM FFI pattern.”

Useful phrases: allocate in linear memory, the memory boundary, grow the memory, pass a pointer into linear memory.

Sandboxing

Sandboxing in WASM means that a module cannot access anything outside its defined imports — it cannot touch the filesystem, network, or other processes unless the host explicitly grants access.

“The appeal of WASM for plugin systems is the sandboxing guarantee. A third-party plugin literally cannot do anything we haven’t whitelisted in the host configuration.”

Verbs: sandbox a module, break out of the sandbox (a security vulnerability), enforce sandbox boundaries, grant capabilities to the sandbox.

Capability-Based Security

Capability-based security is the model WASI uses: instead of ambient authority (a process can do anything its user can), capabilities are explicitly granted — a module only gets filesystem access if the host hands it a file descriptor.

“We’re using capability-based security to limit what the plugin can do. It gets read-only access to /data and nothing else — no network, no environment variables.”

The key phrase here is grant a capability — you’ll use this in design documents: “The host grants the module network capabilities only in the production configuration.”

AOT vs JIT Compilation in WASM

AOT (Ahead-of-Time) compilation compiles the WASM bytecode to native machine code before execution. JIT (Just-in-Time) compiles it during execution.

“We pre-compile to native using Wasmtime’s AOT mode so the cold start latency is negligible. JIT warmup was killing our p99 latency numbers in the edge deployment.”

Phrases: compile ahead of time, JIT warmup overhead, pre-compiled native artifact, the JIT tier kicks in.

Real IT Context: Phrases Engineers Actually Use

In architecture discussions:

• “The component model gives us a clean boundary — neither side needs to know what language the other is written in.”
• “We’re using WASI to abstract the host OS, so the same binary runs on Linux and macOS without modification.”
• “Linear memory passing adds some serialization overhead. For large payloads we’re evaluating shared-nothing versus shared-memory designs.”

In code reviews:

• “This is leaking host capabilities into the plugin. We should scope the WASI filesystem access to the temp directory only.”
• “The WIT definition looks good, but the list type here — do we want to own the allocation on the host side or the guest side?”

In design documents:

• “The sandbox boundary is enforced at the WASM level, which means we get isolation without the overhead of a full process or container.”
• “We chose AOT compilation for the production path and JIT for the development loop, where fast iteration matters more than cold-start performance.”

Key Collocations

Collocation	Meaning
target WASI	compile a module to use the WASI interface
compose components	link multiple WASM components together
generate bindings from WIT	create language-specific glue code from an IDL
grant a capability	explicitly allow a module to access a resource
break out of the sandbox	(security vulnerability) escape module isolation
pre-compile to native	AOT compilation before deployment
JIT warmup	the delay before JIT-compiled code reaches peak speed
pass a pointer	send data between host and WASM module via linear memory

Practice

Write a short paragraph (5-6 sentences) describing a hypothetical system where a plugin is compiled to WebAssembly and runs inside your application. Use at least four terms from this post: runtime, WASI, sandboxing, linear memory, component model, or capability. Focus on explaining why you made each technical choice — this is the level of English you need for design documents and architecture review meetings. Then read it aloud: WASM vocabulary is also spoken in calls, and pronunciation matters (“WASI” not “wah-see-eye”).