{"id":48150884,"url":"https://github.com/wado-lang/wado","last_synced_at":"2026-07-05T02:01:04.957Z","repository":{"id":334304168,"uuid":"1130100153","full_name":"wado-lang/wado","owner":"wado-lang","description":"The Wado Programming Language","archived":false,"fork":false,"pushed_at":"2026-06-28T12:07:05.000Z","size":263183,"stargazers_count":90,"open_issues_count":11,"forks_count":2,"subscribers_count":0,"default_branch":"main","last_synced_at":"2026-06-28T12:16:36.387Z","etag":null,"topics":["programming-language","wado","wasi","wasm"],"latest_commit_sha":null,"homepage":"https://wado-lang.org","language":"Rust","has_issues":true,"has_wiki":null,"has_pages":null,"mirror_url":null,"source_name":null,"license":"mit","status":null,"scm":"git","pull_requests_enabled":true,"icon_url":"https://github.com/wado-lang.png","metadata":{"files":{"readme":"README.md","changelog":"CHANGELOG.md","contributing":null,"funding":".github/FUNDING.yml","license":"LICENSE","code_of_conduct":null,"threat_model":null,"audit":null,"citation":null,"codeowners":null,"security":null,"support":null,"governance":null,"roadmap":null,"authors":null,"dei":null,"publiccode":null,"codemeta":null,"zenodo":null,"notice":null,"maintainers":null,"copyright":null,"agents":"AGENTS.md","dco":null,"cla":null},"funding":{"github":"wado-lang"}},"created_at":"2026-01-08T03:09:09.000Z","updated_at":"2026-06-28T07:21:35.000Z","dependencies_parsed_at":null,"dependency_job_id":"667fdf97-3172-4ef8-af29-9c841a95fc37","html_url":"https://github.com/wado-lang/wado","commit_stats":null,"previous_names":["wado-lang/wado"],"tags_count":8,"template":false,"template_full_name":null,"purl":"pkg:github/wado-lang/wado","repository_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/wado-lang%2Fwado","tags_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/wado-lang%2Fwado/tags","releases_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/wado-lang%2Fwado/releases","manifests_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/wado-lang%2Fwado/manifests","owner_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/owners/wado-lang","download_url":"https://codeload.github.com/wado-lang/wado/tar.gz/refs/heads/main","sbom_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/wado-lang%2Fwado/sbom","scorecard":null,"host":{"name":"GitHub","url":"https://github.com","kind":"github","repositories_count":286080680,"owners_count":35141083,"icon_url":"https://github.com/github.png","version":null,"created_at":"2022-05-30T11:31:42.601Z","updated_at":"2026-05-26T15:22:16.424Z","status":"online","status_checked_at":"2026-07-05T02:00:06.290Z","response_time":100,"last_error":null,"robots_txt_status":"success","robots_txt_updated_at":"2025-07-24T06:49:26.215Z","robots_txt_url":"https://github.com/robots.txt","online":true,"can_crawl_api":true,"host_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub","repositories_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories","repository_names_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repository_names","owners_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/owners"}},"keywords":["programming-language","wado","wasi","wasm"],"created_at":"2026-04-04T17:12:07.937Z","updated_at":"2026-07-05T02:01:04.911Z","avatar_url":"https://github.com/wado-lang.png","language":"Rust","funding_links":["https://github.com/sponsors/wado-lang"],"categories":["Rust"],"sub_categories":[],"readme":"# The Wado Programming Language\n\nA type-safe, high-level WebAssembly.\n\n## Why Wado?\n\nWado was born from a practical need: embedding small Wasm modules in JavaScript projects without the binary size explosion that comes with existing Wasm-targeting languages.\n\nExisting solutions bundle their own memory management runtime into every `.wasm` file, resulting in bloated binaries even for simple tasks. Wado takes a different approach: by leveraging **Wasm GC**, the garbage collector is provided by the Wasm runtime itself (currently wasmtime; browser support pending Wasm Component Model), keeping your binaries minimal.\n\nThe timing matters too. With Wasm Component Model and WASI P3 maturing in 2026, Wado is designed from the ground up for this new era — no legacy baggage, no retrofitting.\n\n## Installing\n\n### Pre-built binary (recommended)\n\nDownload the latest release for your platform from\n[GitHub Releases](https://github.com/wado-lang/wado/releases/latest).\nPre-built binaries are published for:\n\n- Linux (`x86_64`, `aarch64`) — `tar.gz`\n- macOS (Apple Silicon) — `tar.gz`\n- Windows (`x86_64`, `aarch64`) — `zip`\n\nEach archive contains the `wado` binary plus `LICENSE` and `README.md`.\nVerify the download against `SHA256SUMS.txt` attached to the same release.\n\n### From source\n\nIf you have a Rust toolchain installed:\n\n```sh\ncargo install --git https://github.com/wado-lang/wado wado-cli\n```\n\nThis builds the current `main` branch from source. Re-run the same command\nto update.\n\n## Examples\n\n### Hello World\n\n```wado\n#!/usr/bin/env wado run\nuse { println, Stdout } from \"core:cli\";\n\n// run() is the entry point of the wasi:cli/command hosted world\nexport fn run() with Stdout {\n    println(\"Hello, world!\");\n}\n```\n\nRun it:\n\n```sh\nwado run example/hello.wado\n```\n\nCompile to WebAssembly:\n\n```sh\nwado compile example/hello.wado # generates example/hello.wasm\nwado compile -o example/hello.wasm example/hello.wado # ditto\nwado compile --format wasm example/hello.wado # ditto\n\nwado compile --format wat example/hello.wado # generates example/hello.wat with WAT format\nwado compile -o example/hello.wat example/hello.wado  # ditto\n```\n\n### FizzBuzz\n\n```wado\nuse { println, Stdout } from \"core:cli\";\n\nvariant FizzBuzz {\n    Fizz,\n    Buzz,\n    FizzBuzz,\n    Number(i32),\n}\n\nfn classify(n: i32) -\u003e FizzBuzz {\n    if n % 15 == 0 { return FizzBuzz::FizzBuzz; }\n    if n % 3 == 0 { return FizzBuzz::Fizz; }\n    if n % 5 == 0 { return FizzBuzz::Buzz; }\n    return FizzBuzz::Number(n);\n}\n\nexport fn run() with Stdout {\n    for let mut i = 1; i \u003c= 20; i += 1 {\n        println(match classify(i) {\n            Fizz =\u003e \"Fizz\",\n            Buzz =\u003e \"Buzz\",\n            FizzBuzz =\u003e \"FizzBuzz\",\n            Number(n) =\u003e `{n}`,\n        });\n    }\n}\n```\n\n```sh\nwado run example/fizzbuzz.wado\n```\n\n## Key Features\n\n### Language Basics\n\n- Static typing with generics — strong type system with generic types, functions, and methods. No `any` escape hatch\n- Rust-like semantics without lifetimes — value semantics, references (`\u0026T`, `\u0026mut T`), and structs with `impl` blocks, but memory is managed by Wasm GC, so no lifetime annotations needed\n- Familiar syntax — borrows from Rust (structs, `impl`, `let`/`let mut`) and JavaScript/TypeScript (template strings with backticks, ES module-style `use {...} from \"...\"` imports)\n\n### Effect System\n\nEffects map directly to WASI capabilities, making side effects explicit and controllable:\n\n```wado\nuse { println, Stdout } from \"core:cli\";\nuse { Url } from \"core:url\";\nuse { Client, Request, Response, ErrorCode, Fields, Scheme, Trailers } from \"wasi:http\";\n\nfn scheme_of(url: Url) -\u003e Scheme {\n    return match url.scheme {\n        \"http\" =\u003e Scheme::Http,\n        \"https\" =\u003e Scheme::Https,\n        scheme =\u003e Scheme::Other(scheme),\n    };\n}\n\nfn send_get(url: Url) -\u003e Response with Client {\n    let headers = Fields::new();\n    let [trailers_rx, trailers_tx] = Future::\u003cResult\u003cOption\u003cTrailers\u003e, ErrorCode\u003e\u003e::new();\n    let [req, _req_future] = Request::new(headers, null, trailers_rx, null);\n    req.set_scheme(Option::Some(scheme_of(url)));\n    req.set_authority(Option::Some(url.authority()));\n    req.set_path_with_query(Option::Some(url.path_with_query()));\n\n    let result = Client::send(req).wait();\n    trailers_tx.write(Result::Ok(null));\n\n    return match result {\n        Ok(resp) =\u003e resp,\n        Err(e) =\u003e panic(`HTTP request failed: {e}`),\n    };\n}\n\nexport fn run() with Stdout, Client {\n    let url = Url::parse(\"https://httpbin.org/get\").unwrap();\n    let resp = send_get(url);\n    println(`Status: {resp.get_status_code() as i32}`);\n}\n```\n\n`Client::send(...).wait()` is colorless async: the `wait()` suspends the task while the\nruntime drives the request, without coloring `send_get` or `run` as `async`. See\n[`example/http_get.wado`](example/http_get.wado) for the full version (request body,\nstreaming the response body, scheme handling).\n\nThe `with` clause tells you exactly what a function can do. This enables:\n\n- **Security**: Sandbox plugins with only the capabilities you grant\n- **Testability**: Swap real effects with mocks via handlers\n- **Clarity**: No hidden side effects\n\n## Design Principles\n\n### What You See Is What You Get\n\nNo macros. The code you read is the code that runs — Wasm in plain sight.\n\n### Readable Without Context Switching\n\nExplicit over implicit. No implicit type conversions, no function overloading, no hidden dependencies. You shouldn't need to jump to other files to understand what a function does.\n\n### Type-Safe by Design\n\nStrong static typing with no escape hatches like `any`. This prevents the defensive programming patterns (excessive `try-catch`, runtime type checks) that tend to creep into dynamically-typed codebases.\n\n### No Exception Unwinding\n\nErrors are handled explicitly with `Result\u003cT, E\u003e` instead of unwinding exceptions. This makes control flow predictable and easier to reason about.\n\n### Minimal Binary Size\n\nBy leveraging Wasm GC instead of bundling a runtime, Wado produces compact `.wasm` files. This is the core motivation behind the language.\n\n## Status\n\nWado is experimental. The core language — syntax, static typing, generics, closures, modules — is implemented and functional.\n\nHowever:\n\n- **WASI P3 is not yet finalized**: The spec is at release candidate stage, and runtime support is limited\n- **Wasm Component Model** is not yet supported in browsers\n- **Wasm stack switching** is not yet available in wasmtime\n\nThat said, Wado is already usable for its original purpose: embedding lightweight Wasm modules in JS projects where binary size matters.\n\n## Future Directions\n\n### Full WASI P3 Integration\n\nAs the spec finalizes and runtime support matures, Wado will leverage async streams, futures, and the full capability model.\n\n## Informed by Agentic Coding\n\nWado is developed entirely through agentic coding — AI agents write the entire code while the human handles design decisions and project management.\n\nThis isn't just a curiosity; it shaped the language itself. After a year of intensive agentic coding experience, certain patterns became clear:\n\n- **Agents excel at volume but struggle with ambiguity.** Implicit behaviors get multiplied across a codebase. Explicit, predictable semantics work better.\n- **Agents tend toward defensive programming.** Without type safety, they pepper code with `hasattr` checks and nested `try-except` blocks. Strong types eliminate this need.\n- **Exceptions break agent reasoning.** Non-local control flow is hard to predict. `Result\u003cT, E\u003e` keeps everything visible.\n\nThe result: a language where common agentic coding pitfalls are eliminated by design, not convention.\n\n## Documentation\n\n- [Cheatsheet](docs/cheatsheet.md) - Quick syntax reference\n- [Language Specification](docs/spec.md) - Full language reference\n- [Compiler Implementation](docs/compiler.md) - Compiler internals and feature checklist\n- [Benchmarks](benchmark/README.md) - Performance benchmarks vs C and JavaScript, and so on\n- [Other Documentation](docs) - WEP, research notes, etc.\n\n## Development\n\n### Development Process\n\nDeveloping entirely through agentic coding requires active management:\n\n- **Refactoring guidance**: Left unchecked, agents generate case-specific code that only works for immediate tests. Regular intervention steers toward generalizable solutions.\n- **Code minimization**: Agents tend to over-generate logic. Compilers need minimal, general-purpose code — the opposite of what agents naturally produce.\n- **Periodic refactoring phases**: Without intervention, cruft accumulates. We've done one ground-up compiler architecture redesign so far.\n\n### AI-Guided Optimization\n\nAI-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.\n\nWado's optimizer is developed using this approach:\n\n```\nAgent finds pattern → Human reviews → Deterministic optimization rule added\n```\n\nShow the generated WAT to an agent and ask it to spot inefficiencies. Review the suggestions, then implement them as permanent optimization passes.\n\n### Install Development Tools\n\nThis project uses [mise](https://mise.jdx.dev/) to manage dev tools. Install mise first:\n\n```sh\ncurl -fsSL https://mise.run | sh\n# Then add to your shell profile:\n#   eval \"$(~/.local/bin/mise activate bash)\"  # for bash\n#   eval \"$(~/.local/bin/mise activate zsh)\"   # for zsh\n```\n\nThen install project tools:\n\n```sh\nmise trust                 # trust the mise.toml config (first time only)\nmise run on-task-started   # install all project tools\n```\n\nSee [mise.toml](mise.toml) for the list of managed tools.\n\n### Build and Test\n\n```sh\ncargo build\ncargo test\n```\n\n### The Wado CLI\n\n- `wado compile FILE` - Compile Wado source to Wasm/WAT\n- `wado run FILE` - Run Wado source directly using Wasmtime\n- `wado dump FILE` - Dump internal compiler state for debugging\n- `wado format FILE` - Format Wado source code\n\n### Examples That Already Work\n\nThere are E2E test fixtures in [wado-compiler/tests/fixtures/\\*.wado](wado-compiler/tests/fixtures).\n\n### VS Code Extension\n\nThe `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:\n\n```sh\nmise run install-wado-vscode-dev    # install extension to ~/.vscode via symlink\nmise run clean-wado-vscode-dev      # uninstall it from ~/.vscode\nmise run update-wado-vscode-grammar # regenerate syntax files after changing syntax.rs\n```\n\nSee [wado-vscode/README.md](wado-vscode/README.md) for more details.\n\n### On Your Task Done\n\n```sh\nmise run on-task-done # format, clippy-fix, update resources, test\n```\n\n### Releasing\n\nReleases are cut manually on a roughly weekly cadence via [tagpr](https://github.com/Songmu/tagpr).\n\nHow it works:\n\n1. Every push to `main` (re)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.\n2. Merging the Release PR pushes tag `v\u003cnext\u003e`, which triggers `.github/workflows/release.yml` to:\n   - build pre-built binaries for five targets in parallel — Linux (`x86_64`, `aarch64`), macOS (Apple Silicon), Windows (`x86_64`, `aarch64`) — and publish them to a [GitHub Release](https://github.com/wado-lang/wado/releases) with `SHA256SUMS.txt`;\n   - run `wado publish` to push the workspace's Wado packages to [GHCR](https://github.com/orgs/wado-lang/packages) as OCI artifacts.\n3. Default bump is **patch**. Add a `tagpr:minor` or `tagpr:major` label on the Release PR to override.\n\ntagpr 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 — the release job fails if the two files disagree with the tag.\n\n## Benchmarks\n\nPer-commit performance tracking is published to GitHub Pages. Every push to `main` records runtime and binary size metrics.\n\n- [Runtime Performance](https://wado-lang.github.io/wado/benchmarks/runtime-throughput/) — throughput (work per second, higher is better) for integer, float, array, string, and compression workloads (run on wasmtime at `-O1`/`-O2`/`-O3`)\n- [Wasm Binary Size](https://wado-lang.github.io/wado/benchmarks/wasm-size/) — `.wasm` output size for representative programs (compiled at `-Os`)\n\nSee [benchmark/README.md](benchmark/README.md) and [wasm-size/README.md](wasm-size/README.md) for local benchmark instructions and comparison results against other programming languages.\n\n## Authors\n\nCopyright (c) 2026, FUJI Goro (a.k.a. gfx). Some rights reserved.\n\n## License\n\nMIT\n\nSee [LICENSE](LICENSE) for details.\n","project_url":"https://awesome.ecosyste.ms/api/v1/projects/github.com%2Fwado-lang%2Fwado","html_url":"https://awesome.ecosyste.ms/projects/github.com%2Fwado-lang%2Fwado","lists_url":"https://awesome.ecosyste.ms/api/v1/projects/github.com%2Fwado-lang%2Fwado/lists"}