Benchmarks

How fast is Zeno?

Six programs, written once in Zeno, C, Rust and Python, doing the same steps. Every time was measured, and counts only if the program printed exactly what C printed.

0.89× the time of Czeno build --fast, across all six programs (geometric mean)
1.8× faster than Con many small objects, where its pool beats malloc
16.8× faster than beforeon the same objects, since the paged collector and owned memory
31× faster than Pythoncompiled Zeno, on average

Before and after

Drag to compare. Before is the first run, when the collector kept every block in one table that it sorted on each collection. Now it keeps them in pages, and a program can choose memory owned instead (decision 22.5).

The program in other languages

New in 0.5: zeno build --target writes a program in another language. Here each one is run with that language's own tools, at the small sizes, so the times include starting Node, the JVM or .NET. Every cell is a time divided by the time of the same program in C. Smaller is faster. From the record of 0.5.1.

AverageFunction callsA tight loopSorting a listBuilding textMany small objectsFloating point
--target javabuilt by javac17× Con average37× C16× C11× C9× C5× C79× C
--target jsin Node23× Con average28× C45× C10× C6× C10× C180× C
--target cppbuilt by g++ -O232× Con average46× C19× C14× C18× C21× C215× C
--target gobuilt by go35× Con average49× C55× C17× C10× C16× C231× C
--target rustbuilt by rustc -O43× Con average83× C65× C19× C12× C23× C220× C
--target wasmin Node58× Con average117× C98× C29× C14× C24× C352× C
zeno run --vm69× Con average141× C88× C34× C18× C45× C313× C
--target csbuilt by dotnet78× Con average175× C116× C40× C19× C30× C472× C
--target phpin PHP152× Con average390× C261× C89× C12× C90× C1267× C
--target pyin Python 3281× Con average594× C595× C189× C17× C172× C2478× C

A written program carries Zeno's rules with it, so it does what zeno run does, checks and all, in a language that was not built for them. zeno run --vm is in the table as a guide. The targets are for reading, keeping and running a program where Zeno is not; for speed, zeno build --fast is the way.

Version by version

Each release keeps a record of its times, made with bench/record.py. Every cell is a time divided by the time of C (or of Python, for the ways that interpret) in the same run, so records made on different days still line up. Smaller is faster.

Five ways to run a program

The same file, run five ways. Each step down does more work before the program starts, and less while it runs.

  1. zeno runWalks the syntax tree

    Every step looks at a node of the tree and decides what it means. Simple, exact errors, and slow.

  2. zeno run --vmRuns bytecode

    The tree is turned into a flat list of small instructions once, then a loop runs them. Two to three times faster.

  3. zeno buildCompiles to C

    The program becomes C and then machine code. Each value is found by a garbage collector, and each + checks for overflow.

  4. --release --ownedNo collector, no overflow checks

    Each value has one owner and is freed at a line you can point to, from a pool that hands out a block in a few instructions.

  5. --fast --ownedNo checks a correct program never fails

    No index checks either, a float divided by zero is infinity, and the C compiler tries its hardest. As fast as C, and as unforgiving.

What the numbers say

Owned memory matches C and RustOn programs that make many objects it is faster: its pool hands out and takes back a block in a few instructions, where C calls malloc and free.
Checks cost a littleMost of the gap on arithmetic is the overflow check on every +, which --release drops, as Rust's release builds do. Index checks stay.
A collector costs moreIt has to look at what is still in use, again and again: about two times C on many small objects. That is why a program can choose.
--fast runs the instructions C runsIt tells the C compiler what a C program tells it: a whole number does not overflow. On the loop of whole numbers it runs 300.27 million instructions where C runs 300.26 million (decision 23.6).
Where Rust leads, and whyOn nbody, Rust's compiler knows there are exactly five bodies and builds the loop for five. With the number hidden from it, Rust is behind both C and Zeno. Zeno does not chase a benchmark (decision 23.4).
Text and floats are level with Cfor ch in text walks the text without making a list of it, and a field a function never writes is read once, as a C programmer would by hand (decisions 22.7 and 22.8).

Choose once, in zeno.package, with memory owned, or for one build with zeno build --owned. See Choosing how memory is freed.

How it was measured

Wall-clock time of the whole program, best of three. Compiled programs at full size, interpreted ones at a tenth of it. Intel(R) Xeon(R) Processor @ 2.10GHz, 4 cores, Linux, on 2026-11-16. zeno 0.4.0, cc 13.3.0 with -O2, rustc 1.97.0 with -C opt-level=3, Python 3.13.18.

The programs and the script are in bench/. The numbers on this page are in data.json.

Terminal
cargo build --release
python3 bench/run.py --size big --engines c,rust,zeno,zeno-release,zeno-owned