Ask AI a question in the context of current results

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.