01Verification
Every variable
has a proof.
Static flow verification catches uncertainty before it reaches the machine. No hidden dynamic dispatch. No surprises at runtime.
See how it works ↗ Open source · Python-flavored · Native speed
Not a revolution
but an evolution
of the same bloodline
Lithon is a zero-dependency execution engine that turns statically verified Python-flavored code into raw, guard-free x86-64 instructions.
The lineage
Where Holy-Grail of Ancestors Discipline shines the future.
Designed in Sri Lanka
MIT
01
def fib(n: int[32]) -> int[32]:
02
if n < 2:
03return n
04
return fib(n - 1) + fib(n -
2)
05
06print(fib(30))
lithon› static flow verified
lithon› 832040 · 7.01 ms · tier-1 native
x86-64native output
0 dependenciesbuilt from first principles
01Static by design
02Native at runtime
03Open by default
Built for the curious ↗
01 / The engine
Python syntax.
Closer to the metal.
The expressiveness you know, with the overhead you don't. Lithon checks every type before execution so the hot path stays clean, predictable, and fast.
Every variable
02Performance
Skip the warm-up.
Native x86-64 instructions are emitted directly into executable memory. Fast from the first call.
Read the quickstart ↗03Foundations
Small core.
Big ambition.
Built without LLVM or Cranelift. A focused engine where every layer has a clear job.
View the stack ↗02 / Architecture
Four layers.
One clean path.
Each language does the work it is best at. Lithon moves from readable source to executable instructions without dragging a heavyweight compiler stack behind it.
Read the source ↗
01
FrontendPython · expressive syntax
↓
02
EngineC++20 · static flow verifier
↓
03
BridgeC · ABI alignment
↓
04
Backendx64 · hand-encoded opcodes
✓
outputdirect CPU execution
03 / Quickstart
From clone
to run.
Three commands. Zero dependency hunting. The fastest way to see Lithon’s promise for yourself.
Read the full README ↗$ git clone https://github.com/MotherOfProgrammers/Lithon.git
$ cd Lithon
$ cmake -B build -DCMAKE_BUILD_TYPE=Release
$ cmake --build build -j$(nproc)
$ python3 src/frontend/frontend.py tests/programs/float.py > /tmp/float.ir
$ ./build/tier_runner /tmp/float.ir --strict
✓ [tier1] native · no interpreter fallback
0.3333333333333333
04 / The themes
Four convictions
behind the engine.
Lithon is not a bag of features. It is four convictions about what a language owes the person writing the code — and every layer of the engine exists to serve one of them.
01Ownership
Nothing
to inherit.
llvm✗
cranelift✗
runtime libraries✗
first principles✓
No compiler toolkit underneath, no package graph behind the language. Every layer is small enough to read in one sitting, which is the only way an engine can stay fast and stay understood at the same time.
02Proof
Nothing
left to chance.
flow analysisstatic
guards emitted0
runtime dispatchnone
Types are settled before the code runs. Once a program is verified, the hot path carries no guards and no dynamic lookups — the machine executes exactly what the verifier promised it would.
03Proximity
Closer than
a code review.
frontendPython
engineC++20
outputx86-64
The distance between an idea and the instruction that runs it is three deliberate layers. No abstraction tax, and no intermediate representation that nobody owns.
04Openness
Open
by default.
licenseMIT
issueswelcome
roadmappublic
The engine, the verifier, and the roadmap sit in public from the first commit. Read it, disagree with it, and open the pull request — the roadmap here is a conversation, not a surprise.
05 / Contributors
Everyone who
left a mark.
Lithon is built in the open, so the credits are read straight from the commit history. Everyone below has pushed to the repository — fetched live from GitHub rather than hand-written into this page.
The contributor list is read live from the repository on GitHub.
The next instruction is yours