Matches C, cycle for cycle.

Three lanes race on fib(30): Venutian's native compiler, clang -O2 and Python 3. Native and C cross the line together, exactly level at 1.000x cycles. Python arrives after both, 22.9x slower in wall time.

fib(30)

Venutian native

C, clang -O2

Python 3

Full benchmark suite, round 2, 24 September 2026, one Apple M5 Mac

fib(30)
Lane	Measured
Venutian native	0.985x wall
C, clang -O2	1.000x wall (baseline)
Python 3	22.9x slower

The native tier, measured

Native time against clang -O2 on the full benchmark suite, 1.000x meaning parity.

Native time relative to clang -O2, where 1.000x is parity.
Benchmark	Cycles	Wall
fib25	0.991x	0.980x
fib30	1.000x	0.985x
int_loop	1.070x	1.056x
float_loop	1.006x	not recorded

fib(30) lands at 1.000x cycles and 0.985x wall against clang -O2, cycle for cycle parity and faster in wall time. The widest gap on the table, int_loop, is 1.070x, seven percent over clang in cycles. Every benchmark in the suite lands inside that margin.

Against the Venutian bytecode VM, the native tier runs 20x to 300x faster depending on the workload, 298.2x on fib(30) specifically. Against Python 3, the native tier runs 4.3x faster at startup to 39.4x faster on float_loop, and 22.9x faster on fib(30).

Why fib(30) reaches parity

Two decisions in the native compiler do it. The recursive body of fib is inlined once, so the compiled code does not pay a call and return for every recursive step. The base case is kept frameless, no stack frame is built for the branch that just returns. The result is fewer instructions than clang's own output: 43.6 million instructions against clang's 45.5 million, on the same round. Fewer instructions executed is why the native compiler matches C.

Venutian native 43.6 million

clang -O2 45.5 million

Two tiers, one language

The VM: instant start

No compile step, no native build. 7.47 ms vs 17.43 ms, 2.33x faster to first output against Python 3.

venutian run examples/hello.ven

The native tier: C speed

20x to 300x faster (fib30: 298.2x) against the bytecode VM, within 7 percent of clang -O2 on every measured benchmark.

venutian build --native examples/hello.ven

venutian run starts the bytecode VM: no compile step, no native build, the tier for a script, a REPL session, or a quick check.

venutian build --native compiles ahead of time to the native tier, the tier for code that has to run fast: a hot loop, a recursive algorithm, a long batch.

One language, two tiers, and the choice is a command line flag, not a rewrite.

How it was measured

Every number on this page comes from one full benchmark suite run on 24 September 2026 on one Apple M5 Mac (Mac17,3, 4 performance and 6 efficiency cores). Each benchmark runs 30 measured rounds after 3 warmup rounds. The VM startup figure against Python 3 comes from a separate startup benchmark, also n = 30, also 24 September 2026. The full method, the benchmark scripts and the raw rounds are in the performance guide.

Next chapter The compiler