Wasm I/O 2025

Wasm I/O 2025 - Barcelona, 27-28 March Slides: https://2025.wasm.io/slides/bringing-honest-computing-to-the-wasm-world-wasmio25.pdf In this talk, we will introduce the concept of honest computing and why the need for it has never been more critical. Honest computing envisions system that prioritise data and code integrity, enable accountability and provide confidentiality by design and by default in an attestable and demonstrable manner. These systems operate transparently, ensuring reliability without hidden agendas or biases. We will then see how the WebAssembly (Wasm) ecosystem fits perfectly in this vision. Its portable, sandboxed execution environment and deterministic builds provide the foundation for secure, verifiable computation. By combining the Wasm ecosystem with technologies like Trusted Execution Environments (TEEs) and distributed ledgers, Wasm empowers developers to build “honest applications” that uphold integrity and accountability at all times. This talk explores how Wasm’s unique characteristics such as its format, memory sandboxing, and portability make it an ideal building block for developers and an essential tool for broader adoption of honest computing. We will explore practical architectures, demonstrate how the Wasm ecosystem integrates within honest computing, and showcase some real-world examples. By the end, you will have a better understanding on what is Honest Computing, why it matters and how to leverage Wasm to build honest application in your software.

Wasm I/O 2025 - Barcelona, 27-28 March Slides: https://2025.wasm.io/slides/smarter-operating-systems-will-use-wasm-the-coming-os-revolution-wasmio25.pdf Repo: https://github.com/JonasKruckenberg/k23 Operating systems are the ultimate generic challenge: They have to run on a wide variety of hardware and support a multitude of programs. This puts them in the awkward position of being very conservative and making less ideal decisions in the name of portability, reliability, and security. k23 started with the realization that WASM allows us to flip the script on this, though: By embedding a WASM just-in-time compiler directly into a microkernel, we can aggressively optimize components for the hardware at hand and tune memory allocations to the running programs. We can also be much more helpful, automatically checking for use-after-free bugs, printing stack traces, snapshotting application state, tracing program execution, and more. In my talk, I want to present k23, how strong isolation and capability-based security lead to more secure software, how embedded JIT compilers lead to a more performant and helpful OS, and talk about what the future might hold.

Wasm I/O 2025 - Barcelona, 27-28 March By Natalia Venditto - Microsoft, Oscar Spencer - F5 NGINX, Till Schneidereit - Fermyon, Bailey Hayes - Cosmonic & Ralph Squillace / Microsoft.

Wasm I/O 2025 - Barcelona, 27-28 March Leveraging compilers and runtimes that have been compiled to wasm, we can create wasm from source code directly in the browser. With the Component Model and WASI, we can even author wasm components that make use of the network. Moreover, with service workers, we can run the backend services that comprise a service mesh in the browser as we develop them. In this talk we’ll cover the nuts and bolts of how this is possible with WebAssembly, as well as how these tools enable sharing with links at each phase of the development cycle, from writing your code, to debugging and testing it, to deployments.

Wasm I/O 2025 - Barcelona, 27-28 March Slides: https://docs.google.com/presentation/d/1hORpnPsTxS0_zBTVZcL-GvWcLjdU6-yLEWU1DTV7e8w/edit#slide=id.p1 WebAssembly (Wasm) is increasingly playing a key role in video game distribution and online gameplay. Additionally, Wasm serves as a pivotal enabler for successful media streaming by industry giants such as Microsoft, Disney, Netflix, and others. While the intricate “under-the-hood” workings and infrastructure of media streaming largely remain opaque due to proprietary services, this talk provides an overview of how gaming and other content are currently utilized and how they should evolve in the future. As an example of how gaming distribution and play can work, we demonstrate how WebAssembly, in conjunction with Emscripten, is used to compile the original Doom’s C code into a format executable within a browser environment. The fork we created and worked with on GitHub proved to be more challenging than anticipated. During the talk, we discuss the struggles we faced and the solutions we implemented to successfully get Doom running in a browser. By dissecting this process, attendees will gain valuable insight into the inner workings of WebAssembly for game streaming. Additionally, attendees will have the chance to play Doom directly in their browser using a link provided during the session. Join us to explore how WebAssembly is shaping the future of gaming and media streaming.

Wasm I/O 2025 - Barcelona, 27-28 March Slides: https://speakerdeck.com/syrusakbary/making-php-extremely-fast-in-webassembly In this talk, we will share the story of how we leveraged WebAssembly to run PHP perform nearly as fast as native code, and in many cases even faster. We’ll walk through the steps we took, the challenges we faced, and the tangible impact it had on our services. Whether you’re a developer, architect, or performance enthusiast, this talk will showcase practical insights into bridging the gap between interpreted languages and native performance. KEY TAKEAWAYS -Learn how WebAssembly can be a game-changer for PHP and other interpreted languages. -Discover the optimizations and strategies we employed to achieve near-native speed -Understand the real-world impact on scalability, latency, and resource efficiency. WHO SHOULD ATTEND This talk is for developers, architects, and anyone interested in WebAssembly, PHP, or high-performance web applications. Whether you’re working on modernizing legacy systems or exploring cutting-edge web technologies, this session will provide actionable insights. WHY THIS TALK? The convergence of WebAssembly and traditional languages like PHP opens up a new frontier for web development. Our experience demonstrates how embracing Wasm can redefine performance expectations, making this talk a must-attend for anyone looking to push boundaries.

Wasm I/O 2025 - Barcelona, 27-28 March It’s no secret that for a long time machine learning has been mostly a Python game, but the recent surge in popularity of ChatGPT has brought many new developers into the field. With JavaScript being the most widely-used programming language, it’s no surprise that this has included many web developers, who have naturally tried to build web apps. There’s been a ton of ink spilled on building with LLMs via API calls to the likes of OpenAI, Anthropic, Google, and others but in these cases, the user is sending the data and the prompt to the servers of these tools and hence is not a 100% secure. and relying solely on cloud APIs raises issues like cost, latency, and privacy moreover some companies/organizations might require a privacy focused approach which requires building web apps using exclusively local models and technologies, preferably those that run in the browser! This is where open source tools like LangChain, Voy come into the picture. In this talk, we demonstrate building real-time conversational agents using local machine learning that address these concerns while unlocking new capabilities. We detail constructing a complete language model pipeline that runs fully in the browser. This includes ingesting documents, embedding text into vectors, indexing them in a local vectorstore, and interfacing with a state-of-the-art model like Ollama for text generation. By using lightweight packages like Transformers.js and Voy which is an open source vector store running on the browser with the help of WebAssembly, we can quantize and compile models to run efficiently on the user’s device all thanks to WASM. This allows us to build complex conversational workflows like retrieval augmented generation entirely on-device. We handle ingesting external knowledge sources, “dereferencing” conversational context, and chaining local models together to enable contextual, multi-turn conversations.

Wasm I/O 2025 - Barcelona, 27-28 March Slides: https://2025.wasm.io/slides/the-future-of-write-once-run-anywhere-from-java-to-webassembly-wasmio25.pdf Programming languages that are designed to be statically compiled such as Rust, Go, and C++ already provide good support for Wasm, unlike languages such as Java or Python. But what does it take to compile Java to Wasm? In this session, we’ll introduce the brand new Wasm backend for GraalVM Native Image, which allows developers to compile Java applications into efficient Wasm modules leveraging the new Wasm GC proposal. We explain how Native Image and the new backend work, outline possible use cases, and show live demos. We also discuss current limitations and provide an overview of what to expect next. If you’re interested in the future of Java and WebAssembly, this talk is for you!

Wasm I/O 2025 - Barcelona, 27-28 March Slides: https://boxer-wasmio2025.spinup.site/ While containers have been pivotal in cloud computing, offering isolated environments for applications, they bring notable drawbacks. These include substantial overhead, resulting in larger, less efficient deployments and startup times, and a dependency on the underlying OS for security, posing potential vulnerabilities. This scenario necessitates a more efficient, secure, and universally adaptable deployment method. WebAssembly (Wasm) addresses these challenges, and this talk will introduce the open-source project Boxer, which offers tooling for taking existing containerized workloads and definitions, and creating near-universally deployable Wasm distributions (“Boxes”) offering roughly the same environment, with all the benefits of the WebAssembly target. Wasm, a compact binary instruction format, enables lightweight, sandboxed execution, significantly reducing overhead compared to traditional containers. This leads to enhanced performance and smaller, more efficient deployments, ideal for cloud computing. Additionally, Wasm’s memory-safe, isolated execution environment provides superior security, independent of the OS. Thus, Wasm, with its blend of efficiency and security, emerges as not just an alternative, but a substantial improvement over container technology for cloud deployments. This talk will critically examine this new technology, its approach, benefits, and existing limitations compared with containers, and its path forward as a new standard in cloud infrastructure.

Wasm I/O 2025 - Barcelona, 27-28 March Slides & Repo: https://github.com/deadprogram/wasmio2025 Creating a computer vision application so it can run on many different machines and different types of hardware has historically been very difficult. Sounds like an excellent use case for WebAssembly! wasmVision (https://wasmvision.com/) is a new project for high-performance computer vision applications based on WebAssembly. It uses the wasmCV interface (https://wasmcv.org/) which provides guest bindings for computer vision applications based on OpenCV. Any language that can compile to WASM can then use these interfaces to create processors to do tasks like image filtering, object detection, communicate with vision models, and more. In this talk, I will show several demonstrations using code written in Rust, Go, and C to perform a number of visually interesting tasks, including displaying live video from a drone.

Wasm I/O 2025 - Barcelona, 27-28 March Slides: https://2025.wasm.io/slides/from-cloud-to-edge-computing-unleashing-the-power-of-webassembly-at-the-edge-wasmio25.pdf As cloud computing reshapes traditional backend architectures, emerging demands for ultra-low latency and data locality reveal its limits. Enter edge computing—where WASM serves as a critical bridge between centralized cloud capacity and the need for distributed processing. In this session, we’ll dive deep into how WebAssembly enables lightweight, secure, and fast compute workloads at the edge, with an emphasis on real-world use cases that leverage Rust’s unique strengths for predictable performance and memory safety, while coexisting with cloud resources. We’ll showcase the architectural tradeoff and technical challenges we face at Edgee such as data sovereignty and security constraints to power features such as data collection and dynamic A/B testing. We’ll share how we optimized our open-source Rust-based WebAssembly components for edge deployment. Join us to discover how to build architectures that seamlessly blend cloud and edge, unlocking a new level of responsiveness and efficiency.

Wasm I/O 2025 - Barcelona, 27-28 March Slides & Repo: https://github.com/renderlet/wasm-io-25 wasi-gfx is a phase 2 proposal that bring GPUs to Wasm through the power of WebGPU. By providing component bindings through wasi-webgpu, as well as supporting functions around frame buffers, surfaces, and input, it is possible to take WebGPU code written for a browser and run it safely in a desktop app in Wasm. wasi-gfx also has wrappers and backends for common graphics interfaces like wgpu, Bevy, webgpu.h, and the WebGPU examples, so existing Wasm and JS code can be rub on WASI hosts without minimal or no modifications. This is a powerful tool to be able to run web applications outside of a browser, as a desktop app or service. But how can these interface with existing applications? Can we bring the security and cross-platform benefits of Wasm to build GPU-enabled plugins as part of an existing game or app? In this talk, we will show how this can be implemented, and do a technical walkthrough of the different components we built to interop with a game engine. Learn how you, too, can leverage wasi-gfx to enable plugins to interact with the GPU as a part of your own application, regardless of architecture. Some of the topics we will cover include: -Building a robust data model for plugins -Drawing into an existing window -Limiting plugin time/resource consumption -Seamless interop between Native C++ host and Rust Wasm engine I-nitializing and sharing resources between DX12 and wasi-webgpu

Wasm I/O 2025 - Barcelona, 27-28 March Slides: https://2025.wasm.io/slides/unlocking-observability-in-webassembly-with-opentelemetry-wasmio25.pdf WebAssembly (Wasm) is transforming the cloud-native landscape with its unmatched security, performance, and portability. As Wasm continues to evolve, ensuring it is observable becomes essential. Join us for an update on how OpenTelemetry integrates with WebAssembly. We’ll explore the latest advancements in extracting traces, metrics, and logs from Wasm components, guided by open-source standards like WASI OTel. Additionally, we’ll highlight the unique advantages Wasm offers to observability, such as automatic cross-language instrumentation. The session will conclude with live demos showcasing WebAssembly observability in production.

Wasm I/O 2025 - Barcelona, 27-28 March Slides: https://2025.wasm.io/slides/real-world-wasi-components-wasmio25.pdf In this talk, we’ll explore the power and versatility of WASI components through a practical implementation of the Content Authenticity Initiative (C2PA) API. Our journey will showcase how a single WASI component can be leveraged across diverse environments, demonstrating the true potential of WebAssembly’s write-once-run-anywhere promise. Key highlights: 1. Introduction to our previous use of WASI components at Adobe. 2. Deep dive into a custom WASI component based on the C2PA API. 3. Demonstration of the component’s integration with wasmCloud using wasi-http . 4. Demonstration of CLI application creation using wasi-cli 5. Insights into developing JavaScript and Node.js SDKs for broader accessibility. This presentation will offer valuable insights for developers interested in WebAssembly’s cross-platform capabilities, the Content Authenticity Initiative, and the future of SDKs with WASI.

Wasm I/O 2025 - Barcelona, 27-28 March Slides: https://docsend.com/view/emsen5fn4ns6icih Repo: https://github.com/bacalhau-project/examples/tree/main/edge/wasm-sensors WebAssembly promises universal compute, but the path to production is filled with challenges. While we have great tools for building WASM modules, we’re missing crucial infrastructure pieces for real-world deployment and management. In this talk, we’ll dive into the critical gaps holding back WASM adoption and show how Bacalhau solves them: - Universal Deployment: Watch us deploy the same WASM workload seamlessly across clouds, edge devices, and local environments with zero code or job changes - Data Gravity: See how Bacalhau intelligently moves computation to where your data lives, reducing latency and transfer costs - Resource Management: Learn how to handle resource allocation, isolation, and scaling across heterogeneous environments - Production Readiness: Explore monitoring, observability, and fault tolerance in distributed WASM deployments. Through live demos, we’ll showcase real-world scenarios like: -Running ML inference across edge devices while keeping data local -Orchestrating WASM microservices across multiple cloud providers -Managing large-scale data processing with automatic failover You’ll leave understanding how to deploy WASM workloads in production today, with practical solutions to challenges like workload scheduling and data routing. Whether you’re building edge applications, microservices, or data processing pipelines, you’ll learn how to leverage WASM’s portability while ensuring production-grade reliability.

Wasm I/O 2025 - Barcelona, 27-28 March Slides: https://2025.wasm.io/slides/giving-low-code-to-web-with-webassembly-velneos-success-story-wasmio25.pdf In this talk, we will explore how Velneo implemented WebAssembly to bring its applications to the web environment. Through a practical approach, I will demonstrate how we combined WebAssembly with C++ and Qt to develop a comprehensive ecosystem that includes a database manager, a server administrator, and an application editor. Attendees will understand the benefits and challenges of this implementation, offering valuable insights for any developer looking to leverage WebAssembly.

Wasm I/O 2025 - Barcelona, 27-28 March Slides: https://speakerdeck.com/angelmmiguel/o Wasm has blurred the lines between servers and clients, allowing you to run full-stack development environments completely inside your browser. Thirty plus years ago, when the web started, only text and images were supported. Over time, it evolved to support programming. First was JavaScript and Java Applets, later on ActiveX and Flash. Today, WebAssembly and browser APIs allow you to interact with audio/video, filesystems and GPUs, securely and efficiently. This talk explains how you can leverage Wasm and the browser to build the dream programming environment. You can instantly run any combination of language runtimes, databases and servers that you can share with your friends and teammates without having to worry about running and maintaining cloud infrastructure. We will discuss the OSS projects, technology choices, tradeoffs and hacks involved to make this possible, including demos!

Wasm I/O 2025 - Barcelona, 27-28 March Slides: https://2025.wasm.io/slides/moonbit-and-webassembly-unlocking-the-true-efficiency-of-wasm-wasmio25.pdf MoonBit is a young programming language. It has WebAssembly as its first backend, and makes use of many recent proposals such as GC and Js-string-builtins. It produces high quality output, both small in size and fast in execution. MoonBit has demonstrated many use cases, through integration with component model and extism and so on, such as games on Wasm4 in ESP controller, AI Agent on WasmCloud, torch in browser, etc. In this talk, we’ll have a brief introduction at MoonBit: what it is, what it has achieved. We’ll give an introduction about its design philosophy, including how it integrates with AI and how the ecosystem is built. We’ll also give some demo using MoonBit with techniques such as Component Model.

Wasm I/O 2025 - Barcelona, 27-28 March Slides: https://docs.google.com/presentation/d/1UDdWnZ7wHM-7PyXa4x_7AnGWZ76-K6MbjO3zT55gbUg/edit?usp=sharing WebAssembly has gained widespread adoption in the browser, but its transition to the server side presents new requirements and challenges that must be addressed for it to reach its full potential. Based on the experiences of the two speakers—one working in a large corporate environment striving to foster Wasm adoption internally, and the other from a small startup focused on building better tooling for the Wasm ecosystem—this talk explores the hurdles and opportunities in establishing Wasm’s place, on the server side, across diverse contexts. We’ll analyze the key requirements necessary to make Wasm a mainstream technology on the server side, focusing on the following topics: -The current state of the System Interface (WASI) -Debugging tools for server-side Wasm -Monitoring and observability practices -Package management challenges -Secure supply chain requirements -Join us as we explore the evolving landscape of server-side WebAssembly and its potential to transform backend development.

Wasm I/O 2025 - Barcelona, 27-28 March Save the date: Wasm I/O 2026 - 19-20 March, Barcelona

Wasm I/O 2025 - Barcelona, 27-28 March Slides: https://docs.google.com/presentation/d/17WOgQjSGMmH92yRGfO4rkxL3Ir3xPlM-T1r0Ff1DDCk/edit?usp=sharing The WebAssembly GC proposal is a game changer for high-level programming languages, offering the potential to streamline memory management, reduce module sizes, and improve execution speed. This proposal significantly reduces the need for languages to inject complex runtime code to manage memory, making WebAssembly applications built from these languages far more competitive with lower-level languages. In this talk, I’ll share my experience transitioning the compiler for the Grain programming language from its current linear memory model to the new Wasm GC proposal. I’ll dive into the technical challenges, the lessons learned, and the changes made to the compiler to leverage WebAssembly’s new garbage collection features. Through this case study, I’ll explore how this proposal will impact the development of compilers for high-level languages and what it means for optimizing performance in Wasm-based applications. Beyond compiler-specific details, I will also discuss the broader implications of Wasm GC for the WebAssembly ecosystem, particularly in relation to the WebAssembly Component Model. What does it mean for modularity, interoperability, and the future of WebAssembly as a platform for polyglot languages and applications? Attendees will leave with a deeper understanding of WebAssembly’s evolving capabilities, how Wasm GC affects both high-level language implementation and the broader ecosystem, and how it will shape the future of WebAssembly.

Wasm I/O 2025 - Barcelona, 27-28 March Slides: https://2025.wasm.io/slides/privacy-preservation-with-smarter-automotive-experiences-wasmio25.pdf Taira Automotive is a privacy-preserving service that orchestrates intelligence across global fleets of vehicles by using edge networks in over 100 data centers. Using WebAssembly we deploy intelligence workloads instantly to large fleets, distributing training and inference across both Nvidia and Intel platforms, without the need to collect or aggregate data. Each vehicle trains on its own data, and runs inference, enabling offline services to be smarter and responsive, whilst benefiting from significant cost efficiencies and sustainability improvements. Our demo showcases the platform running on mobile, in-vehicle, and across the edge network, using a variety of WebAssembly runtimes, whilst complying with global data regulations, across borders, with safety and privacy preserved. This is a step forward from the original talk: “From Event-Driven to Automotive”, focusing on a single use case.

Wasm I/O 2025 - Barcelona, 27-28 March Slides and repo: https://github.com/launchscout/wasmio_2025 The OTP platform that powers Erlang and Elixir is a great way to build reliable, self-healing systems that’s been proven in production for decades. Wasmex is a library that lets us host WebAssembly Components in Elixir so we can benefit from all the OTP goodies to build bullet proof WASM. We’ll start the talk with a brief description of OTP focusing on how supervised processes work and the “let it crash” core concept. After that we’ll talk about how it pairs perfectly with WebAssembly components so we can build reliable systems to host our WASM code. We’ll illustrate this with an example of how we might use WebAssembly components to extend an Elixir system. No prior knowledge of Elixir will be assumed.

Wasm I/O 2025 - Barcelona, 27-28 March Slides: https://slides.com/vigoo/golem-cloud-powered-by-webassembly?token=xiJvdSrC This talk explores how we leveraged WebAssembly and the Component Model to build Golem Cloud, a durable execution platform that abstracts away distributed systems complexity. We’ll examine the technical implementation details of how Golem’s features are enabled by WebAssembly - from module composition to interface types and resource management. The session will demonstrate how different parts of the WASM ecosystem work together in production infrastructure, and explore how emerging specifications will unlock new possibilities for the future of cloud computing.

Wasm I/O 2025 - Barcelona, 27-28 March Slides: https://slides.com/hwclass/wasmio25-the-silent-sentinel-rust-powered-wasm-for-lightning-fast-bot-detection-at-the-edge/ In the ever-evolving landscape of web security, the battle against bots has traditionally relied on server-side detection mechanisms, often resulting in latency and increased server load. This presentation introduces a groundbreaking approach to bot detection that leverages the power of WebAssembly (WASM) and Rust to create a silent sentinel operating directly within the user’s browser. This innovative solution compiles complex bot detection algorithms written in Rust into a compact WASM module, which is seamlessly integrated into web applications. This “Silent Sentinel” operates autonomously at the edge, analyzing user behavior and identifying potential bot activities in real-time, without the need for client-server communication. Key aspects of this presentation include: -The architecture of our Rust-based bot detection algorithms and their compilation to WASM. -Performance benchmarks demonstrating the lightning-fast detection capabilities compared to traditional server-side methods. -Implementation strategies for integrating the WASM module into various web frameworks. Real-world case studies showcasing the effectiveness of edge-based bot detection. -Security considerations and potential future enhancements of the system. By shifting bot detection to the client-side through WASM, we not only achieve unprecedented speed but also significantly reduce server load and network latency. This approach represents a paradigm shift in web security, offering a more responsive, efficient, and scalable solution to the persistent challenge of bot detection. Join me to explore how this silent sentinel, powered by Rust and WASM, is reshaping the landscape of web security and paving the way for a new generation of edge-based defense mechanisms.

Wasm I/O 2025 - Barcelona, 27-28 March Slides: https://docs.google.com/presentation/d/12Vm1aMamOL8m5DaSVEdPZrdLBAGL3HLu1q9uUm0XL48 The talk will summarize where we are with the release of 0.3.0 in our support for async-style concurrency and then describe the emerging plan to also support thread-style concurrency layered on the Core WebAssembly shared-everything-threads proposal. While the high-level goals around supporting pthreads, goroutines, workers and other languages’ built-in threading concepts are clear, there are some interesting interactions to consider in the context of the Component Model concerning non-threaded code, structured concurrency and parallelism. This talk will discuss the plan for these interactions and how ultimately these different styles of concurrency can compose, particularly in multi-component, multi-language scenarios.