WebAssembly,
made for Go.

A novel runtime that balances compile time, memory usage, and execution speed for a simply wonderful experience.

Read the docs → Browse plugins ↗
// compile, instantiate & run wasm, no cgo
compiled, err := wago.Compile(nil, wasmBytes)
if err != nil { panic(err) }
defer compiled.Close()

inst, err := wago.Instantiate(compiled)
if err != nil { panic(err) }
defer inst.Close()

out, err := inst.Invoke("fib", wago.I32(30))
if err != nil { panic(err) }
fmt.Println(wago.AsI64(out[0])) // → 832040
57/57
MVP files pass
16,592
MVP assertions passed
0
lines of cgo
7
native runtime targets

A real engine, not a wrapper.

It reads, checks, and compiles WebAssembly to native code — all in pure Go. No C, no cgo.

Native x86-64, ARM64 & RISC-V

Compiles straight to native code for all three architectures in milliseconds, with no warmup.

WebAssembly 3.0

Full support for the WebAssembly 1.0, 2.0, and 3.0 standard, on by default.

Singlepass Backend

Absurdly fast and light. Low memory, high throughput, and competative performance.

Standalone executables

Compile wasm into native standalone executables. Great for CLIs.

Plugin API

Anything is possible. Need HTTP? Install it. Want AVX-512 support? Implement it. We also have a package manager to boot.

3rd-Party Tests

We run the Official WebAssembly test suite along with the entire wazero and wasmtime suites. We pass everything.

Conformance

We show our work

wago tracks the official WebAssembly/testsuite file by file. The numbers here come straight from the engine's own test run.

100% applicable MVP files pass
→ Read the full SPECTEST.md
WebAssembly 1.0 MVP feature details · historical (bd742cd) 17/17 pass
i32 / i64 integer ops pass
f32 / f64 ops pass
f32 / f64 ceil / floor / trunc / nearest / copysign pass
Conversions + reinterpret pass
Float→int trunc NaN/overflow traps pass
Control flow: block / loop / if / else / br / br_if / br_table / return pass
call / call_indirect pass
select, drop, nop, unreachable pass
Locals pass
Globals pass
Linear memory load/store pass
memory.size / memory.grow pass
Active data segments pass
Tables + active element segments pass
Function imports / exports pass
Memory / table / global imports & exports pass
start function pass
WebAssembly 2.0 finished proposals 6/6 pass
Sign-extension ops pass
Non-trapping float→int pass
Multi-value pass
Reference types pass
Bulk memory pass
Fixed-width SIMD pass
WebAssembly 3.0 finished proposals 9/9 pass
Tail calls pass
Extended const expressions pass
Typed function references pass
Memory64 pass
Multiple memories pass
Garbage collection pass
Exception handling pass
Relaxed SIMD pass
Branch hinting pass
Future features active proposals 2/31 partial
JS Promise integration planned
Web Content Security Policy not planned
Threads & atomics flag
Compact import section pass
Wide arithmetic pass
ESM integration not planned
Stack switching planned
Custom page sizes planned
Custom descriptors & JS interop unsupported
Relaxed dead-code validation unsupported
Numeric values in WAT data unsupported
Extended name section unsupported
Rounding variants unsupported
Compilation hints planned
JS primitive builtins not planned
Acquire-Release Atomics planned
Multibyte array access unsupported
Half precision (FP16) unsupported
Type imports unsupported
Component model partial
C / C++ embedding API unsupported
Flexible vectors unsupported
Memory control unsupported
Reference-typed strings unsupported
Profiles unsupported
Shared-everything threads unsupported
Frozen values unsupported
More array constructors unsupported
JIT interface unknown
Type reflection (JS API) unsupported
JS text-encoding builtins unknown
Get started

Up and running in one command

Add wago to your module and embed it, or drive the engine straight from the CLI to run, compile, or validate any .wasm.

$ curl -fsSL https://install.wago.sh/unix | sh
Read the quick start guide →
End-to-end latency

Fresh process in milliseconds

The whole process, from spawn to exit, timed end-to-end across six real workloads. Process startup and execution are measured together.

wagosingle-pass 15.1 ms
wasmersinglepass 25.0 ms
wazycompiler 132 ms
v8turboshaft 132 ms
wasmtimecranelift 192 ms
wasmercranelift 194 ms
wazerocompiler 198 ms
AMD Ryzen 7 7800X3D 8-Core Processor, linux/amd64
Performance

Runtime Statistics

Summary metrics · lower is better
Compileper compile
wago 389µs
wazero 3.16ms
8.1× faster
Compile peak RSSper compile
wago 10.4 MB
wazero 13.7 MB
1.3× less
Machine codecompiled corpus
wago 13.3 KB
wazero 23.1 KB
1.7× less
Instantiaterunnable corpus
wago 4.7µs
wazero 34.2µs
7.3× faster
Executionrunnable corpus
wago 369µs
wazero 677µs
1.8× faster
Compile + instantiatesum of means
wago 394µs
wazero 3.20ms
8.1× faster
Host → Wasmper call · host-to-wasm-call
wago 21.2ns
wazero 26.8ns
1.3× faster
Wasm → hostper call · wasm-to-host-call
wago 21.7ns
wazero 205.1ns
9.5× faster
linux · amd64 · AMD Ryzen 7 7800X3D 8-Core Processor · wago ed0ca6535

View the results on wasm.fyi →

Plugins

The Most powerful Plugin API

Need HTTP? Install a plugin. Need WASI? Add it. Need new host bindings? Build them with the plugin API.

Community

Join us on Discord

Ask questions, share what you're building, and follow wago's progress with the community.

Join Discord ↗

Embed wasm in your Go app

MPL-2.0-licensed and built in the open. Add it to your module in one command and call straight into native wasm, no cgo.

Read the docs →