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
checks passed
0
lines of cgo
86.1%
test coverage

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

Compiles straight to native code for both 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 core 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 1/31 partial
JS Promise integration planned
Web Content Security Policy planned
Threads & atomics pass
Compact import section planned
Wide arithmetic planned
ESM integration planned
Stack switching planned
Custom page sizes planned
Custom descriptors & JS interop planned
Relaxed dead-code validation planned
Numeric values in WAT data planned
Extended name section planned
Rounding variants planned
Compilation hints planned
JS primitive builtins planned
Acquire-Release Atomics planned
Multibyte array access planned
Half precision (FP16) planned
Type imports planned
Component model planned
C / C++ embedding API planned
Flexible vectors planned
Memory control planned
Reference-typed strings planned
Profiles planned
Shared-everything threads planned
Frozen values planned
More array constructors planned
JIT interface planned
Type reflection (JS API) planned
JS text-encoding builtins planned
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.

Try now → 
$ 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. Compare process startup and execution together on the architecture that matches your machine.

wagosingle-pass 16.8 ms
wazerocompiler 17.7 ms
wasmtimecranelift 18.3 ms
wavmllvm 32.9 ms
v8turboshaft 36.7 ms
wasm3interpreter 112 ms
wasmiinterpreter 226 ms
Apple M4 Max, darwin/arm64
Performance

Runtime Statistics

Summary metrics · lower is better
Compilefresh process
wago 1.80ms
wazero 9.24ms
5.1× faster
Compile heapper compile
wago 593 KB
wazero 4.4 MB
7.6× less
Machine codecompiled corpus
wago 46.5 KB
wazero 84.7 KB
1.8× less
Instantiaterunnable corpus
wago 11.1µs
wazero 20.9µs
1.9× faster
Executionrunnable corpus
wago 67.8µs
wazero 138µs
2× faster
End-to-end latencycompile + instantiate
wago 1.81ms
wazero 9.26ms
5.1× faster
Host → Wasmraw Instance.Invoke (i32) → i32
wago 15ns
wazero 34.2ns
2.3× faster
Wasm → hostreserved typed import callback
wago 197.4ns
wazero 438.4ns
2.2× faster
linux · amd64 · AMD Ryzen 7 7800X3D 8-Core Processor · wago 9f01d14

The 40-workload runtime suite, including 21 command programs, was measured on both architectures at Wago 4651e8cd (September 23, 2026): three samples per measurement, shown as medians. The boundary rows use a caller-owned session held across repeated calls; opening and closing that session is excluded from each timed call. Compare values within an architecture. Every displayed workload has measurements from both Wago and Wazero; the full correctness corpus remains separate. The end-to-end startup sweep above was last measured September 10, 2026. See the benchmark corpus & methodology.

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.

WASI

Complete Preview 1 and Preview 2 support, including unstable compatibility.

wago-org/wasi ↗
Component Model

Component execution, Canonical ABI linking, and typed interfaces for Wago.

wago-org/component-model ↗
Networking

Capability-gated TCP, UDP, DNS, and network protocol support with bounded host policy.

wago-org/net ↗
Workers

Bounded, composable WebAssembly worker primitives for concurrent plugin workloads.

wago-org/workers ↗
Emscripten

Standalone Emscripten compatibility, plus Go js/wasm and Ruby JS-ABI execution.

JairusSW/wago-emscripten ↗
Wide SIMD

Portable v256 and v512 instructions with native AVX-512, AVX2, and NEON lowering.

JairusSW/wide ↗
Browse the plugin registry ↗ Build a plugin ↗
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

Apache-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 →