gdp-wired
An automatic prover for stateful rules.
Budgets, caps, rate limits, workflows, access policies. You write the rule and the laws it must keep. gdp-wired proves them with no proof to write, shows a real run that breaks a law when it's false (found by searching on the GPU), has every proof checked again by Lean, and ships the rule as JavaScript.
Laws as comments in 11 languagesNew to formal verification? Read the guideGitHubnpmWatch the film (1:25, with sound)
In a minute · npx gdp-wired-cli check
One comment. One command.
TypeScript is the native, first-class path on both routes. Write rules and laws with the
gdp-wired TypeScript library API and proveRule, or run
npx gdp-wired-cli check file.ts on plain TypeScript/JavaScript, Effect services or XState machines
with // gdp: law comments. The CLI also reads Python, Go, Rust, Java, Kotlin, Swift, Ruby, Elixir, C
and C++. See what each reader supports and refuses.
The film
The frontier · measured at 0.30, CHC-COMP since
At the front of the field, in our harness*
One automatic prover against each benchmark's best tool: our worst run against the best rival's best run. Every answer is checked by the kernel, and none is wrong.
The numbers as a table
| Benchmark | gdp-wired | Best rival | Rival | Lead |
|---|---|---|---|---|
| CHC-COMP LIA-Lin | 1,159–1,169 | Golem (Spacer (Z3) about 1,156) | up to 1,163 | level |
| TIP 2015 | 212–213 | Vampire | 187 | +25 |
| SV-COMP termination | 246 | Ultimate Automizer | 224 | +22 |
| TermComp ITS, terminates | 613–614 | KoAT2 | 601 | +12 |
| TermComp ITS, doesn’t terminate | 538–542 | LoAT | 532 | +6 |
0.49 · IC3Syn's distributed protocols
All 29 protocols. Nothing written.
IC3Syn (Cao, Wu, Yao, Wei, Chen, Ma, arXiv 2605.24619, May 2026) synthesizes invariants for 29 TLA+ protocols: leader election, consensus, Paxos, two-phase commit, sharded key-value stores, lock services. We ported the whole suite and checked each port against TLC step by step. gdp-wired proves all 29 with no invariant, lemma or hint written, by the same prover that proves an app's budget cap, and every proof is a certificate checked twice: by the kernel, then by Lean.
- of 29 proven with nothing written, each checked by the kernel
- 29
- Lean 4.34.0 theorems, on propext, Classical.choice and Quot.sound only
- 67
- obligation proofs joined into the Lean theorem of MLDR, the hardest
- 35
- broken variants refuted with a run; none ever proven
- 11
| Release | Proven | Budget |
|---|---|---|
| 0.37 | 14 of 29 | 60 s |
| 0.39 | 15 of 29 | 60 s |
| 0.40 | 16 · 18 of 29 | 60 s · 300 s |
| 0.41 | 19 of 29 | 300 s |
| 0.43 | 20 of 29 | a 60-second counted budget |
| 0.44 | 19–20 of 29 | 60 s of wall time, each protocol alone on its machine |
| 0.45 | 22 of 29 | 60 s of wall time on pinned hardware, in every run (24 in some) |
| 0.49 | 29 of 29 | larger budgets than those runs, in our harness |
MLDR, MongoDB's logless dynamic reconfiguration: its Lean certificate is too large to check in one build on a 32 GB machine, so it was checked as 35 obligation proofs joined into the family theorem.
11 · 11 · 7 Each protocol has a broken variant with a planted bug: 11 refuted with an actual counterexample run, 11 rejected on a small instance without a trace, 7 still open. None is proven.
10 of 10 before IC3Syn: the DistAI and DuoAI protocols (locks, leader election on a ring, consensus), all ten inside 60 s in every run at 0.33, 200 of 200 over 20 runs each.
Not claimed
- All 29 within the reference budget (counted work equal to 600 reference CPU seconds, IC3Syn's default timeout): that result is pending, to be published as an addendum.
- A lead over IC3Syn or the tools it measures: our budgets differ from the paper's.
- Implementations: the proofs are of the stated laws of the protocols' models.
- Lean checks the exported certificates; binding them to the original machines in Lean is not yet claimed.
Nothing on trust
Every answer, checked.
Proven
A certificate a small kernel checks
Every proof comes with a certificate, and a
small kernel (kernel/kernel.ts) checks it. The prover that found it is untrusted: if it is wrong, the kernel
refuses the proof.
Again
Re-checkable in Lean
Every proof leaves as a Lean theorem. The kernel's twin in
Lean 4.34.0 is proven sound on the standard axioms, and lake build checks the proofs again.
Broken
The exact run that breaks it
A false law comes back with a real run from the start: the params and each request in order, replayed before it counts.
The benchmarks get the same treatment: on CHC-COMP every sat answer is the kernel's proof on the original rule
and every unsat answer a run that checkDerivation confirms.
The same law, three ways
The proof is one line.
A request of cost c is admitted while spend s is under budget b; each request is capped
at m. The law: spend stays within b + m after any sequence of requests. Real code from the repository's
compare/, each one checked.
import {min, nat, proveRule, rule, when} from 'gdp-wired'
// A request of cost c is admitted while spend s is under budget b; each request is capped at m.
const budget = rule('budget')
.params({b: nat, m: nat})
.inputs({c: nat})
.state({s: 0})
.step(({b, m, c, s}) => ({s: when(s.lt(b), s.plus(min(c, m)), s)}))
// The law
const bounded = budget.law('spend stays within b + m', ({s, b, m}) => s.atMost(b.plus(m)))
// The proof
proveRule(budget, [bounded]) // {proven: true, checked: true}
Proven by induction over steps; the kernel checks the tree the prover grows. 25 ms, whole command.
-- Rule 1, the budget, in plain Lean 4 (core only): s from 0; a request of cost c adds min c m while s < b.
-- Law: s ≤ b + m after any list of requests, proven by hand (induction on the list, omega per step).
-- --- rule
def step (b m s c : Nat) : Nat := if s < b then s + min c m else s
def run (b m s : Nat) : List Nat → Nat
| [] => s
| c :: cs => run b m (step b m s c) cs
-- --- laws
theorem bounded (b m : Nat) (cs : List Nat) : run b m 0 cs ≤ b + m := by
-- --- proofs
suffices h : ∀ s, s ≤ b + m → run b m s cs ≤ b + m from h 0 (Nat.zero_le _)
induction cs with
| nil => intro s hs; exact hs
| cons c cs ih =>
intro s hs
apply ih
have := Nat.min_le_right c m
unfold step; split <;> omega
Plain Lean 4.34.0, core only: induction on the list by hand, omega per step. 488 ms.
# Rule 1, the budget, in Bend 2: s from 0; a request of cost c adds min(c, m)
# while s < b. Law: s <= b + m after any list of requests, proven by hand:
# induction on the list, with the step's comparison carried as evidence
# (Cmp2), since a Bend proof cannot case on a computed Bool.
import Base
# --- evidence
# a <= b as a type: Unit when it holds, Empty when it doesn't
def LE(a: Nat, b: Nat) -> Data:
match a b:
case 0n y:
Unit
case 1n+x 0n:
Empty
case 1n+x 1n+y:
LE(x, y)
# a comparison with its evidence: x <= y, or y < x
type Cmp2<-x: Nat, -y: Nat> is Data:
IsLe{e: LE(x, y)}
IsGt{e: LE(1n+y, x)}
def dec.up(-a: Nat, -b: Nat, w: Cmp2<a, b>) -> Cmp2<1n+a, 1n+b>:
match w:
case IsLe{e}:
IsLe{e}
case IsGt{e}:
IsGt{e}
def dec(x: Nat, y: Nat) -> Cmp2<x, y>:
match x y:
case 0n y:
IsLe{Unit{}}
case 1n+a 0n:
IsGt{Unit{}}
case 1n+a 1n+b:
dec.up(a, b, dec(a, b))
# --- rule
def step.go(s: Nat, -b: Nat, c: Nat, m: Nat, w: Cmp2<b, s>) -> Nat:
match w:
case IsLe{e}:
s
case IsGt{e}:
Nat.add(s, Nat.min(c, m))
def step(+s: Nat, +b: Nat, c: Nat, m: Nat) -> Nat:
step.go(s, b, c, m, dec(b, s))
def run(cs: List<&2, Nat>, s: Nat, +b: Nat, +m: Nat) -> Nat:
match cs:
case Nil{}:
s
case Con{c, t}:
run(t, step(s, b, c, m), b, m)
# --- laws
law bounded:
for b: Nat
for m: Nat
for cs: List<&2, Nat>
LE(run(cs, 0n, b, m), Nat.add(b, m))
# --- proofs
def le_refl(a: Nat) -> LE(a, a):
match a:
case 0n:
Unit{}
case 1n+x:
le_refl(x)
def le_succ(a: Nat, b: Nat, e: LE(a, b)) -> LE(a, 1n+b):
match a:
case 0n:
Unit{}
case 1n+x:
match b:
case 0n:
Empty.absurd(LE(x, 0n), e)
case 1n+y:
le_succ(x, y, e)
def le_trans(a: Nat, b: Nat, c: Nat, ab: LE(a, b), bc: LE(b, c)) -> LE(a, c):
match a:
case 0n:
Unit{}
case 1n+x:
match b:
case 0n:
Empty.absurd(LE(1n+x, c), ab)
case 1n+y:
match c:
case 0n:
Empty.absurd(LE(1n+x, 0n), bc)
case 1n+z:
le_trans(x, y, z, ab, bc)
def le_pred(s: Nat, b: Nat, e: LE(1n+s, b)) -> LE(s, b):
match s b:
case 0n y:
Unit{}
case 1n+x 0n:
Empty.absurd(LE(1n+x, 0n), e)
case 1n+x 1n+y:
le_pred(x, y, e)
def le_add(k: Nat, +m: Nat) -> LE(m, Nat.add(k, m)):
match k:
case 0n:
le_refl(m)
case 1n++p:
le_succ(m, Nat.add(p, m), le_add(p, m))
def add_le_l(s: Nat, -k: Nat, -j: Nat, e: LE(k, j)) -> LE(Nat.add(s, k), Nat.add(s, j)):
match s:
case 0n:
e
case 1n+p:
add_le_l(p, k, j, e)
def add_le_r(a: Nat, b: Nat, +m: Nat, e: LE(a, b)) -> LE(Nat.add(a, m), Nat.add(b, m)):
match a b:
case 0n y:
le_add(y, m)
case 1n+x 0n:
Empty.absurd(LE(Nat.add(1n+x, m), m), e)
case 1n+x 1n+y:
add_le_r(x, y, m, e)
def min_le(c: Nat, m: Nat) -> LE(Nat.min(c, m), m):
match c m:
case 0n y:
Unit{}
case 1n+x 0n:
Unit{}
case 1n+x 1n+y:
min_le(x, y)
def step_ok.go(+s: Nat, +b: Nat, +c: Nat, +m: Nat, w: Cmp2<b, s>, h: LE(s, Nat.add(b, m))) -> LE(step.go(s, b, c, m, w), Nat.add(b, m)):
match w:
case IsLe{e}:
h
case IsGt{e}:
le_trans(Nat.add(s, Nat.min(c, m)), Nat.add(s, m), Nat.add(b, m),
add_le_l(s, Nat.min(c, m), m, min_le(c, m)),
add_le_r(s, b, m, le_pred(s, b, e)))
def step_ok(+s: Nat, +b: Nat, +c: Nat, +m: Nat, h: LE(s, Nat.add(b, m))) -> LE(step(s, b, c, m), Nat.add(b, m)):
step_ok.go(s, b, c, m, dec(b, s), h)
def run_ok(cs: List<&2, Nat>, +s: Nat, +b: Nat, +m: Nat, h: LE(s, Nat.add(b, m))) -> LE(run(cs, s, b, m), Nat.add(b, m)):
match cs:
case Nil{}:
h
case Con{+c, t}:
run_ok(t, step(s, b, c, m), b, m, step_ok(s, b, c, m, h))
def bounded(b, m, cs):
run_ok(cs, 0n, b, m, Unit{})
Bend 2: the comparison carried as evidence, and the ≤ lemmas written out. 137 ms.
| Rule | Tool | Proof lines | Check, median |
|---|---|---|---|
| budget | gdp-wired | 1 | 25 ms |
| Lean | 8 | 488 ms | |
| Bend | 84 | 137 ms | |
| caps | gdp-wired | 1 | 44 ms |
| Lean | 30 | 547 ms | |
| Bend | 74 | 161 ms | |
| window | gdp-wired | 2 | 42 ms |
| Lean | 29 | 571 ms | |
| Bend | 117 | 156 ms |
Most of each check time is the tool's startup floor: 17 ms for gdp-wired, 134 ms for Bend, 453 ms for Lean. Every tool was also handed the same bug for each rule, and rejected it.
When a law is false
You get a real run that breaks it.
Forget the cap: write s.plus(c) instead of s.plus(min(c, m)). The kernel refuses the proof, and a search
from the start turns the failure into a run you can replay.
Searches over short histories run on the GPU; every hit is replayed before it counts.
// the step, with the cap forgotten
.step(({b, c, s}) => ({s: when(s.lt(b), s.plus(c), s)}))
proveRule(budget, [bounded])
// refused, and a run that breaks the law:
// {params: {b: 1, m: 0}, trace: [{c: 2}]}
What it proves
Laws about state, automatically.
Invariants
A law that holds after every sequence of requests: spend stays within the budget.
Maps, sets and lists
Laws at every key (no day passes its cap) or every two keys (a batch taken only when it increases), sets a request carries, lists kept in order.
Step laws
What one step does (a balance only goes down), and laws over up to 64 steps in a row.
Histories and sums
Sums and queries over a log of requests, like a sliding-window rate limit, and sums over every key of a map with
M.sum().Orderings at any distance
A refund never follows a release, through ghost state that watches the rule.
Liveness
Every ticket issued is served, in every run that keeps sending the requests that help, under weak or strong fairness.
Refinement
An implementation behaves like a simpler spec, step for step.
Functions
Division, remainder and your own functions, known by their facts; a Lean definition brings facts proven there.
Pure functions, two runs
Laws about what a function returns, and laws comparing two calls: the secret never changes the answer.
Records and variants
State and requests made of named fields, or one of several cases (a seat free, held or sold), every case covered.
Lemmas you state
A function defined by a recurrence, and lemmas about it proven by induction: a backoff delay is at most 64 and never shrinks.
Lists and trees
An invoice's lines with folds over them, folds over trees, and trees kept in a rule's state as tables of nodes.
187 rules from 21 domains in the examples (finance, access control, public services, operations, protocols, commerce, supply chains, games, education, healthcare, energy, networking, AI agents, cloud, ad tech, governance, insurance, bookings, safety and IoT, mobility, media), each checked three ways: proven, broken by a real run, checked by Lean.
59 of 59 laws from a Bend project's policy core (jev-fabric), ported and proven automatically.
29 of 29 of IC3Syn's distributed protocols proven with nothing written, every proof checked by the kernel and again by Lean (the protocols).
Beyond the benchmarks
Real projects, real bugs.
Rules and state machines from open-source code in the languages it reads (rate limiters, quotas, ledgers, escrow, payments, sessions and OAuth, access policies, job queues, circuit breakers, feature flags, approvals), each pinned to a commit and given the laws a reviewer would ask about. At 0.32.0, where the 361 laws of 0.31 kept their verdicts (CHANGELOG):
- laws checked
- 440
- proven
- 391
- broken, each with the run that breaks it
- 39
- still open
- 10
Along the way it found real bugs in 15 open-source projects, each reported to its maintainers or already known upstream. Two were low-severity security issues, reported privately.
0.6.0 to 0.51
The climb, release by release.
| Benchmark | Then | Now |
|---|---|---|
| CHC-COMP LIA-Lin | 368 0.20 | 1,165–1,168 |
| TIP 2015 | 73 0.20 | 212–213 |
| SV-COMP termination | 47 0.22 | 246 |
| TermComp ITS, terminates | 56 0.22 | 613–614 |
| TermComp ITS, doesn’t terminate | 320 0.22 | 538–542 |
| Real-world corpus, proven of 311 | 218 0.23 | 274 |
- 0.7gdp-ts proofs minted by checks gdp-wired has proven
- 0.8Records, variants and the lemmas you state
- 0.10–0.11Lists a request carries, trees, laws over 64 steps
- 0.12Conditions at every two keys; the prover rebuilt for speed (a 64-step law, 87 s to 5.1 s)
- 0.13–0.14Statecharts, and XState machines read as charts
- 0.15–0.16Invariants nobody wrote, found; a stuck law searches for what it needs
- 0.17–0.19Cyclic proofs in the kernel and in Lean, the certificate by default; recursive datatypes as values
- 0.20–0.21The frontier corpus, 81 of 81; “there exists”, recursion that isn't structural
- 0.22A CDCL search for wide steps: 332 of 332 CHC step goals, from 43
- 0.23Runs that never end, linear arithmetic over the rationals, the real-world corpus
- 0.24k-induction, rules read from TypeScript (
gdp-wired/extract), SV-COMP read from C as C runs - 0.25–0.26The lemma search on TIP 2015; certificates in an interchange format, with checkers outside the library
- 0.27–0.28A Go front end for the extractor; nontermination closed by cases
- 0.29Sums over a map's keys (
M.sum()) and liveness under strong fairness, each proven in Lean first - 0.30IMC's query made cheap (a median 1,239 ms to 81 ms on 16 gap tasks); CHC-COMP LIA-Lin reaches the leading tools, and led them by 5 in four side-by-side batches on Modal after the release (2 vCPU); measured again on boat, each tool alone on 4 vCPUs, it is level with Golem
- 0.31Effect services read into rules; four distributed protocols proven with nothing written; a sum's cells keep their kind, proven in Lean first
- 0.32Ten of ten distributed protocols with nothing written, each checked again in Lean; Java, Kotlin and Swift;
npx gdp-wired-cli check, laws as comments in 11 languages - 0.33All ten protocols inside 60 s in every run; counts and ghost maps as certificate kinds, proven in Lean first; fixed: the TypeScript kernel could accept a false proof past 253 (Lean re-checks were never affected)
- 0.33.1Fixed: a law key named
k#could make the TypeScript kernel accept a false law (Lean re-checks were never affected) - 0.34Liveness over every key, clocks and leases between nodes, and ordered collections: price-time priority proven on a real order book
- 0.35Counts in a machine's laws, proven in Lean first, and a search that finds them: three more distributed protocols proven with nothing written
- 0.36Exceptions and loops read from code: try/except proven for every outcome, folds over lists exact for every length
- 0.37Fourteen of IC3Syn's 29 distributed protocols proven with nothing written, the first through a ghost map, each checked again by Lean
- 0.38Solidity, with re-entrancy and 256-bit arithmetic: a DAO-shaped contract broken by a re-entrant run replayed on its bytecode, its fix proven
- 0.39More real Python read as it ships, a conditional store write no longer misread; fifteen of IC3Syn's 29 protocols proven with nothing written
- 0.40Big goals decided by asking for a model first: sixteen of IC3Syn's 29 protocols at 60 s, eighteen at 300 s
- 0.41OpenZeppelin's ERC-20: the sum of balances equals totalSupply, proven on the whole contract; nineteen of IC3Syn's 29 at 300 s
- 0.41.1Fixed: names that collide with the ones the kernel makes for itself could make the TypeScript kernel accept a false law (Lean refuses six of the seven)
- 0.42Faster IMC for CHC-COMP: the full bar at 1,181 solved, none wrong
- 0.43Effect's retries and transactions (
Schedule,STM) read and proven; the CLI accounts for every law stated in the code; IC3Syn's ports checked against TLC step by step; the soundness fuzz made exact - 0.44
gdp-wired-check, the trusted kernel alone as its own checker (an npm bin, a 139 KB file, WebAssembly); Effect queues and semaphores; a faster CDCL search; 0.43’s package fixed - 0.45Security fix: names such as
constructorand__proto__were read through the JavaScript prototype, so 0.44’s TypeScript kernel andgdp-wired-checkcould accept a crafted false rule or certificate (Lean re-checks never did; upgrade); TIP proven 219–221 of 492, from 209–212; “there exists” verdicts checked by the kernel; distributed apps through the CLI - 0.46Fixed: Python’s
round(a / k)is exact only below 252, and a strict decision rechecks its cached model;check --securityproposes policies for review; database handlers over Django, SQLAlchemy, Prisma and TypeORM - 0.47Effect Schema read into typed values (
fromSchema: signed integers, booleans, choices, records,Maybe, tagged unions), exact on decoded closed values; unsupported predicates fail closed - 0.48Breaking: source translation is cross-checked against native execution by default (unchecked laws exit 2), and
fun.run()interprets terms; CI-first use: a dev dependency, plain code shipped; finite comparisons and mutation checks - 0.49All 29 of IC3Syn’s distributed protocols proven with nothing written and kernel-checked, every one checked again by Lean (67 theorems); of their broken variants, 11 refuted by a run and none proven
- 0.50Proofs at every size: 27 of IC3Syn’s source models proven in Lean for every size, not up to a bound, and Paxos the 28th in 0.50.1 (MLDR stays proven up to size 64);
gdp-wired liftturns a proof into a self-contained Lean project - 0.50.2Fixed:
gdp-wired-cli checkexited 0 on a stated law it couldn’t settle (since 0.32; it exits 2 now), and a Lean export of a law over a list’s plain values could prove it about their positions instead (since 0.34; such laws are refused) - 0.50.4Agents consult the prover while they code:
gdp-wired-agent-consult, an MCP server withprove,why_not,suggest,check_changeandstatus - 0.51Machine integers: 8 to 64 bits, signed or not, overflow that wraps, saturates or traps, and floor, truncating or Euclidean division, each checked again by Lean as its own
UIntN,IntNandBitVec - 0.5212 of the 16 real-world laws the prover couldn’t settle are now decided: liveness through ranks and fair rings, pairwise row invariants, guards on versioned rows; a refutation can repeat a request 231 times, checked in closed form rather than replayed
- 0.53Totals over maps checked by the kernel: a count or sum kept per key (a Raft vote tally, an account’s pending transfers) proven natively and checked again by Lean, settling the other four
- 0.53.1Fixed: a law over a sum written by a reset of every key could be reported broken when it held (never proven when false); every reported run now replays on the original rule
- 0.54Laws that bound an item by a running total, found and proven on their own; CometBFT’s recorded-majority law proven;
minimizeRunshrinks a breaking run until every request matters - 0.54.1Large models no longer crash the kernel before solving: shared subterms stay shared, and the real-world laws prove in a third less time
- 0.54.2Fixed: a partly initialized C or C++
consttable (T[64] = {[37] = 9}) was read as all zeros, so a false law could report as proven (0.46 through 0.54.1); such tables are now read exactly or refused. Upgrade if you check C or C++ - 0.55Totals per group proven by the kernel: a row’s charge bounded by its tag’s total, a stored message implying a positive count for its subject, each checked again by Lean
- 0.55.1A law the prover can’t settle alone is retried together with its neighbours, and the last real-world law falls: all 467 decided, none left unknown
- 0.56Opt-in C safety: write
// gdp: safetyand it proves no out-of-bounds access, signed overflow or division by zero, replays every failure under the sanitizers, and states the exact compiler, flags and headers it proved under
Two structures, one boundary
Win the boundary. Hand off the rest.
The run algebra
Every obligation the kernel builds is one inclusion over runs, made from a few moves: start, assume, read a request, take
a step. Invariants, step laws, histories, liveness, refinement and loops all reduce to it, and one Lean twin of it
(SMachine) is proven sound.
Handwired
Rules compile to GPU loop programs, through a fork of Cheng Lou's Handwired: the search that finds a breaking run, and the synthesizer that finds a missing invariant or rank for the kernel to prove.
The handoff to Lean
Past the boundary are proofs a prover would have to invent: induction nobody stated, products of unknowns. Integer
arithmetic with induction or products is undecidable, so no automatic prover proves all of them. Define the function
in Lean, prove its facts there, and the rule uses them. Going the other way, toLean and
leanProject turn every gdp-wired proof into a Lean theorem.
Why you can trust a proof
A small kernel checks everything.
Trusted
The kernel (kernel/kernel.ts) turns a rule and its laws into goals and checks a proof tree for each: case splits on linear facts, then a linear refutation at each leaf.
Untrusted
The prover that finds the trees, the builders, the runtimes and the GPU searches. If the prover is wrong, the kernel rejects the tree.
Proven
The kernel's twin in Lean 4.34.0, proven sound with the standard axioms only. The exporter sends the kernel's real trees; tampered ones compute to false.
- Every law in the examples run again on concrete runs, against what the interpreter makes of the expression that was proven.
- Random terms through every evaluator (interpreter, generated JavaScript, kernel, GPU search, Lean) against a reference.
- Every one-operator change to the kernel run against the tests; the few that survive are equivalent.
- Fuzzing: the kernel never accepts a refutation of something that has a model.
How it works · 14 min
The long version, explained.
A 14-minute walkthrough: certificates, the kernel, why no proof to write, the frontiers.
More films
More films
Prove your first rule.
The CLI reads your code where it is, in any of 11 languages. The library is plain JavaScript with types: Node 20+, Bun or a browser. The skill teaches your coding agent to write rules and laws, and an MCP server lets it consult the prover while it codes.
Your language, with a worked exampleThe guide: your first proof in seven steps
Built on
Credits
Handwired
by Cheng Lou: the circuit and GPU runtime the searches build on, through a fork.
gdp-ts
by Guillermo Rauch: Ghosts of Departed Proofs for TypeScript, where the audit path starts.
by Anicet Nougaret: the cloud computers the rest of our work runs on (the 29 protocols, their Lean checks, the benchmarks and the release gates), through supercomputer, our open-source job runner over a warm pool of boat machines.
Bend 2
by Victor Taelin: the language the laws were first written in, and the open-sourced ideas that made this possible.