How Does Kit Stack Up, Revisited?

Back to Blog

Back in January we benchmarked Kit against Go, Rust, Zig, V, Crystal, Nim, Node.js, Python, and Ruby, and Kit came out looking very good. That was nearly six months ago—172 days, to be exact—and a lot has happened since. At the time, Kit didn't even have a tagged release yet. Today, 140 tagged releases later (from the first, 2026.3.7, through the current 2026.7.8), the compiler, the runtime, and the benchmark suite itself have all changed. So we ran everything again.

Goodbye, Mac Mini

The biggest change isn't in the software at all. The original benchmarks ran on a trusty 2018-era Intel Mac mini—a Core i7-8700B with 6 cores and 64 GB of RAM. It served well, but it has been retired in favor of a considerably more modern machine: a Corsair AI Workstation 300 built around AMD's Ryzen AI Max+ 395, with 16 cores / 32 threads boosting past 5 GHz, 128 GB of LPDDR5X RAM, and Ubuntu 24.04 instead of macOS.

That means the absolute numbers below are not directly comparable to January's. Everything got faster—a seven-year CPU generation gap will do that. What is worth comparing is how the languages rank against each other, and there the story has some genuine surprises.

The methodology has tightened up too. All timings now come from hyperfine, and on Linux the run scripts pin benchmark processes to a fixed set of physical cores (taskset -c 2-5) so scheduler placement doesn't skew run-to-run results. Toolchains are current as of this post: Kit 2026.7.8, Zig 0.16.0, Go 1.26.4, Rust 1.96.1, Node.js 26.4.0, Crystal 1.20.3, Nim 2.2.10, V 0.5.1, Python 3.14.6, and Ruby 4.0.5.

Fibonacci Recursion

Same test as January: a naive recursive fib(45), stressing function call overhead and recursion performance.

The Results

Language	Mean Time	vs Fastest
Nim	0.893s	1.00x (fastest)
V	1.097s	1.23x slower
Kit	1.946s	2.18x slower
Rust	2.088s	2.34x slower
Zig	2.097s	2.35x slower
Crystal	3.237s	3.62x slower
Go	3.469s	3.88x slower
Node.js	6.722s	7.53x slower
Ruby	52.460s	58.75x slower
Python	53.432s	59.84x slower

Kit's absolute time dropped from 3.85s to 1.95s—but so did everyone's; that's the hardware, not the compiler. The interesting change is the leaderboard: Nim, which was 4.4x slower than Kit on the Mac mini, is now the fastest language in the field, with V close behind. Kit slipped from first to third, though it still edges out Rust, Zig, and Go. Honest takeaway: Kit remains firmly in the systems-language pack on recursive workloads, but the January "fastest overall" crown is gone—newer Nim and V toolchains on this CPU clearly hit an optimization sweet spot.

Pi Calculation

The Leibniz series pi calculation is back, with one important change: the workload was reduced from 100 million iterations to 10,000, which moves the timings from seconds into microseconds. That makes this round not comparable to January's pi numbers, and at these durations process startup noise is a real factor. Treat it as a short-loop-plus-startup test rather than a sustained floating-point test.

The Results

Language	Mean Time	vs Fastest
Zig	131.3µs	1.00x (fastest)
V	175.3µs	1.34x slower
Nim	177.5µs	1.35x slower
Rust	246.0µs	1.87x slower
Kit	331.1µs	2.52x slower
Go	369.9µs	2.82x slower
Crystal	464.0µs	3.53x slower
Python	5.881ms	44.79x slower
Node.js	13.450ms	102.43x slower
Ruby	25.025ms	190.58x slower

Zig takes the top spot, with Kit landing mid-pack among the compiled languages at 2.52x. Kit's tail-recursive loop still compiles down to a native loop—no list allocation, no stack growth—but at the microsecond scale, binary startup overhead separates the field more than raw arithmetic does. Notably, V, Nim, and Crystal, which trailed badly in January's long-running version of this test, are now competitive.

New: Ray Tracer

The benchmark suite has grown since January. The first addition is a deterministic ray tracer that renders a 120×80 sphere scene and prints a checksum of the gamma-corrected pixels. It exercises floating-point vector math, records/structs, branch-heavy intersection code, recursive reflection rays, and nested image traversal—much closer to real-world numeric code than fib or pi.

The Results

Language	Mean Time	vs Fastest
Zig	633.5µs	1.00x (fastest)
V	684.0µs	1.08x slower
Rust	788.4µs	1.24x slower
Crystal	975.4µs	1.54x slower
Nim	988.0µs	1.56x slower
Go	1.183ms	1.87x slower
Kit	12.950ms	20.44x slower
Node.js	23.468ms	37.05x slower
Python	64.111ms	101.20x slower
Ruby	93.375ms	147.40x slower

No sugarcoating this one: at 20x slower than Zig, the ray tracer is Kit's weakest result and its clearest optimization target. Kit still beats every JIT-compiled and interpreted language handily, but the gap to the systems-language pack comes from record-heavy code paths that don't yet stay out of the allocator the way the vec3 benchmark below does. This is exactly the kind of workload the record monomorphization work is chasing, and we expect this number to fall in future releases.

New: Vec3 Record Loop

Which brings us to the second addition: a 100-million-iteration tail-recursive loop that carries a Vec3 record ({x, y, z: Float}) through add/scale/dot helper functions, Kit vs Zig head-to-head. This stresses record monomorphization. As of Kit 2026.7.8, all-primitive-field records pass through monomorphized functions as native structs in registers—instead of heap-allocating on every helper call.

The Results

Language	Mean Time	vs Fastest
Kit	128.1ms	1.00x (fastest)
Zig	132.5ms	1.03x slower

Kit actually edges out Zig here—300 million helper calls passing records with zero heap allocations. When the unboxing optimization applies, Kit's functional record code runs at native struct speed. The ray tracer above shows what happens on paths where it doesn't yet apply; this benchmark shows where it's headed.

New: FFI

The final addition calls C's sqrt() 100 million times, accumulating the result, to measure foreign function interface overhead—Kit vs Zig, Go, and Rust.

The Results

Language	Mean Time	vs Fastest
Rust	39.7ms	1.00x (fastest)
Zig	39.8ms	1.00x
Go	1.807s	45.49x slower
Kit	1.976s	49.74x slower

An asterisk on this one: Zig and Rust recognize the libc sqrt call and lower it to a native instruction, so they're measuring effectively zero per-call overhead rather than a real FFI boundary. Go (via cgo) and Kit both pay a genuine boundary cost on every call, and Kit lands right alongside Go— about 18–20 nanoseconds per foreign call. Reasonable company to keep, with room to improve.

Try It Yourself

Want to run these benchmarks on your own hardware? Clone the repository and give it a spin:

jj git clone https://gitlab.com/kit-lang/kit-benchmarks.git
cd kit-benchmarks
./install.sh
./run-benchmarks.sh

We'd love to hear your results, especially on different hardware configurations. Share them with us on @KitLangOrg or @Kit_Lang, or open an issue in the repository.

Updated July 10, 2026: an earlier version of this post said Kit "roughly doubled its fib(45) speed since January" and credited compiler work. As a reader pointed out, every language sped up by a similar or larger factor on the new machine, so the improvement is attributable to the hardware, not the compiler. The wording has been corrected; the tables and rankings are unchanged.