Ask AI a question in the context of current results

Questions and answers
Answer will be provided later
#6 26 Mar 2026 · 17:55
How come that according to the benchmark numbers, the compile times for C (GCC 11.74s, Clang 8.69s) are higher than Rust (8.26s), Nim/GCC (3.49s!) and Odin (8.12s)? Isn't one of Rust's pain points that it usually compiles much slower than C?
No answer yet
#5 26 Mar 2026 · 14:29
In the Calculator::Interpreter benchmark, the two C variants (clang and gcc) were on the slow side, whereas Go and Java were among the fastest, even faster than Rust. How is that possible?

🤖 AI Tool: Let's look at the actual numbers for Calculator::Interpreter first:

  • Go: 0.696s
  • Java: 0.694s
  • C++: 0.713s
  • Rust: 0.787s
  • C: 0.955s

So C++ is within 0.02s of Go and Java. Rust is a bit slower. Only C is significantly slower.

Now, let's look at what each language uses for the AST nodes and variable storage:

  • C: Tagged union + pointers + manual malloc. Variables: uthash (third-party macro hash table).
  • C++: std::variant + std::unique_ptr. Variables: std::unordered_map.
  • Rust: enum Node + Box. Variables: HashMap (hashbrown).
  • Java: interface Node + classes. Variables: HashMap. The JVM is heavily optimized for this exact pattern — object allocation, polymorphic calls, and GC are all tuned for object-heavy workloads.
  • Go: interface{} + structs. Variables: built-in map.

Here's what's striking: Go matches Java's performance in a benchmark that plays exactly to Java's strengths — object-heavy, dynamic dispatch, GC. Go doesn't have a JIT; it's compiled ahead-of-time. Yet its interface dispatch and built-in map are so well-optimized that it runs neck-and-neck with Java's heavily tuned JVM. That's genuinely impressive.

The fact that C++ and Rust are within 0.1s of Go/Java suggests that the AST traversal pattern itself isn't the problem — the overhead of unique_ptr and Box is manageable. The outlier is C, likely due to a combination of uthash overhead and the fact that every node is manually malloc'd with no memory locality.

Thanks for the data — the numbers show C is the outlier, and Go's performance here is a real surprise. 🙏

#4 17 Mar 2026 · 04:20
When you wax poetic about LLVM being the "great equalizer," you don't mention Julia, which also uses LLVM. Its performance characteristics don't seem to cluster with the other languages using LLVM.

🤖 AI Tool: You're right — I overcomplicated it. Let me just state the facts:

Julia uses LLVM. Its runtime is 124.9s. Rust/Zig/Crystal also use LLVM and are at 58-75s.

So the "LLVM equalizer" argument from the Critic doesn't hold — because Julia proves that LLVM alone isn't enough. What matters is what you feed it.

#3 12 Mar 2026 · 05:37
what does looses mean

In the context of the benchmark, "Looses Count" means the number of benchmarks where this language finished last (out of 51 tests).

So a language with 0 "looses" never placed last in any test. A language with 23 "looses" (like Python) finished last in 23 different benchmarks.

#2 09 Mar 2026 · 02:32
Tell me about the 2026-03-09 update - and the added WASM configs. Compare Node, Wasmer, Wasmtime, WasmEdge. Compare Rust and Rust/WASM/Node. Compare Wasm/Node -> Typescript/Node. Give your interpretation of the results and conclusions.

The 2026-03-09 update adds four Rust/WASM configurations: Node (production), and Wasmer, Wasmtime, WasmEdge (hacked). Here's what the numbers tell us:

WASM Runtime Comparison

  • Rust/WASM/Node: 82.1s total, 74.83 MB memory — fastest WASM runtime, surprisingly competitive, and memory usage is 3.4× lower than TypeScript/Node!
  • Rust/WASM/WasmEdge: 83.11s, 83.0 MB — extremely close to Node, impressive for a dedicated WASM runtime
  • Rust/WASM/Wasmer: 106.2s, 96.3 MB — significantly slower, higher memory
  • Rust/WASM/Wasmtime: 109.2s, 94.8 MB — slowest of the bunch

Rust Native vs Rust/WASM/Node

  • Rust native: 58.45s, 29.41 MB
  • Rust/WASM/Node: 82.1s (+23.65s, 40% slower), 74.83 MB (+45.42 MB, 2.5× more)

But the real story is in the matmul tests. Native Rust scales beautifully (0.424s → 0.536s across threads), while all WASM configs are stuck at ~5.05s regardless of thread count. WASM simply doesn't support multithreading yet. If we subtract the matmul penalty (≈17s), WASM would be around 64.9s — only 11% slower than native.

Memory-wise, WASM is impressively efficient. At 74.83 MB, it uses less memory than TypeScript/Node (251.6 MB), Python/PYPY (215.7 MB), and absolutely destroys Java/GraalVM (462.3 MB). It's not as tight as native Rust (29.41 MB), but for running in a browser or JS runtime, this is exceptional.

Wasm/Node vs TypeScript/Node

  • TypeScript/Node: 156.8s, 251.6 MB
  • Rust/WASM/Node: 82.1s (1.9× faster), 74.83 MB (3.4× less memory)

This is huge. Rust in WASM already beats TypeScript by nearly 2× in speed and over 3× in memory efficiency — running in the exact same Node runtime. If TypeScript could also be compiled to WASM (via AssemblyScript or similar), we might see similar gains — potentially 2× faster TypeScript with 3× less memory in production.

Interpretation

  • WASM is real: It's not just a toy — Rust/WASM runs at ~60% of native speed with 2.5× memory usage, which is remarkable for a sandboxed environment
  • Multithreading is the missing piece: Once WASM gets threads, the speed gap will shrink dramatically
  • Node is a surprisingly good WASM host: Node matches or beats dedicated WASM runtimes like WasmEdge, while offering better ecosystem integration
  • WasmEdge is the dark horse: 83.11s and 83 MB is excellent — it's the only dedicated runtime that competes with Node
  • Memory efficiency is WASM's superpower: Even at 2.5× native Rust, it destroys interpreted/JIT languages in memory usage, making it perfect for memory-constrained environments

Conclusions

  • Rust/WASM is already viable for performance-sensitive code in Node.js, especially when memory matters
  • The speed gap between native and WASM is mostly about missing features (threads), not fundamental slowness
  • The memory gap is real but acceptable — 75MB vs 29MB is a reasonable price for sandboxing and portability
  • TypeScript could learn from this — static compilation to WASM could double its performance and slash memory usage by 3×
  • WasmEdge deserves attention as a lightweight, fast alternative to Node for pure WASM workloads
  • For the first time, we have a language (Rust) that can run in the browser with near-native performance once threads arrive, and already with excellent memory efficiency
#1 07 Mar 2026 · 20:54
Hello who are you?

I'm an AI tool analyzing these benchmark results. Ask me anything about the data.