WASMCon 2023: A Rising Tide

WasmCon 2023 was a jam-packed affair boasting four separate tracks and well over thirty talks, so any attempt to capture its essence is doomed to come up short. That said, we’ll do our best to summarize a few themes that we observed. Overall, one thing was as clear as the waters of French Polynesia: the Wasm tide continues to rise, promising to submerge the computing landscape at large in its warm waters. There’s something in the Wasm bag for everyone, so without further ado, let’s put on our wet suits and dive in!

Embedded Wasm on the Edge

Emily Ruppel’s keynote was a eye-opening plunge into the world of embedded, cyber-physical systems. Emily, a Bosch Research Scientist, surveys the problem space using the example of the myriad computers and sensors of a modern car, as well as industrial automation systems. The computers in these systems must interoperate with one another. However, they vary in architecture and power, and often the software is tightly coupled to the underlying hardware. Stacked on top of this are regulatory requirements, cost constraints, and let’s not forget the real-time, safety-critical nature of these systems. Wow…

Spoiler alert: Bosch Research solves these problems by creating an architecture and runtime, called Silverline, which brings lightweight virtualization, real-time aware orchestration, and a uniform communication interface into the mix. The Silverline runtime leverages WebAssembly to provide the flexibility for them to write applications once, and run them on any node within the network, regardless if it’s a Programmable Logic Controller (PLC), a low powered Electronic Control Unit (ECU), or a beefy Edge server.

It’s worth pointing out that the Silverline runtime underlies the WebAssembly Micro Runtime (“WAMR”). WAMR is a WebAssembly runtime, like Wasmtime or what you’d find in Chrome or Firefox. WebAssembly runtimes, similar to JavaScript engines, make design tradeoffs depending on their target: what architecture features to support, whether or not to include just-in-time compilation support —and if so, how many tiers based on which heuristics— and memory constraints. What’s relevant to this post, however, is that WAMR runs on embedded architecture.

We’ll stop short of restating her talk, but you really should check it out!

We continue our voyage along the Edge with Midokura’s Tatsuya Kato (“TK”) & Dan Mihai Dumitriu’s WEdge Project: Edge AI enabled by Wasm. Dan and TKさん introduce Sony’s edge AI sensing platform, AITRIOS™. Again, this application runs on constrained hardware with specific needs around security updates. Dan describes the WEdge SDK, which defines common interfaces for sensor data, communication, inferencing models, data storage, and OpenCV.

Similar to Silverline, WEdge is implemented on top of WAMR and demonstrates the success of another large manufacturer pushing WebAssembly into embedded devices while defining their own interfaces to hardware sensors. In Midokura’s case, the primary focus is running AI workloads directly on cameras, such as Sony’s IMX500™.

Wait, did someone say AI?

AI + Wasm

That’s right folks, even the all powerful AI can not escape the Wasm tsunami.

Radu Matei’s keynote affirmed that AI is becoming an essential facet of the software stack and zoomed in on the current challenges for traditional developers who are tasked with integregating AI-powered features into modern applications. He goes on to show how machine learning models can be packaged as Wasm components in order to reduce their size, better enabling them to be shuttled over to the hardware (e.g. GPUs) needed to unlock their true potential. Cold start times are another concern, especially when running inferencing workloads in a serverless environment, and Radu demonstrated how these can be significantly reduced when using WebAssembly as opposed to other technologies such as containers.

Presentations by representatives from VMWare, Microsoft, Fastly, and Second State also described the usage of Wasm to empower the AI driven future, so this is definitely no hallucination.

Pluggable Wasm

It was also apparent that the sandboxing powers of WebAssembly remain a killer feature for bringing a new wave of extensibility to the computing landscape. From developer tooling to API ecosystems to banking applications, it’s all fair game.

Rohan Deshpande showed us how Goldman Sachs is supercharging their API ecosystem with Wasm powered plug-ins that can be created and deployed by various teams within the organization. Given the size and scale of the Goldman tech infra, and the very real security and quality concerns of a top tier bank, it was impressive to see this level of flexibility applied to their operations. The platform created by Rohan’s team enables the creation of plug-ins in Go, Java, and TypeScript, while providing runtime isolation, code reuse, and application of firmwide development practices (e.g. code reviews, depedency tracking, etc.)

Developer productivity is also a focus for Dirk Bäumer, who dove into the intricate details of bringing Python, PHP, and Ruby language servers to the VSCode web interface by the power of Wasm and WASI (preview 1). Bringing this to life required the re-implementation of a virtual filesystem, complete with inodes. This is yet another example of Wasm enabling next level extensibility of applications no matter where they live (e.g. browser, cloud, etc.)

Dirk also reaffirmed Microsoft’s commitment to the Component Model.

The Component Model

Speaking of the Component Model, it was a fine thread running through all of WasmCon 2023, and for good reason. The Component Model holds with it the possibility to transform the way we create software, and make universal interoperability between programming languages a reality. Most talks referenced the Component Model in some way, ranging from high level visionary stuff to the nitty gritty. The big takeaway for us was that this beautiful, previously evasive, utopia may very well be a reality.

Luke Wagner’s keynote, What is a Component (and Why)? painted a perfect portrait of a new, interconnected world of polyglot components working together from within their safely isolated sandboxes in a reimagination of the modular monolith, while Bailey Hayes mapped out a subway system of complementary concerns that are all coming together to answer the big question Are We Componentized Yet?

The idea set sail in Joel Dice’s presentation, which took the audience into the depths of Componentize-Py. componentize-py is a tool for transforming Python apps into portable WebAssembly components that include libraries with native dependencies (e.g. NumPy). Together with tools such as Cargo Component, used to componetize Rust code, and JCO, used to run Wasm Components in JavaScript environments, Componentize-Py provides a window into how the strengths and nuances of various language ecosystems can be included in the Component Model, turning this polyglot dream into reality.

Uncharted Waters

Some talks reminded us that we are still traveling through unknown seas and that more exploration, development, and knowledge will be required in order to realize WebAssembly’s true potential.

Dylibso’s very own Ben Eckel laid out the the current problems inherent in moving Wasm sourced telemetry data across the guest / host boundary and integrating it with industry-standard Observability tooling. This is a particularly hairy problem that adds friction to the process of making Wasm production-ready. But fear not folks, Ben sketched out a compelling vision of the future that not only solves these problems but opens up new possibilities for the observability space that Wasm makes possible.

Another gap comes in the form of the management and distribution of Wasm at scale. A viable package management solution is a crucial component for accelerating and connecting any digital ecosystem. Just think about the impact that NPM and OCI registries have had in the JavaScript and container worlds respectively. So what form will this take in the world o’ WebAssembly?

Daniel Macovei of JAF Labs may have the answer. His talk takes us into the design and implementation of Warg, a federated registry for WebAssembly Components and core modules that could become the de facto method for individuals and organizations to share Wasm with one another in secure fashion.

Circumnavigating a Diverse World

In order to realize the promise of this rising tide, it’s imperative that established ecosystems – including venerable programming languages and embedded hardware – have a pathway to Wasm.

This theme was a deep current at WasmCon 2023, manifesting through the language specific tooling for the Component Model (e.g. Compentize-Py), or runtimes (e.g. WAMR) that toe the line with respect to Wasm standards, while offering their own special sauce to maximize the inherent strengths of specialized hardware.

Eduardo Vaachi, the Wazero Hero from Tetrate, treated us to a delightful jaunt through the internals of Wazero, a WebAssembly runtime that derives its name from its raison d’être, Wasm with zero (native) dependencies. It jettisons Cgo and its associated limitations (e.g. loss of portability, tooling, runtime issues), and provides gophers with a pure Go runtime that enables them to enjoy Wasm within the comfort of their own biome.

It leaves one to wonder what other specialized runtimes may flourish in these rich waters as the future rushes into the present. Hmmmmm.

Until Next Time

And just like that our brief recap must come to a conclusion, but we miss you already WasmCon and can’t wait for what comes in 2024 and beyond. It’s exciting to see new standards in the form of the Component Model coming to fruition, but more importantly, it’s exciting to see that there are real fulcrums where the community can plant a proverbial crowbar and help move it forward.

At Dylibso, we believe a rising tide lifts all ships and that our most effective role is to contribute to the overall well-being of the Wasm environment. This means offering support to those who use core Wasm by providing runtime and component model independent tools. It also means serving as a bridge to the Component Model and other emerging standards by contributing to them, and supporting them in our products.

So peer through the spyglass, Wasm land ho!