Almide

A programming language designed for LLM code generation.

Playground · Specification · Grammar · Cheatsheet · Design Philosophy

Almide is a statically-typed language optimized for AI-generated code. It compiles to native binaries (via Rust) and WebAssembly.

The core metric is modification survival rate — how often code still compiles and passes tests after a series of AI-driven modifications. The language achieves this through unambiguous syntax, actionable compiler diagnostics, and a standard library that covers common patterns out of the box.

The flywheel: LLMs write Almide reliably → more code is produced → training data grows → LLMs write it better → the ecosystem expands.

Measured by almide-dojo across 30 tasks (basic / intermediate / advanced):

Try it in your browser → — No installation required.

curl -fsSL https://raw.githubusercontent.com/almide/almide/main/tools/install.sh | sh

irm https://raw.githubusercontent.com/almide/almide/main/tools/install.ps1 | iex

Requires Rust (stable, 1.89+):

git clone https://github.com/almide/almide.git
cd almide
cargo build --release
cp target/release/almide ~/.local/bin/

fn main() -> Unit = {
  println("Hello, world!")
}

almide run hello.almd

• Multi-target — Same source compiles to native binary (via Rust) or WebAssembly (direct emit)
• Generics — Functions (fn id[T](x: T) -> T), records, variant types, recursive variants with auto Box wrapping
• Pattern matching — Exhaustive match with variant destructuring
• Effect functions — effect fn for explicit error propagation (Result auto-wrapping)
• Bidirectional type inference — Type annotations flow into expressions (let xs: List[Int] = [])
• Codec system — Type.decode(value) / Type.encode(value) convention with auto-derive
• Map literals — ["key": value] syntax with m[key] access and for (k, v) in m iteration
• Fan concurrency — fan { a(); b() }, fan.map, fan.race, fan.any, fan.settle
• Top-level constants — let PI = 3.14 at module scope, compile-time evaluated
• Pipeline operator — data |> transform |> output
• Module system — Packages, sub-namespaces, visibility control, diamond dependency resolution
• Standard library — 430 functions across 23 modules (string, list, map, json, http, fs, etc.)
• Built-in testing — test "name" { assert_eq(a, b) } with almide test
• Actionable diagnostics — Every error includes file:line, context, and a concrete fix suggestion

• Predictable — One canonical way to express each concept, reducing token branching for LLMs
• Local — Understanding any piece of code requires only nearby context
• Repairable — Compiler diagnostics guide toward a specific fix, not multiple possibilities
• Compact — High semantic density, low syntactic noise

For the full design rationale, see Design Philosophy.

let PI = 3.14159265358979323846
let SOLAR_MASS = 4.0 * PI * PI

type Tree[T] =
  | Leaf(T)
  | Node(Tree[T], Tree[T])

fn tree_sum(t: Tree[Int]) -> Int =
  match t {
    Leaf(v) => v
    Node(left, right) => tree_sum(left) + tree_sum(right)
  }

effect fn greet(name: String) -> Result[Unit, String] = {
  guard string.len(name) > 0 else err("empty name")
  println("Hello, ${name}!")
  ok(())
}

effect fn main() -> Result[Unit, String] = {
  greet("world")
}

test "greet succeeds" {
  assert_eq("hello".len(), 5)
}

Almide source (.almd) is compiled by a pure-Rust compiler through a three-layer codegen architecture:

.almd → Lexer → Parser → AST → Type Checker → Lowering → IR
                                                            ↓
                                              Nanopass Pipeline (semantic rewrites)
                                                            ↓
                                              Template Renderer (TOML-driven)
                                                            ↓
                                                    .rs / .wasm

The Nanopass pipeline applies target-specific transformations: ResultPropagation (Rust ?), CloneInsertion (Rust borrow analysis), LICM (loop-invariant code motion). The Template Renderer is purely syntactic — all semantic decisions are already encoded in the IR.

almide run app.almd              # Compile + execute (Rust target)
almide run app.almd -- arg1      # With arguments
almide build app.almd -o app     # Build standalone binary
almide build app.almd --target wasm  # Build WebAssembly (WASI)
almide compile                   # Compile to .almdi (module interface + IR)
almide compile parser            # Compile a specific module
almide compile --json            # Output interface as JSON
almide test                      # Find and run all test blocks (recursive)
almide test spec/lang/           # Run tests in a directory
almide test --run "pattern"      # Filter tests by name
almide check app.almd            # Type check only
almide check app.almd --json     # Type check with JSON output
almide fmt app.almd              # Format source code
almide clean                     # Clear build + dependency cache

Almide emits WASM bytecode directly (no Rust/C intermediary). Each binary is self-contained — allocator, string handling, and runtime are all included. No external GC or host runtime dependency.

Sizes below are with ALMIDE_WASM_OPT=1 (post-build wasm-opt -O3, opt-in for now).

For trivial programs the two are tied. For numerical / stdlib-heavy code, Almide stays small while wasm-bindgen grows with API surface:

Why: wasm-bindgen's type-marshalling glue grows with each exported API; Almide's stdlib lives in a single coherent runtime that doesn't bloat as the call surface expands.

Bench source: almide-wasm-bindgen/examples/bench.

Almide compiles to Rust, which then compiles to native machine code. No runtime, no GC, no interpreter.

Comparison with 15 established languages using mame/ai-coding-lang-bench (MiniGit implementation task).

Almide uses Sonnet 4.6 (unknown language); all others use Opus 4.6 (known language). Almide achieves 100% pass rate with fewer lines of code than most languages, despite needing more time due to the model having no prior training data for the language.

Single source of truth for Almide syntax — keywords, operators, precedence, and TextMate scopes. Written in Almide itself.

All tools that need to know Almide's syntax import this module rather than maintaining their own keyword lists:

# almide.toml
[dependencies]
almide-grammar = { git = "https://github.com/almide/almide-grammar", tag = "v0.1.0" }

import almide_grammar
almide_grammar.keyword_groups()    // 6 groups, 41 keywords
almide_grammar.precedence_table()  // 8 levels, pipe → unary

The compiler itself uses almide-grammar's TOML files (tokens.toml, precedence.toml) at build time to generate its lexer keyword table — ensuring the compiler and all tooling stay in sync.

• VS Code — vscode-almide — Syntax highlighting, bracket matching, comment toggling, code folding
• Tree-sitter — tree-sitter-almide — Tree-sitter grammar for editors that support it (Neovim, Helix, Zed)

Browser-based compiler and runner. The Almide compiler runs as WASM — no server, no installation. Try it at almide.github.io/playground.

• docs/ARCHITECTURE.md — Compiler pipeline, module map, design decisions
• docs/SPEC.md — Full language specification
• docs/GRAMMAR.md — EBNF grammar + stdlib reference
• docs/CHEATSHEET.md — Quick reference for AI code generation
• docs/DESIGN.md — Design philosophy and trade-offs
• docs/STDLIB-SPEC.md — Standard library specification (381 functions)
• docs/roadmap/ — Language evolution plans

Contributions are welcome! Please open an issue or pull request on GitHub.

After cloning, install the git hooks:

brew install lefthook  # macOS; see https://github.com/evilmartians/lefthook for other platforms
lefthook install

All commits must be in English (enforced by the commit-msg hook). See CLAUDE.md for project conventions.

Licensed under either of MIT or Apache 2.0 at your option.