WasmCon 2024

The burgeoning realm of embedded systems, particularly those that are safety-critical and constitute integral components of cyber-physical systems, presents a unique set of challenges and opportunities for the WebAssembly (Wasm) community and runtime projects. As industries like automotive, industrial automation, and consumer electronics, represented by giants such as Bosch, Siemens, and Sony, increasingly adopt and integrate Wasm into their ecosystems, it becomes imperative to address the nuanced requirements of these domains. This panel discussion will explore Wasm's role in advancing innovation, security, and reliability in these fields. Key discussion points will include safety and reliability, resource constraints, real-time performance, security, and standards-based interoperability. Innovative use cases will showcase cutting-edge applications of Wasm in embedded and cyber-physical systems, highlighting collaborative efforts between industry leaders like Bosch, Siemens, and Sony.

WebAssembly is revolutionizing the way we build modern applications, providing near-native performance and cross-platform capabilities. However, accessing GPU resources for rendering graphics or performing compute operations has been challenging for Wasm applications, especially outside of the browser. Enter wasi-webgpu, a Phase 1 WASI proposal that bridges this gap by exposing the WebGPU API to Wasm guest code through the Component Model. With wasi-webgpu, any Wasm application can leverage the power of any GPU to render stunning 2D and 3D graphics and execute advanced AI algorithms. This talk will explore the design and capabilities of wasi-webgpu, demonstrating how it empowers developers to build high-performance applications that seamlessly integrate GPU functionality. We'll cover: * What is wasi-webgpu and why you should care * Runtime architecture and compatibility with the WebGPU spec * Examples: (time permitting) * Rendering 2D & 3D graphics * GPU-accelerated AI

WASM (WebAssembly) is rapidly gaining traction, but a comprehensive understanding of its security landscape remains fragmented. This panel discussion aims to bring together WASM experts and security enthusiasts to address this gap. This discussion will provide a valuable starting point for developers building secure WASM applications. It will also benefit WASM users by raising their awareness of potential security concerns. The discussion is expected to span the following major areas: Built-in WASM security features and limitations Security tools available for the WASM ecosystem Potential attack vectors and mitigation strategies Best practices for secure WASM development

Debugging and profiling programs is done through instrumenting the program-under-observation (inserting instructions to monitor dynamic execution). The most-common techniques inject instructions directly into the program. While this enables tools to support any domain, it intrudes on the program state space, complicates the implementation, limits the scope of observation, and cannot dynamically adapt. These issues can be remedied by interfacing with an engine, like Wizard, with instrumentation support. A recent ASPLOS paper demonstrated how to build support that protects the application, provides consistency guarantees, applies JIT optimizations, and more. However, this technique limits a tool's scope to programs that can run on such engines. This talk presents the design of a new instrumentation DSL for Wasm that abstracts above the injection technique enabling tooling to support a wide domain of applications while leveraging runtime capabilities as-available without reimplementation.

One of the most beloved features of the component model is extensibility. As the WebAssembly ecosystem continues to grow, the WebAssembly community will need extensibility beyond component composition to build everything from plugins to fully distributed microservices and everything in between. This is where wRPC (WIT-RPC), a WebAssembly component-native, transport-agnostic RPC protocol and framework comes in. wRPC facilitates WIT (WebAssembly Interface Type) defined composition over network, IPC, or other means of communication. What this means is every WebAssembly component can be used with wRPC out-of-the-box using your execution model of choice. This talk will discuss why wRPC exists, the design behind it, and how you can integrate it with your WebAssembly runtimes and platforms. Through many diagrams and demos, you’ll learn why wRPC is important and how it can be used to create reusable, language-agnostic plugins and distributed component communication.

With the Web IDL now available as a Wit package, any programming language can leverage browser APIs, just like JavaScript. Our speakers explain how this works and showcase the exciting possibilities it opens up. Using WASI implementations built for the browser, components running in a Service Worker can intercept outbound HTTP requests, responding in the place of the server. Opening up interesting offline as well as local-first applications.

Sure, we all love Wasm, but how are you actually supposed to deploy and consume it? The OCI Artifact guidance provides a standardized way to build and distribute content of all shapes and sizes. In this session, we’ll introduce you to the Wasm OCI Artifact specification and how you can use it to distribute, discover, and consume Wasm components just like other cloud native artifacts – all while using your existing tooling and controls. In this talk we’ll break down how to package and use Wasm as OCI artifacts, complete with live demos. We’ll show how you can use common tooling to pull the same Wasm component from a registry and run it seamlessly across runtimes such as runwasi and wasmCloud. Plus, we’ll demonstrate how these components fit neatly into dependency management. Join us for a session packed with insights, live demos, and a dash (or two) of humor, as we explore the future of Wasm with the OCI spec.

WebAssembly offers a lot of advantages for IoT and embedded development: developers can use modern toolchains, diverse programming languages and sandboxing technology on truly tiny devices like ESP32 microcontrollers. Support for these use-cases is improving with the newly formed Embedded SIG and new interfaces for connecting WebAssembly applications to underlying hardware via USB and I2C. This talk explains how WebAssembly improves embedded development and shows how to control connected USB and I2C devices from WebAssembly. It covers the WASI-USB and WASI-I2C proposals and explains how to embed a device driver in WebAssembly. The session also takes a look at the overhead of these interfaces and embedded WebAssembly in general. The session closes with a peek into the future.