WebAssembly Adoption: Is Slow and Steady Winning the Race?
Where are we at with WebAssembly adoption? Eighteen months ago, The New Stack published an article asking what was holding Wasm back; just last month, 51% of respondents to a poll by The New Stack said they still have no personal experience using WebAssembly. Two months ago, another of our polls found that while 23% have used WebAssembly at work, 42% said that although they don’t use WebAssembly, they plan to when it matures.
For something that has been around for seven years — a substantial period of time in the context of the software industry — it’s strange that so many people are still waiting to begin using it.
So, what’s going on? Is WebAssembly caught in a state of arrested development, condemned to a perpetual adolescence? Or is it just a question of expectations and perspective, symptomatic of the way we’ve all been taught the standard hype cycle process.
The Current State of Play in WebAssembly
“Adoption is slim but still on a slow and steady uptick,” Oscar Spencer, Director of Engineering at Suborbital, told The New Stack. Oscar is also the co-author of the Grain programming language and spoke to The New Stack for the article mentioned above. In that, he expressed his disappointment at the AssemblyScript project withdrawing its support for WASI (WebAssembly System Interface), which was widely viewed as detrimental to adoption and something that would lead to greater fragmentation in the Wasm ecosystem.
However, Spencer is now confident that WebAssembly has moved past the problems of 2022. “The tooling is slowly getting better and developer confidence is slowly building,” he says.
To a certain extent, the fragmentation that Spencer predicted in 2022 has come to pass — but rather than be a challenge, it has arguably been one of WebAssembly’s strengths.
This is a point made by Ben Titzer, one of the co-founders of WebAssembly. “It's been amazing to see it used in so many contexts by so many different people,” he said. “I had expected an adoption trajectory to be more centralized…in reality, it's spread a lot by word of mouth, by independent experiments.”
Steve Manuel, co-founder and CEO of Dylibso, a software company that builds tools to help teams leverage Wasm, says that “we’re still in the early days.” He sees the current state of play as one consisting mostly of “systems engineers and compiler developers working on targeting Wasm.” However, he views “significant implementations at large companies” — like Shopify, which used Wasm for its Functions product — as a sign that “there is a swell of adoption just around the corner.”
“Every Shopify app developer is now re-tooling to work on this new product,” he added. “Whether they know it or not [they] are deploying WebAssembly modules to Shopify, disguised as apps on the platform.”
Adoption Successes and Challenges
Titzer says that as well as his surprise that the project hasn’t really been driven by central stewardship, he has also been surprised at “the gradual nature of existing languages targeting it.”
“While obviously C/C++ and Rust came to the ecosystem early on, other languages seemed to slowly put a ‘toe in the water’, first having limited support and then gradually investing more as usage takes off.”
As the founder of a company specifically developing tools to help engineers leverage WebAssembly, Manuel is in a great position to track and follow particular adoption trends. “One interesting area of growth is the adoption in business-critical, enterprise applications written in Java.” he says. That might sound surprising, but he explains that “many folks who lived through the early wave of Java basically see Wasm as JVM 2.0.” In practice, this means “Wasm being embedded in Java apps, largely using the Chicory runtime, primarily built by Dylibso and Red Hat, specifically for Java users.”
Another area where Manuel has seen success for WebAssembly is in helping developers “incorporate plugin systems into software applications.” In other words, “enabling end users to write a customization for the software using a program — the plugin — compiled to WebAssembly.”
Question Marks over Serverless?
One use case touted to be particularly appropriate for Wasm is serverless. Last year an industry analyst told The New Stack that he believed WebAssembly has the potential to tackle vendor-lock-in, one of the main weaknesses of serverless. Meanwhile, our analysis of Scott Logic’s State of WebAssembly 2023 report found that serverless WebAssembly use cases are on the decline, going from 36% of respondents in 2022 to 13% in 2023 (probably because the newer survey question differentiated between backend services and other serverless offerings, like vendor-centric Functions as a Service).
Manuel believes there are some challenges in this area.
“The adoption cycle just may take longer here as teams are forced to re-tool and re-skill, after having likely recently done so to adopt containers and Kubernetes,” he said. “There are efforts to bring Wasm to Kubernetes in a more streamlined fashion, but these are very recent.”
What Will Drive the Future of Wasm?
Wasm can ultimately be applied in just about any field. Indeed, Manuel notes that he is confident that it's going to have a part to play in the future of LLMs and AI, given its ability to be used “as a secure and portable runtime” for such workloads.
There are a few key things that are going to drive WebAssembly adoption in the months and years to come.
WASI is undeniably important. With version 0.2 widely hailed by those in the WebAssembly community as a milestone, stabilizing fundamental parts of the WebAssembly’s design and ecosystem, it provides developers with an easier way to use the technology.
“WASI preview two is a checkpoint of stable interfaces,” Spencer said. “The instability of preview one, [which] may have scared or prevented you from using Wasm in production, is now past us.”
Titzer also acknowledges the importance of WASI to the WebAssembly ecosystem. “It represents a great opportunity to have a well-thought-out platform with excellent security properties from the beginning, as well as wide deployments.” However, he notes that it isn’t that straightforward. “Designing high-level APIs that are cross-language and cross-platform is an example of a ‘wicked problem’ in software. The WebAssembly community will have to work hard to stick to proper layering to avoid pitfalls that others have fallen in.”
It’s interesting that both Titzer and Spencer see what lies beneath WASI as even more exciting. Maybe it’s not that surprising given their relationship to WebAssembly, but it nevertheless highlights that what’s important about WebAssembly isn’t reaching a plateau where it will finally make sense to everyone, but instead its capacity for new permutations and constant reimaginings.
“Core WebAssembly — the instruction set design — is a layer below WASI that will see adoption in contexts we have not yet dreamed of,” Titzer said. For Spencer, meanwhile, although WASI may have a more “immediate impact” for developers, it’s the Component Model — the architectural instructions that underpin Wasm’s interoperability — where the real value lies: “Longer-term, the ease that comes from the Component Model will be what makes Wasm take off.”
Another important facet to consider when it comes to Wasm adoption is new languages that enable compatibility with it. Although it might be the case that this has been somewhat “gradual,” as Titzer puts it, Manuel notes that languages are catching up with Rust in terms of their support for WebAssembly. He notes, for example, that Go recently added support for WASI and that it “can compile to Wasm to target virtually any Wasm runtime,” and also mentions newer languages like Zig. “Zig’s explicit memory management […] shines where it provides a very handy allocator specifically tuned for Wasm’s memory model,” he said. “Programs that are written in Zig perform very well compiled to Wasm.”
Is Wasm Telling a Clear Story?
It’s possible that one of the issues for WebAssembly is its ability to tell a clear story about itself. With something like Docker, for example, it was straightforward: it made it easy to build and run small component parts of a system or application inside containers.
This isn’t to say there isn’t a good story about WebAssembly; it’s more that telling one that makes sense to everyone is tricky.
“Communicating the core idea of WebAssembly is made both easier and harder by having a hot new thing it can do today,” Titzer said. “That external value story is always going to be context-dependent because the translation of that internal value to the use case is where external value appears.”
He offers some examples: “For smart contracts, the story is ‘deterministic, verifiably correct, and efficient execution targetable from mainstream languages’... for embedded systems, it's ‘weird CPUs look pretty much the same now and you can't brick the device accidentally’."
Manuel has a similar perspective to Titzer: “Wasm tells many compelling stories — that is both its weakness and its strength.” He believes this might explain why it hasn’t taken off at pace. “This broad audience [for WebAssembly] means that it has cross-cutting impact, but it can be a slow burner as the impact is diluted, for now, across these areas.”
In other words, WebAssembly adoption isn’t as noticeable as we might expect because it’s widely distributed, and spread across many domains and use cases.
Is It Just a Matter of Expectations?
Perhaps, then, it’s really a question of expectations. “I hear lots of people talk about what Wasm is or isn’t, but to me, Wasm is a compiler target,” Spencer says. “Yes, it’s a compiler target with nice security and portability characteristics, but it’s still just a compiler target. Replace every time you say WebAssembly with x86 or ARM and see if it still makes sense.”
In other words, when we talk about the adoption of WebAssembly we’re expecting to see something when, in actual fact, its real value isn’t necessarily visible. “As a foundational technology, it is often not visible — or maybe not even important — that Wasm is being used under the hood,” Titzer suggests.
With this in mind, maybe Wasm is mainstream. Spencer notes, for instance, that anyone who browses the web is likely to be interacting with WebAssembly on a daily basis. But then again, maybe it hasn’t: “Wasm has gone mainstream when we all stop talking about it as much,” he added.
Industry chatter aside, it’s possible that we just need to appreciate that slow and steady wins the race. “As I told Luke [Wagner, WebAssembly co-creator],” Titzer recounts, “‘taking over the world is a slow process, kind of like mold growing on things. Be the mold.’"
Editor's note: Additional statistics reporting for this post was contributed by Lawrence Hecht.
