Ask AI a question in the context of current results

🤖 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.

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.

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

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