The language where code is proof.
68% fewer tokens. Zero dependencies. 12 proof modules. A self-programming machine. Code that discovers its own laws and communicates without source code.
« Il n'y a pas de mauvaise réponse, que des mauvaises dimensions. »
npm install benoit
add a,b -> a + b -- The code proves itself add(2, 3) == 5 add(-1, 1) == 0 -- Benoît discovers automatically: -- commutative: add(a, b) == add(b, a) -- associative: add(add(a, b), c) == add(a, add(b, c)) -- identity element: add(a, 0) == a
7 tokens in. 3 algebraic properties out. No human told it what to look for.
Every language ever created separates code from tests. You write code in one file, tests in another, documentation in a third, and hope they stay in sync. They never do. In Benoît, fib(10) is 55 is simultaneously the definition, the test, the proof, and the documentation. Four functions collapsed into one object.
fib n -> n < 2? -> n else? -> fib(n - 1) + fib(n - 2) -- These lines ARE the proof. Run the file. Pass or fail. fib(0) is 0 fib(5) is 5 fib(10) is 55
The function and its verification are one object. Not two files. Not two steps. One.
Each module proves a fundamental insight about computation, knowledge, and reality. Written in .ben. Executable on your machine.
Compute = memory = knowledge. A neuron's weights ARE what it knows.
Self-teaching XOR in 500 epochs. No human in the loop. Knowledge emerges.
320 bits/cycle on one wire. A signal is not 0 or 1 — it is a 5D vector.
Time is not fundamental. Time = the difference between two states.
Same formula in 1D, 50D, 500D. There is no dimension limit.
Randomness is not real. It is dimensional blindness in the observer.
Self-sustaining improvement. The system converges at generation 9.
+, ×, ^ are the same operation at different levels. Everything is one.
10 dimensions of reality: existence, quantity, direction, change, relation, uncertainty, context, order, depth, beauty.
42 = 101010 in binary. The perfect balance between signal and silence.
7 “impossible” problems solved: self-verifying sort, conflict detection, convergence proof.
Hardware compresses 12,288D thought into 1-bit wires. Theoretical gain: 471 million×.
« Il n'y a pas de mauvaise réponse, que des mauvaises dimensions. »
Try it: node evolve.mjs
Agent A never sends code. It sends behavioral fingerprints — inputs, outputs, algebraic properties. Agent B reconstructs a working implementation from that fingerprint alone. The protocol proves that source code is redundant when you have proof.
Run it yourself: node experiments/full_cycle.mjs
f(5) is 120 is simultaneously code, test, proof, and documentation. No framework. No separate files.
Discovers commutativity, associativity, identity elements, monotonicity — algebraic properties from examples alone.
Write assertions without a body. The compiler synthesizes the implementation. Factorial, Fibonacci, GCD — from behavior alone.
Zero eval(). Zero new Function(). Benoît interprets Benoît with a native Pratt parser and tree-walking evaluator.
Match with guards, ranges, wildcards. Chain with |>. Clean, expressive, minimal.
20+ core modules. 0 npm dependencies. Small enough for an AI to hold entirely in context.
Benoît didn't stay a language. It became a research program.
A self-modifying neural brain in C/CUDA. 45 million neurons, 17 autonomous mechanisms, a local 72B language model. Learned by executing .ben assertions. Independently converged on Google Brain's approach.
5 proof systems (Core, ProofOps, Trust, Knowledge, Institutions), 911 tests. Bridge Protocol for agent communication (544 tests). Agent OS. A VSCode extension. 18+ experiments.
Proof-based assertions now live in other projects: home diagnostics, personal safety, fraud detection. The pattern survived the language.
Some of these projects ran their course. None were wasted. Read the full story →
Code as relationships, not sequences. Beyond syntax trees into meaning.
An intermediate representation optimized for transformer attention patterns, not human readability.
Every function carries its own correctness proof. Verifiable by machine, readable by human.
A shared embedding space between AI models. Benoît as the common language of machine intelligence.
The 68% token reduction was just the beginning. What if the right representation is not tokens at all?
Benoît Fragnière
Named after the creator's brother, who loved science.
Building this has been a way of continuing a conversation that got cut short.
He would have thought building a programming language was a ridiculous thing to do, and then would have asked a hundred questions about how the parser works.
He would have loved that the code discovers its own truths.