A Deeper Dive into WebAssembly, the New Executable Format for the Web


Web Assembly on monitor

Things are constantly changing in the world of computing. From mainframes to cloud IaaS, from virtual machines to Linux, we are constantly extending and reinventing technologies. Often these changes are driven by the fact that “the way we’ve always done it” no longer works in a new paradigm, or actually wasn’t that great to start with.

We don’t have to look hard to see recent examples. Virtual machines (VMs), containers, Kubernetes, and OpenTelemetry are just a few examples where changing requirements inspired new solutions. And as Kubernetes and OpenTelemetry show, when the solution is right a tsunami of adoption follows.

I recently spoke with some industry experts about three technologies they predict will be the Next Big Things. One of the three in particular deserves a more detailed look: WebAssembly (often abbreviated as Wasm). Wasm has caught the interest of many because it extends the language support for browsers beyond JavaScript. No, it’s not a replacement for JavaScript; rather, it’s the fourth and newest language accepted by the World Wide Web Consortium (W3C) as an official web standard (along with HTML, CSS, and JavaScript).

What Is WebAssembly?

Back in 2015, Mozilla started work on a new standard to define a “a portable, size‑ and load-time-efficient format and execution model” as a compilation target for web browsers. WebAssembly basically was designed to allow languages other than JavaScript to run within the browser. And Wasm quickly caught on with browser vendors, with all the major browsers supporting it.

Some of you may recall the days of cross‑compilers, where code was targeted at an external environment, often in control hardware. The targets varied wildly, which meant the cross‑compilation had to be strictly aligned between the generating system and the target system. Wasm works in a similar way, providing a binary executable to a defined runtime on a wide range of platforms. Since the runtime is a low‑level virtual machine (think JVM), it can be embedded into a number of host applications.

So Wasm is a portable binary code for executing programs and a set of interfaces for interaction between the program and its environment. No where does it make any web‑specific assumptions, so it can be used widely. In fact, the interest in Wasm is heavily driven by its potential in server‑side use cases. Companies like Cosmonic, Fermyon, and Suborbital are showing that Wasm will impact our future in apps from the browser to the back end.

One of the compelling features driving adoption has been Wasm’s support for many languages, with pretty complete coverage for nearly every popular language, including C, C++, Go, Ruby, and Rust. Partial implementations for other languages are available or likely underway. But a word of caution – Wasm’s support for a given language may be limited to a particular context: the browser, outside the browser, or even directly on a system. So it’s important to verify that Wasm supports a language in the context where you want to use it.

Why Should You Care About WebAssembly?

WebAssembly has focused on several crucial features that all browsers need. We’ve mentioned the polyglot nature of Wasm, which has allowed the browser to be extended to many languages. But there are several others.

  • Speed/performance – No one likes waiting for web pages to load. It’s even less fun waiting for a web application to load and start. Wasm’s compilation model makes loading fast. In fact, performance can approach that of a native application.
  • Size – For web apps, the size of the objects being downloaded is the crucial factor. Smaller binaries mean faster time to start.
  • Cross‑platform – Web browsers are the universal access point for websites and apps, so we want “write once, run anywhere” (on every browser) to be a reality rather than just a promise. Wasm already delivers on this pretty well, and will continue to improve.
  • Multi‑lingual – In the modern age of adaptive applications and microservices architectures, no one language is suited for every purpose. By extending apps from many languages to the browser, Wasm removes a major “anti‑pattern” blocker, also known as “I don’t use that language”. Especially when we look at server‑side use, we need to move beyond solely JavaScript, and Wasm enables us to do that.
  • Security – If you have to run untrusted code in your browser, it must be isolated. Wasm achieves isolation with memory‑safe sandboxed execution environments. The current implementation isn’t perfect, but Wasm contributors are heavily focused on it, so I expect rapid improvement.

Its focus on these features makes Wasm incredibly high‑performance, efficient, and honestly, fun. A great place to learn more about that is the recording of Franziska Hinkelmann’s talk at CovalenceConf 2019: Speed, Speed, Speed: JavaScript vs C++ vs WebAssembly. Keep in mind that right now Wasm might not be all that much faster than JavaScript, but it doesn’t yet have JavaScript’s many years of optimization work behind it either. Also, speed is not the only factor in Wasm’s favor – size and the ability to use your language of choice also matter.

How Do You Get Started?

There are a lot of great resources on WebAssembly. It is clearly the path a number of companies are following, from startups to major players:

  • Adobe has demonstrated Photoshop running in Wasm in the browser.
  • Figma saw load time cut by 3X with Wasm.
  • Wasm Labs at VMware has demonstrated WordPress, a PHP runtime, and a database all running in the browser.

But you don’t have to start by switching over to Wasm in one fell swoop. These are all great resources for learning more:

  • WebAssembly.org is the definitive source for all things Wasm, including the specs and a well‑structured Getting Started guide for developers.
  • On her blog, Renee Shah asked technologists at 18 startups how and why they’re using Wasm.

Additionally, these demo apps are running on Wasm:


WebAssembly is still a work in progress, and as with any new technology, some aspects are more complete than others. Even so, the concepts behind it are compelling, and I predict that it’s going to be a game changer, a major force for the future of adaptive apps, either in browser or in a cloud. Without a doubt, WebAssembly is one of the technologies you need to learn about now.