A programming language built for AI to write and people to read. One language from a quick script to a full app, and you can follow every line.
// A plain function: text in, text out.
fn shout(msg: String) -> String {
msg.to_upper()
}
// This one prints, so its type shows it: ! IO
fn run() -> () ! IO {
Console.log(shout("hello, lingo"))
}Most programming languages were designed decades ago, for people typing at a keyboard. Today a lot of code is written by AI, and read, checked, and trusted by people. Lingo is built for both sides of that: easy for an AI to write correctly, and easy for a person to read and verify.
Try it yourselfEach is the load-bearing token in its snippet, spotlighted in blue. The code examples are real and runnable today; the lockfile, diagnostic, and CLI snippets are the toolchain's actual output. New to effects, capabilities, or refinement types? The language reference defines each.
The signature tells you - and the agent - everything a function can do. This one reads the filesystem, so its type carries ! FS; a function with no effect row can't touch the outside world at all.
fn describe(path: String) -> String ! FS {
match Fs.read_file(path) {
Ok(_) -> "read ${path}"
Err(_) -> "missing ${path}"
}
}A function can only do what it was granted. Derive a narrower capability and hand it down - least authority, enforced structurally.
Shipped · values + scoped derivation// use_fs can touch the filesystem and nothing else.
fn use_fs(c: Cap<FS>) -> String { "scoped" }
fn run(cap: Cap<Root>) -> () ! IO {
let fs = cap.fs()
Console.log(use_fs(fs))
}Machine-verified properties replace docstrings. The bound lives in the type, so the compiler checks every assignment site.
Shipped · core + SMT provetype Port = Int where 0 <= x <= 65535
fn run() -> () ! IO {
let http: Port = 80 // ok
let bad: Port = 99999 // T0301 at compile time
}Functions are keyed by the hash of their AST, not their name. Renames are free; parallel agents can't collide on names.
hash_v1: {
"app.lingo:double": "blake3:archko…"
"app.lingo:is_even": "blake3:6lnhwl…"
}The compiler emits JSON with a machine-applicable fix. The human CLI is the thin wrapper, not the other way round.
{
"code": "T0004",
"suggestion": {
"action": "add_effect"
}
}One formatter, one test runner, one toolchain. Deprecated forms are removed, not aliased, so there are no dialects to memorise.
lingo build
lingo test
lingo format
lingo fixVirtual time, seeded random, no global mutable state. Same seed, same value: dice(42) is 1 on every run, with no ! Random effect.
fn dice(seed: Int) -> Int {
Random.int(seed, 1, 6)
}The combination, designed cohesively for AI authors, is what only Lingo has.
The compiler runs as a WebAssembly module, right here in the page. No server, no signup. Edit any example and press Run.
Run this in the playgroundimport lingo-lang.org/packages/hello@0.3.0 { greet, version }
fn run() -> () ! IO {
Console.log("hello@${version()}")
Console.log(greet("World"))
Console.log(greet("Lingo"))
}Any one of these exists somewhere else. The whole set doesn't.
| Capability | Lingo | Gleam | Roc | Unison | Koka | Lean 4 | Haskell |
|---|---|---|---|---|---|---|---|
| Effects in the type | ✓ | — | partial | ✓ | ✓ | partial | partial |
| Capability passing | ✓ | — | partial | — | — | — | — |
| Refinement types | ✓ | — | — | — | — | ✓ | ✓ |
| Content-addressed code | ✓ | — | — | ✓ | — | — | — |
| Machine-first JSON diagnostics | ✓ | — | — | — | — | partial | partial |
| One canonical form + formatter | ✓ | ✓ | ✓ | partial | — | — | — |
| Determinism foundation | ✓ | — | — | — | — | — | — |
Peer by peer
A small, friendly type system, an excellent formatter, and battle-tested concurrency on the BEAM.
Lingo's betEffects and capabilities in the type, refinement types, content-addressing, and JSON-first diagnostics - the gaps that made us build it.
Fast pure functional code, an opinionated formatter, and effects marked with a ! suffix on a capability-secure platform.
Lingo's betEffects and capabilities tracked in the type itself rather than delegated to the platform, plus refinement types and content-addressing.
Content-addressed code by hash of the definition, so renames are free and parallel edits never collide on names, plus abilities for algebraic effects.
Lingo's betThe same content-addressing and effects, extended with capabilities and refinement types, over ordinary files instead of a codebase manager.
Pioneered row-typed algebraic effects and handlers, and the Perceus reference counting that Lingo's runtime is built on.
Lingo's betThe same effects and Perceus foundation, extended with first-class capabilities, refinement types, and content-addressing, aimed at AI authors.
Dependent types and a full proof assistant - the strongest correctness guarantees of any language here.
Lingo's betTrade dependent-type proofs for deterministic, explicit execution: SMT-checked refinement types for the properties that matter at runtime, without the proof burden. Lean is for truth; Lingo is for action.
Refinement types over Haskell - SMT-checked logical predicates carried in the type.
Lingo's betRefinement types as a built-in, not a layer over GHC, composed with effects, capabilities, and content-addressing in one language.
These are the languages Lingo learned from - Koka pioneered the effects, Unison the content-addressing, Liquid Haskell the refinements, and each still leads Lingo in its own column. The bet is the full set, combined cohesively for an audience that reads more than it writes.
One source, one analysis pipeline, many output artifacts. Lex, typecheck, effects, capabilities and the target-constraint solver are unified across every target - only the final emission step differs.
Designed for AI authors from the start: one canonical language across every target, with no polyglot glue and no per-platform dialects to reconcile. The same source stays verifiable, sandboxable, and composable wherever it runs - properties an agent can build on.
serve backendview frontend · trace / log observabilitystore data layerThe differentiators are in. Version 1 lands when a capstone ships as proof - the self-hosting compiler is the stamp - and the spec is the cold-start doc for an AI agent. The timing is open; capstone progress drives it. The compiler will be open source.