Benchmarks

Ten identical programs in Rux, Rust, C++, Go, C# and Java, built and run on real machines. Execution time, CPU time, peak memory, compile time and binary size, all measured by one open-source runner.

Benchmark source Methodology

Desktop · Core i9-11900KF · October 7, 2026

Rux is pre-1.0, and its backend does not optimize yet

Rux compiles through its own pipeline straight to x86-64, with no LLVM and, so far, no optimization passes and a register allocator that spills everything to the stack. Its run times are a baseline to track from release to release, not a verdict. Memory use and binary size already reflect the language design: no garbage collector, no runtime. The compiler design post explains why.

Machine

CPU: 11th Gen Intel(R) Core(TM) i9-11900KF @ 3.50GHz
Threads: 16
Memory: 64 GiB
OS: Windows 11 (build 26300)
Run: October 7, 2026
Method: standard profile · 3 clean builds · 1 warm-up + 5 measured runs

Toolchains · benchmarks commit a4370eb

Rux: Rux 0.4.0 (2026-10-07 15:15:36 UTC)
Rust: rustc 1.99.0 (b940084d7 2026-09-28)
Cargo: cargo 1.99.0 (5f94df478 2026-08-27)
C++: clang version 23.1.2 (https://github.com/llvm/llvm-project 85ac560262434c9ccfc0c183ec22d4138ed647fb)
Go: go version go1.27.1 windows/amd64
.NET SDK: 10.0.401
JDK: java version "27" 2026-09-15
GraalVM: native-image 25.0.4 2026-07-21

Summary

Each cell is the geometric mean, over all ten apps, of the language's value divided by Rux's. Rux is 1.00× by definition.

Geometric mean over all apps of each language's value divided by Rux's. Above 1.00× Rux is lower, below 1.00× Rux is higher; every metric is lower-is-better.
Rux	Rust	C++	Go	C# AOT	C# JIT	Java AOT	Java JIT
1.00×	0.11×	0.09×	0.10×	0.11×	0.12×	0.10×	0.10×
1.00×	0.11×	0.09×	0.11×	0.11×	0.12×	0.10×	0.12×
1.00×	1.12×	1.10×	1.37×	1.59×	2.38×	1.77×	4.40×
1.00×	0.69×	0.97×	0.58×	8.28×	3.53×	63×	1.09×
1.00×	0.72×	2.86×	8.31×	5.40×	0.81×	32×	0.01×
1.00×	0.72×	2.86×	8.31×	5.40×	0.84×	32×	0.01×

Above 1.00× — Rux is lower Below 1.00× — Rux is higher Every metric is lower-is-better. Select a metric to see it per app.

Results by app

Wall-clock time from process start to exit, including start-up. Median of runs; lower is better.

Rux compared with

Other languages Hollow: JIT, needs an installed runtime Hover, tap or focus the chart for values.

Execution time (s)

Relative to Rux

Execution time (s), median of runs for each app. The best value in each row is bold.
App	Rux	Rust	C++	Go	C# AOT	C# JIT	Java AOT	Java JIT
Sha512	13.313	0.495	0.467	0.658	0.684	0.809	0.625	0.699
Mandelbrot	4.260	0.915	0.904	0.886	0.916	0.937	0.924	0.978
WordCount	13.099	0.639	0.604	0.814	0.846	0.715	1.096	0.969
BinaryTrees	5.338	2.090	1.911	0.896	0.748	0.851	0.242	0.308
Sort	2.756	0.592	0.597	0.616	0.645	0.709	0.648	0.731
NBody	4.007	0.235	0.221	0.279	0.359	0.523	0.207	0.277
MatrixMultiply	12.231	0.631	0.194	0.575	0.683	0.781	0.741	0.399
PrimeSieve	2.361	0.588	0.556	0.570	0.585	0.611	0.631	0.630
Fannkuch	0.899	0.138	0.133	0.141	0.134	0.173	0.161	0.195
Base64	5.474	0.280	0.223	0.276	0.304	0.324	0.565	0.393

The programs

Each is an ordinary console program written the same way in every language. It takes its sizes as arguments, prints a deterministic result and exits; there is no timing code inside.

App	What it does	Stresses	Standard size
Sha512	SHA-512 of a pseudo-random buffer, re-hashed with the digest fed back in	64-bit integer and bit operations	16 MiB × 16 rounds
Mandelbrot	Renders the Mandelbrot set and writes it as a PPM image	Floating point, file output	2000×2000, 500 iterations
WordCount	Generates text from a random vocabulary, counts words in a hash map, prints the top 10	Strings, hashing, hash maps	10M words, 100k vocabulary
BinaryTrees	Builds and frees many complete binary trees	Allocation	depth 18
Sort	Quicksort (median of three, insertion sort below 16) of random 32-bit integers	Branches, memory access	10M integers
NBody	Five-body planetary simulation	Floating point, square root	5M steps
MatrixMultiply	Dense double-precision matrix product, i-k-j loop order	Loops, cache, vectorization	1024×1024
PrimeSieve	Sieve of Eratosthenes over a byte array, prints count and sum	Memory bandwidth	primes up to 100M
Fannkuch	Pancake flips over every permutation (fannkuch-redux)	Small arrays, branches	n = 10
Base64	Hand-written Base64 encode and decode round trip	Byte manipulation, table lookups	32 MiB × 4 rounds

Methodology

Keeping it fair

Every algorithm is written by hand, identically, in every language: same data generation, operation order and data layout. Only standard-library I/O, collections and allocation; no third-party packages, SIMD intrinsics or threads.
Inputs come from the same SplitMix64 generator; floating-point results are printed as raw IEEE-754 bits, so every language must agree bit for bit (C++ is built with -ffp-contract=off).
All builds target baseline x86-64, and runtimes run with their defaults: no GC or JIT tuning for .NET, Go or the JVM.
BinaryTrees allocates the way each language normally does: new/delete in C++, Box in Rust, the garbage collector in Go, C# and Java, and Allocator::Pool in Rux. WordCount uses each standard library's hash map.

How it is measured

Build. One untimed warm-up build, then 3 timed clean release builds with the language's usual tool (rux, cargo, clang++, go build, dotnet publish, javac + jar or native-image). Go starts from a cache holding only the precompiled standard library, so the app itself is always compiled from scratch.
Run. 1 unmeasured warm-up, then 5 measured runs, with languages taking turns so drifts in machine state hit all of them alike. Execution time includes process start-up — for the JIT builds, starting the runtime and compiling.
Validate. Every run must exit with code 0 and print exactly the expected output, or the cell is marked FAIL and left out.
The page shows medians; the chart tooltips add the minimum, standard deviation and run count.

Reading the numbers

C# and Java appear twice. AOT is one native executable (NativeAOT, GraalVM Native Image); JIT runs on an installed runtime (framework-dependent .NET, java -jar).
The JIT builds' executable and deployable sizes exclude the shared runtime they need, which is why the Java jar is a few KiB.
Peak memory is the working set on Windows and maxrss on Linux; the two are not comparable across operating systems, and neither are times across machines.
Ratios are value ÷ Rux, summarised by geometric mean so that a 2× win and a 2× loss cancel out.

The apps, the runner and full instructions to reproduce these results on your own machine are in rux-lang/Benchmarks.