What do the brackets in the type signature mean?

WebAssembly is a stack machine, so each instruction has a signature [args] to [results] describing the values it pops and pushes. For example i32.add has [i32 i32] to [i32]: it pops two 32-bit integers and pushes their sum. The symbol for the bottom type marks a stack-polymorphic or unreachable result.

Why are some opcodes two bytes like 0xFC 0x0A?

The single-byte opcode space filled up, so later proposals use a prefix byte followed by a LEB128 sub-opcode. The 0xFC prefix covers bulk-memory and saturating-conversion instructions added after the MVP, such as memory.copy and memory.fill.

What is the difference between call and call_indirect?

call invokes a function by a static index known at compile time. call_indirect picks a function from a table using an i32 index on the stack and checks its type signature against an expected type at runtime, trapping on mismatch. Indirect calls are how function pointers and vtables are implemented.

How does memory.grow report failure?

memory.grow takes a page count and returns the previous memory size in 64 KiB pages on success, or -1 (as an i32) if the host cannot satisfy the request. Code must check for -1 before assuming the new memory is available, rather than trapping.

Does this reference cover SIMD and threads?

It focuses on the core MVP instruction set plus common WebAssembly 2.0 bulk-memory operations. The 128-bit SIMD (vector) and atomic threading instructions are large separate families with their own opcode prefixes and are out of scope here.

WebAssembly Instruction Reference

Email me this result

Get this tool's output sent to your inbox, plus one useful tool a week. No spam, unsubscribe any time.

A stack machine in bytecode

WebAssembly is a compact, typed stack machine. Each instruction pops a fixed set of operands off the value stack and pushes its results back, which makes the bytecode easy to validate and fast to compile. This reference groups the core MVP and WebAssembly 2.0 instructions into control, parametric, variable, memory and numeric categories, each with its opcode, stack type signature and a short description.

How it works

Every instruction is described by a signature [args] → [results]. Numeric instructions like i32.add consume their operands and push a typed result; the integer ops use two’s-complement wrapping while float ops follow IEEE-754. Control instructions (block, loop, if, br, br_table, call) manage labelled scopes and jumps — branches target blocks by depth, not by name, in the binary format.

Variable instructions move values between the stack and locals or globals, and memory instructions read and write the single linear memory using an address on the stack plus an alignment hint and offset immediate. Opcodes are single bytes for the MVP; later extensions such as bulk-memory use a 0xFC prefix and a sub-opcode. Filter the list above by name, opcode or category to find what you need.

Notes and gotchas

Signed division (i32.div_s) and the float-to-int truncations trap on divide by zero and on out-of-range conversions; use the saturating *_sat variants to clamp instead of trapping.
local.tee is local.set that leaves the value on the stack — handy for chaining.
Memory addresses are byte offsets into one flat array starting at zero; out-of-bounds access traps deterministically.
The text format (.wat) names blocks and locals for readability, but the binary format resolves those to numeric indices and branch depths.