pre-alphaM0 to M2 run on JavaScript, no release yet

Code that keeps
its promises.

Sakura Lang is the language agents write. Every signature declares its effects, errors and contracts, and the compiler holds the code to them.

Read the docs For agents

agents GET /llms.txt, or any page + .md

src/users.sakura

error EmailTaken(email: Email)error Bannedtype SignupError = EmailTaken | Bannedfn signup(email: Email, pw: Password)  -> User ! {Clock, Db, Random, Fail<SignupError>}  ensures result.email == email{  if Db.exists(users, email) { fail EmailTaken { email } }  let id = Random.uuid()  let user = User { id, email, joined: Clock.now() }  Db.insert(users, user)  let _ = Http.post_json(crm_hook, user)  user}

error V3001 src/users.sakura:12:11

function signup performs Http, which its signature does not allow.

interface_changeadd Http to the signature: needs review
agentremoves the call instead← keeps the promise

sakura check --json

The signature is the contract.

Five lines a person can review. The compiler holds the body to every one of them.

src/accounts.sakurahover a clause

fn withdraw(acct: Account, amount: Cents)
Takes.Typed inputs. Cents is a refinement: an Int that is never negative.
-> Account
Returns.The updated account. Nothing else comes back.
! {Ledger, Fail<Overdrawn | Frozen>}
May do.Only Ledger: no network, files or clock. It fails in exactly two named ways.
requires positive: amount > 0
Requires.The caller's duty. Breaking it is the caller's defect, D020.
ensures result.balance == acct.balance - amount
Ensures.The promise, checked on every return in every build, D021.
{ … }the body: checked against the clauses above, then out of the way

Reviewed by: a person, reading five lines
Held by: sakura check, on every change

Review promises, not diffs.

An agent can rewrite six hundred lines before you finish your coffee. Nobody reviews that well. In Sakura Lang, everything a function is allowed to do lives in its signature, so review shrinks to the lines that change a promise.

agent/billing-retries

5 files +612 −388

src/billing/retry.sakura+214 −90signatures kept
src/billing/ledger.sakura+131 −122signatures kept
src/billing/charge.sakuraReview: promise changed
Removed: pub fn charge(card: Card, amount: Cents) -> Receipt ! {Payments, Fail<ChargeError>}
Added: pub fn charge(card: Card, amount: Cents) -> Receipt ! {Http, Payments, Fail<ChargeError>}
charge now makes HTTP calls. That is a decision for a person, so the diff surfaces it, and nothing else.
src/billing/webhooks.sakura+156 −104signatures kept
test/billing_test.sakura+73 −61signatures kept

Illustrative review of an agent's change. The tooling is part of the design, not a shipped product.

Effects are requirements. Handlers answer them.

signup says it needs a database, a clock and a way to fail. It never says which. Whoever calls it installs handlers, so a test swaps the database for memory with no mocking library and no change to the code.

with sql_db() { Serve.listen(router, addr) }

sql_db()

clauses call Sql.sqlite

Db.exists(…)

Clock.host()

reads the system clock

Clock.now()

try/catch

turns it into a 409

fail EmailTaken

DbClockFail<SignupError>

signup(email, pw) · the body is the same in both

Effects HandlersHandlers are tail-resumptive: a clause returns the result once. No resume, no Async.

Authority only narrows.

An effect says what a function needs. The handler around it decides how much it gets. Root handlers come from the host, capped by sakura.toml; every with below can narrow that, and nothing can widen it. There is no ambient authority to import.

hosteverything the machine can do

sakura.toml [permissions]fs.read = ["./data"], net = [], the ceiling

main() ! {Console, Cli, Fs, …}root handlers for these effects only

with Fs.rooted(Dir.subdir(…, "data"))paths resolve inside ./data

word_counts(text) -> Map<String, Int>pure: no row, no authority at all

Scopes of authority for the CLI example in design §15.6, outermost first.

Fs.read("../.ssh/id_ed25519")FsErroroutside the rooted directory; symlink escapes are rejected too
main declares Http, net = []exit 75refused at startup, not at first use
a captured Dir outlives its withV6002capabilities cannot escape the scope that made them
Log.event(Level.Info, "{token}", [])V2031Secret<String> is not Show, so it can never be logged

Capabilities and security

Every claim says how it is known.

Sakura Lang never calls a program verified because it compiled. Each obligation gets exactly one status, and the tools report it.

01proved
the type and effect checker, on every build
- every effect has a handler
- every Fail tag is caught or declared
- every match is exhaustive
- no null, no unchecked index
02runtime_checked
a check at the boundary; a violation is a defect
- requires ordered: lo <= hi
- where it >= 0 && it <= 100
- Int overflow
03tested
sakura test, on the inputs that ran
- property "normalize is idempotent"
- sakura test --contracts
- snapshots
04trusted
assumed, and listed in the build manifest
- @external bindings
- @trust("reason")
- host handlers

In v0 every contract is runtime_checked, in every build including --release. From M4, sakura verify can move a single obligation to proved and drop only that check. Contracts

How an agent works with Sakura Lang.

The compiler is the agent's other half. Every answer it gives is data a model can act on, and every change it would make says how far it reaches.

writeagent
drafts the body, leaves ?holes where it is unsure
sakura check --jsoncompiler
diagnostics and hole records as JSON Lines
apply fixesagent
local fixes go in; signature changes go to a person
sakura testcompiler
deterministic handlers, fixed seed, shrunk failures
↺ until check and test are clean

01writeagent

drafts the body, leaves ?holes where it is unsure

02sakura check --jsoncompiler

diagnostics and hole records as JSON Lines

04sakura testcompiler

deterministic handlers, fixed seed, shrunk failures

03apply fixesagent

local fixes go in; signature changes go to a person

GET /llms.txt

# Sakura Lang > Sakura Lang is an agent-first programming language. Every signature declares its effects, errors and contracts, and the compiler seals them on every build. Sakura Lang is pre-alpha and nothing is released. The v0 language design is written (docs/design.md in the repository). The compiler builds from source and checks and runs M0 to M2 programs (effects, handlers, typed errors, holes) on JavaScript; the M3 standard library (http, sql, fs, cli, ai, task) is not built yet, so examples that use it do not run. Build it: https://sakura-lang.vercel.app/docs/quickstart - The core language for agents, in one file: https://github.com/icantcodefyi/sakura-lang/blob/master/docs/llms.txt- Every docs page is available as Markdown: append `.md` to its URL (for example https://sakura-lang.vercel.app/docs/tour/effects.md).- All docs in one file: https://sakura-lang.vercel.app/llms-full.txt ## Start- [Introduction](https://sakura-lang.vercel.app/docs): Sakura Lang is an agent-first, general-purpose programming language in which the signature is the contract.

Live from this site. Open llms.txt or llms-full.txt.

Diagnostic and hole records are what sakura check --json emits today; the MCP server is planned for M3.

Start here if you are an agent

For agents docs

Values, without a borrow checker.

Every value is independent: no aliasing, no lifetimes, no cycles. Native code (M5) counts references at compile time and updates a uniquely owned value in place. The JavaScript backend uses the host GC; the semantics are the same.

One binary for the whole loop.

Checker, runner, formatter and test runner already share one compiler library; packages, LSP and MCP join them in M3, with a standard library for HTTP, SQLite, JSON schemas, CLIs and typed LLM calls.

sakura check: types, effects, exhaustiveness, holes
sakura run: build to JavaScript and run main
sakura test: deterministic handlers, properties, snapshots
sakura fmt: one canonical format
sakura explain: any code, with a wrong and a fixed program
sakura prompt: the language guide for agents
sakura fix: fixes gated by impact classplanned
sakura mcp serve: the compiler as MCP toolsplanned

For code an agent writes, defaults decide.

Every language below can be written carefully. The question is what holds when nobody is being careful: what the compiler enforces by default.

Side effects in the signature
Sakura Lang: Yes, checkedTypeScript: No, hiddenPython: No, hiddenRust: No, hiddenEffect-TS: Yes, R channel
Errors in the signature
Sakura Lang: Yes, Fail<E> error unionsTypeScript: No, untyped throwPython: No, untyped raiseRust: Yes, ResultEffect-TS: Yes, E channel
No null, no exceptions
Sakura Lang: YesTypeScript: Partly, strict nulls, throw remainsPython: No, None, raiseRust: Partly, Option, panics remainEffect-TS: Partly, JS throw remains
Memory without GC pauses or lifetimes
Sakura Lang: Yes, native RC with reuse; JS GCTypeScript: No, tracing GCPython: Partly, RC plus cycle GCRust: Partly, no GC, lifetimesEffect-TS: No, tracing GC
Contracts and refinement types
Sakura Lang: Yes, always checked at runtimeTypeScript: NoPython: No, runtime librariesRust: Partly, external verifiersEffect-TS: Partly, Schema, at runtime
Authority you grant, not ambient
Sakura Lang: Yes, handlers grant authorityTypeScript: NoPython: NoRust: NoEffect-TS: Partly, services, not enforced
Taint and secret types
Sakura Lang: Yes, Untrusted, SecretTypeScript: NoPython: NoRust: Partly, newtypes by conventionEffect-TS: Partly, Redacted
Diagnostics as data, with fixes
Sakura Lang: Yes, fixes declare impactTypeScript: Partly, tsserver code fixesPython: Partly, varies by toolRust: Yes, JSON, applicable fixesEffect-TS: Partly, via TypeScript
One way to do each thing
Sakura Lang: Yes, small grammarTypeScript: NoPython: Partly, by conventionRust: NoEffect-TS: No, many styles

Comparison of language defaults relevant to agent-written code. The Sakura Lang column describes design goals.
By default	Sakura Langdesign	TypeScript	Python	Rust	Effect-TS
Side effects in the signature	Yes: checked	No: hidden	No: hidden	No: hidden	Yes: R channel
Errors in the signature	Yes: Fail<E> error unions	No: untyped throw	No: untyped raise	Yes: Result	Yes: E channel
No null, no exceptions	YesYes	Partly: strict nulls, throw remains	No: None, raise	Partly: Option, panics remain	Partly: JS throw remains
Memory without GC pauses or lifetimes	Yes: native RC with reuse; JS GC	No: tracing GC	Partly: RC plus cycle GC	Partly: no GC, lifetimes	No: tracing GC
Contracts and refinement types	Yes: always checked at runtime	No	No: runtime libraries	Partly: external verifiers	Partly: Schema, at runtime
Authority you grant, not ambient	Yes: handlers grant authority	No	No	No	Partly: services, not enforced
Taint and secret types	Yes: Untrusted, Secret	No	No	Partly: newtypes by convention	Partly: Redacted
Diagnostics as data, with fixes	Yes: fixes declare impact	Partly: tsserver code fixes	Partly: varies by tool	Yes: JSON, applicable fixes	Partly: via TypeScript
One way to do each thing	Yes: small grammar	No	Partly: by convention	No	No: many styles

enforced by default partly, or by convention or library not providedThe Sakura Lang column states design goals; the M0 to M2 parts run today.

Designed. Running in part.

The compiler checks and runs M0 to M2 programs on JavaScript today. M3 is under way, in the open, and nothing is released yet. Full roadmap

M0Runs today
Hello, effects
Lexer, parser, Console, inference, CPS JavaScript, sakura run and sakura check --json.
M1Runs today
Pure language, typed errors
Records, variants, exhaustive match, Fail with try/catch, std in Sakura Lang, tests, sakura fmt.
M2Runs today
Handlers and holes
User effects and handlers, row variables, deterministic test handlers, typed holes.
M3In progress
Contracts and agents
Runtime contracts, permissions, Secret and Untrusted, Task, Http, Sql, LSP and MCP.
M4
WASM and verify
WASM backend; sakura verify discharges contracts with Z3 and drops proved checks.
M5
Native
Cranelift backend with Perceus reference counting and in-place reuse.

Read the design. Then hold us to it.

The docs are written for people and for the agents that work with them. Every page is one fetch away as Markdown.

Read the docs View on GitHub

Code that keeps its promises.

The signature is the contract.

Review promises, not diffs.

Effects are requirements. Handlers answer them.

Authority only narrows.

Every claim says how it is known.

How an agent works with Sakura Lang.

Start here if you are an agent

Values, without a borrow checker.

One binary for the whole loop.

For code an agent writes, defaults decide.

Designed. Running in part.

Hello, effects

Pure language, typed errors

Handlers and holes

Contracts and agents

WASM and verify

Native

Read the design. Then hold us to it.

Code that keeps
its promises.