The Wado Programming Language

Wado is a Rust-flavored, statically-typed, GC-ed language and toolchain that targets only the WebAssembly Component Model and WASI 0.3+. The compiler is 100% agentic-coded.

See docs/design-philosophy.md for the reasoning behind these choices, and wado-lang.org for the docs and blog.

Installing

Pre-built binary

Pre-built binaries are published on GitHub Releases for:

• Linux (x86_64, aarch64) — tar.gz
• macOS (Apple Silicon) — tar.gz
• Windows (x86_64, aarch64) — zip

Each archive contains the wado binary plus LICENSE and README.md. The asset name is derived from uname, so this block downloads, verifies, and installs in one go 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   # ensure ~/bin is on PATH

Every release archive carries a signed build provenance attestation binding the file to the workflow run that built it; the gh attestation verify step above checks it. Windows archives (.zip) install the same way — download the matching wado-windows-*.zip and verify it against SHA256SUMS.txt.

From source

If you have a Rust toolchain installed:

cargo install --git https://github.com/wado-lang/wado wado-cli

This builds the current main branch from source.

Hello World

#!/usr/bin/env wado run
use { println, Stdout } from "core:cli";

// run() is the entry point of the wasi:cli/command hosted world
export fn run() with Stdout {
    println("Hello, world!");
}

wado run example/hello.wado                    # run it directly
wado compile -o hello.wasm example/hello.wado  # compile to Wasm
wado compile -o hello.wat  example/hello.wado  # or to WAT

Status

Wado is experimental. The core language — static typing, generics, closures, modules, traits, pattern matching, the effect system — is implemented and functional, and already usable for its original purpose: embedding small, type-safe Wasm modules where binary size matters. It waits on the broader ecosystem — the Component Model in browsers, WASI 1.0, and GC across component boundaries — to reach its full shape.

Documentation

• Design Philosophy — why Wado is the way it is
• Cheatsheet — quick syntax reference
• Language Specification — full language reference
• Compiler Implementation — compiler internals and feature checklist
• Benchmarks — performance vs C, JavaScript, and others
• Other Documentation — WEPs, research notes, and more

These are also published, alongside the blog, at wado-lang.org.

Development

Agentic Coding

Developing entirely through agentic coding requires active management:

• Refactoring guidance: Left unchecked, agents generate case-specific code that only works for immediate tests. Regular intervention steers toward generalizable solutions.
• Code minimization: Agents tend to over-generate logic. Compilers need minimal, general-purpose code — the opposite of what agents naturally produce.
• Periodic refactoring phases: Without intervention, cruft accumulates. We've done one ground-up compiler architecture redesign so far.

AI-Guided Optimization

AI-guided optimization is a technique where you show generated code to a coding agent and have it identify optimization opportunities. The agent's output is non-deterministic, but the insights can be turned into deterministic compiler rules.

Wado's optimizer is developed using this approach:

Agent finds pattern → Human reviews → Deterministic optimization rule added

Show the generated WAT to an agent and ask it to spot inefficiencies. Review the suggestions, then implement them as permanent optimization passes.

Install Development Tools

This project uses mise to manage dev tools. Install mise first:

curl -fsSL https://mise.run | sh
# Then add to your shell profile:
#   eval "$(~/.local/bin/mise activate bash)"  # for bash
#   eval "$(~/.local/bin/mise activate zsh)"   # for zsh

Then install project tools:

mise trust                 # trust the mise.toml config (first time only)
mise run on-task-started   # install all project tools

See mise.toml for the list of managed tools.

The Wado CLI

• wado compile FILE - Compile Wado source to Wasm/WAT
• wado run FILE - Run Wado source directly using Wasmtime
• wado doc FILE - See the documentation for a Wado source file
• wado format FILE - Format Wado source code

VS Code Extension

The wado-vscode/ directory contains a VS Code extension for syntax highlighting. It is not published to the marketplace, but you can install it locally for development:

mise run install-wado-vscode-dev    # install extension to ~/.vscode via symlink
mise run clean-wado-vscode-dev      # uninstall it from ~/.vscode
mise run update-wado-vscode-grammar # regenerate syntax files after changing syntax.rs

See wado-vscode/README.md for more details.

On Your Task Done

mise run on-task-done # format, clippy-fix, update resources, test

Releasing

Releases are cut manually on a roughly weekly cadence via tagpr.

How it works:

1. Every push to main opens a Release PR that bumps [workspace.package].version in both Cargo.toml and wado.toml (kept in lockstep so the CLI and the published Wado packages ship one version), regenerates Cargo.lock, and updates CHANGELOG.md from PRs merged since the previous tag.
2. Merging the Release PR pushes tag v<next>, which triggers .github/workflows/release.yml.
3. Default bump is patch. Add a tagpr:minor or tagpr:major label on the Release PR to override.

tagpr is the single version manager: the workspace version is bumped only by the Release PR, never by hand. Do not edit [workspace.package].version in Cargo.toml or wado.toml directly.

Benchmarks

Per-commit performance tracking is published to GitHub Pages. Every push to main records runtime and binary size metrics.

• Runtime Performance — throughput (work per second, higher is better) for integer, float, array, string, and compression workloads (run on wasmtime at -O1/-O2/-O3)
• Wasm Binary Size — .wasm output size for representative programs (compiled at -Os)

See benchmark/README.md and wasm-size/README.md for local benchmark instructions and comparison results against other programming languages.

Authors

Copyright (c) 2026, FUJI Goro (a.k.a. gfx). Some rights reserved.

License

MIT

See LICENSE for details.