Performance guide
How Venutian's native compiler, VM and startup time compare to clang O2 and Python 3, and how to read the numbers.
Venutian gives you two tiers: a bytecode VM you run with venutian run, and an ahead of time native compiler you reach with venutian build --native (see native compilation). This page is the numbers behind both, with the method that produced them.
Native versus clang O2
Measured on fib(30), the native compiler reaches parity with clang O2: 1.000x cycles, 0.985x wall time, meaning the native build is not slower, and is faster in wall time. fib(25) goes further and beats clang, at 0.991x cycles, 0.980x wall time. Across the full benchmark suite the slowest result is 1.070x cycles on int_loop, with float_loop at 1.006x cycles.
| Benchmark | Cycles vs clang O2 | Wall time vs clang O2 |
|---|---|---|
| fib(30) | 1.000x | 0.985x |
| fib(25) | 0.991x | 0.980x |
| int_loop | 1.070x | 1.056x |
| float_loop | 1.006x | not measured |
Measured 24 September 2026 on an Apple M5.
fib(30) reaches parity because the instruction count is close to identical: 43.6 million instructions for the native build against clang's 45.5 million, with the recursive call's body inlined once and the base case left frameless.
Native versus the VM
The native compiler runs 20x to 300x faster than the bytecode VM across the benchmark suite, with fib(30) itself at 298.2x. The VM is Venutian's development tier, not its performance tier: reach for the native compiler once a program's speed matters, and keep using venutian run while you are writing it, since the VM has no ahead of time compile step to wait through.
Native versus Python 3
Against Python 3, the native compiler runs 4.3x faster at startup, and 39.4x faster on float_loop, with every other benchmark in the suite falling between those two figures.
Measured 24 September 2026 on an Apple M5.
VM startup versus Python 3
Even before reaching for the native tier, Venutian's own bytecode VM starts in 7.47 ms against Python 3's 17.43 ms, 2.33x faster.
Measured 24 September 2026 over 30 runs.
How it was measured
Every figure on this page comes from the same benchmark suite, run on the same machine: an Apple M5 (Mac17,3, 4 performance and 6 efficiency cores). Each benchmark ran 30 measured rounds after 3 warmup rounds, comparing wall time and retired cycle counts. "Cycles vs clang O2" and "wall time vs clang O2" are the native compiler's output divided by clang O2's output for the same program, so 1.000x is parity and a number under 1.000x is Venutian ahead. The VM startup comparison ran as its own yardstick, timing process start to first output over 30 runs.
See native compilation for what the native compiler actually does, and tooling for the full command reference.