Analyzing the Performance of WebAssembly vs. Native Code
25 comments
·November 4, 2025b_e_n_t_o_n
wmf
wasm outside the browser for compile-once-run-anywhere usecases with sandboxing / security guarantees
Please just use Docker in a microVM or whatever. It's 0% slower and 100% more mature.
rowanG077
Setting up docker and a microVM is orders and orders of magnitude harder and less ergonomic then using your browser. These are not at all interchangeable.
rlili
That it’s not even an order of magnitude slower sounds actually pretty good!
gnabgib
(2019) Popular in:
2019 (250 points, 172 comments) https://news.ycombinator.com/item?id=20458173
2020 (174 points, 205 comments) https://news.ycombinator.com/item?id=19023413
icsa
45% slower to run everywhere from a single binary...
I'll take that deal any day!
andyferris
45% slower to run everywhere from a single binary... with less security holes, without undefined behavior, and trivial to completely sandbox.
Its definitely a good deal!
ben-schaaf
Native code generally doesn't have undefined behaviour. C has undefined behaviour and that's a problem regardless of whether you're compiling to native or wasm.
pron
> without undefined behavior
Undefined behaviour is defined with respect to the source language, not the execution engine. It means that the language specification does not assign meaning to certain source programs. Machine code (generally) doesn't have undefined behaviour, while a C program could, regardless of what it runs on.
gishh
That which is old is new again. The wheel keeps turning…
“Wait we can use Java to run anywhere? It’s slow but that’s ok! Let’s ride!”
ori_b
Is compiling so hard?
PantaloonFlames
45% slower means..?
Suppose native code takes 2 units of time to execute.
“45% slower” is???
Would it be 45% _more time?_
What would “45% _faster_” mean?
tharakam
I guess it is clearer if expressed like "Native application took only x% of WASM equivalent".
azakai
0% slower means "the same speed." The same amount of seconds.
10% slower means "takes 10% longer." 10% more seconds.
So 45% slower than 2 seconds is 1.45 * 2 = 2.9 seconds.
oersted
It’s a fair point, that way of expressing it is always a bit confusing. Is it the original time plus 45%? Is it 45% of the original speed?
I think it is easier to understand in terms of throughput.
So 45% less work per unit of time, so 55% of the work.
huflungdung
[dead]
azakai
The data here is interesting, but bear in mind it is from 2019, and a lot has improved since.
vlovich123
This is pretty good actually considering the low hanging optimizer optimizations left and that the alternative is JS which generally performs 2-10x slower.
I think vectorization support will narrow the aggregate difference here as a lot of SPEC benefits from auto vectorization if I recall correctly.
turbolent
... in browsers. Which at best JIT compile. There are several WASM runtimes that AOT compile and have significantly better performance (e.g. ~5-10% slower).
The title is highly misleading.
astafrig
It’s not misleading to measure the performance of WebAssembly in a web browser.
pyrolistical
Just means the browsers can catch up.
Initially slower but then faster after full compilation
padenot
Browsers have been doing (sometimes tiered) AOT compilation since wasm inception.
chalcolithic
could you please name them?
fanf2
(2019)
ModernMech
Yeah, I've seen this when test Rust code compiled into native and wasm. I don't know about 45% though, I haven't measured it.
45% slower seems pretty decent considering they use a wasm kernel they developed to mimic the unix kernel so they can run non-modified unix programs inside the browser. It's actually pretty impressive that they did this, and even more impressive that it works and like another commentator said, is not even an order of magnitude slower.
I'm more interested in 1) usages of wasm in the browser that don't involve running unmodified unix programs and 2) wasm outside the browser for compile-once-run-anywhere usecases with sandboxing / security guarantees. Could it be the future for writing native applications?
Languages like Kotlin, C#, Rust, as well as C/C++ etc support wasm quite well. Could we see that be a legitimate target for applications in the future, if the performance gap was closer to 10%-ish? I would personally prefer running wasm binaries with guaranteed (as much as possible ofc) sandboxing compared to raw binaries.
edit: it's from 2019, there have been significant improvements made to wasm since then.