Benchmarks

bench/ has the same programs written in C, C++, Rust, Zig and Volt, each in the way that language’s programmers would usually write it: Rust and Zig with their standard libraries only (safe Rust, no crates). Every program prints the same output in each language:

The Rust and Zig programs use what those languages’ standard libraries give, which isn’t always the same work as the C. Worth knowing when reading their columns:

• Hash maps: Rust’s HashMap hashes with SipHash, which resists flooding and is slower than the multiply-and-shift or FNV hashes the C tables use; Zig’s maps use Wyhash. That shows in hashmap, knucleotide, wordfreq and lru_cache, and it’s the hash, not the language.
• Allocation: Rust’s Box and Vec go through glibc’s malloc, as C does; the Zig programs allocate through Zig’s general-purpose allocator. In lru_cache the Rust and Zig versions reuse an evicted node’s slot where C frees it and allocates a new one.
• Bounds checks: safe Rust checks every index (as Volt’s release builds do, where the check can fail); C and Zig’s ReleaseFast don’t. vm_interp is where it costs most.
• Library routines: sort is each standard library’s own sort (slice::sort, std.mem.sort), and print is Rust’s own shortest-float formatting, where C’s tries %.*g at each precision.
• Target CPU: Zig builds for the machine it runs on; clang, gcc, rustc and voltc build for any x86-64.

cargo test --release --test bench -- --ignored --nocapture

The harness builds each program eight ways. C is built with clang -O2 and with gcc -O2, C++ with clang++ -O2 -std=c++20, Rust with rustc --edition 2024 -C opt-level=3, and Zig with zig build-exe -O ReleaseFast (which builds for the host CPU, Zig’s default). Zig is found on PATH or in ~/.local/bin; without it the Zig column shows “—”. Volt is built with --release through both of voltc’s backends: C, compiled by clang and by gcc, and LLVM. Each build runs best of three, and every build has to print the same output. BENCH_ONLY=nbody,sort runs only some of the programs, and BENCH_RUNS=5 takes the best of five. BENCH_MAX_RATIO=1.25 fails when a Volt build takes more than 1.25 times as long as C (clang). A full run rewrites the table below.

To see where one of them spends its time, run it under bolt hot: bolt hot bench/binary_trees/main.volt -- 18.

A full run writes what follows: the machine and toolchain it ran on, then the times. Each time is the best of the runs, and each one after C (clang) also shows its ratio to it (below 1.00x is faster); “—” marks a compiler that wasn’t installed. Times move a few percent between runs; differences that small are noise.

Measured 2026-10-09 on:

• CPU: AMD Ryzen 7 9800X3D 8-Core Processor (8 cores, 16 threads, powersave frequency governor)
• Memory: 60 GiB
• OS: Arch Linux, kernel 7.2.8-hardened1-2-hardened
• C and C++: clang version 23.1.1; gcc (GCC) 16.2.1 20260810
• Rust: rustc 1.99.0 (b940084d7 2026-09-28)
• Zig: zig 0.17.0
• Volt: voltc –release; its LLVM backend on LLVM 23.1.1
• Timing: best of 3 runs, wall clock

• Against Rust and Zig: over the 39 programs Volt’s LLVM build takes 0.88x Rust’s time and 0.89x Zig’s (geometric means; against C: Volt 0.81x, Rust 0.92x, Zig 0.91x). It’s ahead on 24 programs against Rust and 21 against Zig, mostly from its allocator (binary_trees, lru_cache), its library (sort’s radix sort, json) and its hash maps against Rust’s SipHash (knucleotide, wordfreq). Zig is ahead by more than 10% on nbody, strings, csv, print, wordfreq, life, revcomp and raytrace (it also builds for this CPU, see above), and Rust on dijkstra, nbody and sudoku; their other leads are smaller.

• Many rows are a tie. Volt compiles to the same machine code as C for the same loops: the C backend hands clang C that does what the C program does, and the LLVM backend emits the same IR clang would.

• Release builds check bounds. Indexing and slicing stay checked in --release, as one compare and a trap instruction (safety). Most rows don’t notice: the compiler drops a check it can prove, and a loop over 0..xs.len proves its own. The rows that index with values only known at run time pay: vm_interp (its stack pointer, local slots and program counter) is 1.05x where it was 0.62x unchecked, and lz77 1.13x. @attributes([@unchecked]) on vm_interp’s run gives the unchecked time back (0.49 s). dijkstra paid 1.16x until std’s heap stopped checking the indices its sift loops can’t get wrong; it’s 0.95x now. The gcc column paid more on bigint (3.46x): an if value was a branch per arm storing its result, and gcc’s jump threading copied the checked store in rs[i] = if (over) x - BASE else x into both arms of the branch on the carry, so the branch stayed and mispredicted where clang made it a conditional move. An if value whose arms are plain values is C’s ?: now, and if (c) 1 else 0 is c as a number, so gcc makes the conditional move too: 0.82 s, then 0.63 s (1.43x of gcc’s C, 0.44 s) once the program adds its limbs in the C’s order and resize’s fill became a memset.

• sort: a radix sort for integers. slice.sort sorts integers of 256 or more elements by their bytes (it’s stable, and integers have no order but their bits), in a few passes over the data, with no comparisons at all. std::stable_sort is a merge sort with the comparison inlined; C’s qsort calls a function through a pointer for every comparison.

• vm_interp: a match on an enum is a jump table. A match whose arms test whole variants (no guards, no payload patterns) becomes a switch on the tag, and since the arms cover every tag it needs no default: LLVM copies the dispatch into the end of each arm, so each instruction jumps straight to the next one’s code. C’s switch keeps a range check and one shared dispatch; std::visit gets the same copied dispatch. Unchecked, Volt’s is 0.62x and ahead of it; with the bounds checks above it’s 1.05x.

• vec_grow: Volt values move by copying bytes, so std::vec grows with realloc, which can extend a buffer in place, as the hand-written C does. std::vector can’t: it allocates a new buffer and moves each element across.

• hashmap: C++’s std::unordered_map allocates a node per entry; std::map in Volt and the C table don’t.

• sieve: vec.resize(n, 1) fills with one plain loop, which clang turns into the same memset the C program calls. (Filling with push was 14% slower: each push stores the length back, and a byte store may alias it, so the loop can’t be turned into a memset.)

• binary_trees: free lists beat malloc. In a --release build std’s default allocator takes small blocks from per-thread free lists (allocators), so a box costs a load and a store, and a box<node>? is a pointer, so a node is 16 bytes like C’s. The C and C++ programs call malloc and new for every node (before the free lists, Volt was 1.14x to 1.18x). A C program with its own pool would match it: this row measures the allocators, not the compilers. The arena idiom (a std::mem::arena per tree, node::new(value, arena.allocator()), reset() after each) measured 0.85x on the C backend and 0.83x on LLVM: a box from an arena carries the arena’s pointer, so each node is twice the size or more, and the free lists win.

• print: floats are printed by Ryu, in Volt. libc has no shortest-round-trip float printing, so C tries %.*g with more digits until strtod reads the value back. C++’s std::to_chars does what Volt does; Volt is ahead on the writing. A println takes stdout’s lock once for the whole statement and puts its pieces into stdio’s buffer with fwrite_unlocked, with no format string to parse, where C++ makes a printf call per line. It is still stdio’s buffer, so a C library’s printf output stays in order with Volt’s.

• gcc’s own wins are its optimizer’s, and the Volt (C, gcc) column shows how much of them Volt’s C output gets. fib: gcc turns much of the recursion into loops, for Volt’s C as for the C program. spectral_norm: gcc vectorizes the inner loops at -O2, doing the divisions two at a time while keeping the sum in order (clang only vectorizes a float sum it may reorder); Volt’s C doesn’t get that yet (0.97x, where gcc’s C is 0.66x), though its a(i, j) does its math in i32 as the C does (in usize, the unsigned 64-bit to f64 conversion has no SSE2 vector form). bigint’s gcc win isn’t Volt’s yet: Volt’s C through clang matches gcc’s C, so what’s left is gcc on Volt’s loops (the range loops’ exit test hides from gcc that the index is in bounds), and the zeros resize writes that the C’s realloc doesn’t.

• Where Volt still trails: vm_interp and lz77 pay for their bounds checks (above). lz77 and wordfreq also append to a std::string with a capacity check per call, where the C checks once per word and then writes without checks, and wordfreq’s sort_by (a stable merge sort) is a little slower than qsort on its 24-byte rows. Through LLVM, revcomp (1.21x), fft (1.12x) and life (1.11x) trail too.