The Wado Programming Language Wado
Type-safe, high-level WebAssembly.
Type-safe like Rust, familiar like TypeScript, compiled to clean Wasm. Wasm in plain sight.
A First Look
#!/usr/bin/env wado run
// Hello World in Wado
use { println, Stdout } from "core:cli";
export fn run() with Stdout {
println("Hello, world!");
}
A few lines, but a lot is on display: a shebang for one-file
scripts, ES module–style imports from a namespaced standard library
(core:cli), an export entrypoint into the
wasi:cli/command world, and — the surprising part — a
with Stdout clause that puts the side effect in the function's type.
It compiles to a small, self-contained .wasm — nothing ships
alongside it.
See it on something real: a tour of Wado through an HTTP service walks a single-file httpbin clone, feature by feature.
Why Wado
Wado targets exactly one platform: WebAssembly's Component Model and WASI.
That focus shapes the whole language — its type system is the
Component Model's, down to the split into variant,
enum, and flags.
- Small by construction — targeting Wasm GC means the host provides the garbage collector, so no memory-management runtime ships inside the module. Binaries stay lean; the wasm-size dashboard tracks the current numbers.
- Effects in the type — every WASI capability a function touches (like the
with Stdoutabove) shows up in its signature. The platform's boundaries and the language's effects are one and the same. - Explicit and predictable — no macros, no implicit conversions, no
any; the code you read is the code that runs, and errors are values (Result/Option), not exceptions. The compiler is 100% agentic-coded — a language agents can work in has to be this legible.
Get Started
Grab the latest prebuilt binary and verify it. The archive name is derived
from uname, so this block works as-is on macOS
(Apple Silicon) and Linux (x86_64, aarch64) —
copy the whole thing:
BASE=https://github.com/wado-lang/wado/releases/latest/download
ASSET="wado-$(uname -s | tr A-Z a-z)-$(uname -m).tar.gz"
curl -fsSLO "$BASE/$ASSET"
# Verify the checksum and the build provenance (needs the GitHub CLI).
if command -v shasum >/dev/null; then
curl -fsSL "$BASE/SHA256SUMS.txt" | shasum -a 256 --ignore-missing -c -
else
curl -fsSL "$BASE/SHA256SUMS.txt" | sha256sum --ignore-missing -c -
fi
gh attestation verify --repo wado-lang/wado "$ASSET"
tar xzf "$ASSET"
mkdir -p ~/bin
install -m 755 "${ASSET%.tar.gz}/wado" ~/bin/wado
This installs wado into ~/bin — make sure that
directory is on your PATH.
Then write a program and run it:
cat > hello.wado <<'EOF'
#!/usr/bin/env wado run
use { println, Stdout } from "core:cli";
export fn run() with Stdout {
println("Hello, world!");
}
EOF
wado run hello.wado
Also available: Windows builds
on the release page, cargo install --git https://github.com/wado-lang/wado wado-cli
to build from source, and a VS Code extension under wado-vscode/.
Status & Roadmap
Wado is experimental, but the core language — static typing, generics, closures, traits, pattern matching, the effect system — works, and it's already usable for its original purpose: embedding small, type-safe Wasm modules where binary size matters. Its design points further out, though; three things in the broader Wasm ecosystem need to land first:
-
Browser support for the Wasm Component Model. Today, Wado
components run on wasmtime. Once browsers ship CM, the same
.wasmwill run unchanged on the web. - WASI 1.0. WASI P3 is the current release-candidate milestone; WASI 1.0 is the next. Wado tracks the spec closely.
- Wasm Component Model × Wasm GC integration. GC types are not yet exchangeable across CM boundaries. Once they are, Wado's value semantics will compose naturally with any CM-targeting language.
When these land, Wado's era begins.
Resources
- Cheatsheet — Quick syntax reference
- Language Specification — Full language reference
- Compiler Internals — How the compiler works
- Documentation — Spec, standard library, and design proposals (
wep-*.md) - Runtime performance dashboard
- Wasm binary size dashboard
- Repository — Source, issues, releases
- Component Model — the platform Wado targets (Bytecode Alliance)
- WASI — the system interface Wado builds on