Making WebAssembly and Wasmtime More Portable

Portability is among the first properties promoted on WebAssembly’s official homepage:

Wasmtime 27.0: Complete Wasm GC support, PyTorch backend, and more

This month’s v27.0 release of Wasmtime—the fast, secure, and standards-compliant WebAssembly (Wasm) runtime—includes enhancements such as completed support for the new Wasm garbage collection proposal, a PyTorch backend for wasi-nn, link-time feature gate configuration for unstable WIT APIs, and more.

Wasmtime 26.0: 64-bit tables, shell completions, Windows ARM64 support, and more

Wasmtime is a fast, secure, and standards-compliant WebAssembly runtime. The latest v26.0 release includes enhancements such as implementation of the “table64” extension, a new wasmtime completion subcommand, ARM64 Windows support, and more.

Wasmtime v25.0 brings extended constants, WASI 0.2.1, user stack maps, and more

Wasmtime is a lightweight WebAssembly runtime that is fast, secure, and standards-compliant. Today’s release of Wasmtime v25.0 brings enhancements including extended constants, WASI 0.2.1 support, and user stack maps.

New Stack Maps for Wasmtime and Cranelift

As part of implementing the WebAssembly garbage collection proposal in Wasmtime, which is an ongoing process, we’ve overhauled the stack map infrastructure in Cranelift. This post will explain what stack maps are, why we needed to change them, and how the new stack maps work.

Our Next Plumbers Summit event - September 26 & 27, 2024

The Bytecode Alliance is pleased to invite you to the next installment in our ongoing Plumbers Summit event series, each designed to bring our members and community contributors together to help set strategic direction and plan efforts for the coming year. Our next Summit will be September 26 and 27, 2024 at the Microsoft Visitor Center in Redmond, Washington. Seating for the in-person session is limited but the event will be live streamed online to support full remote participation.

Simplifying components for .NET/C# developers with componentize-dotnet

If you’re a .NET/C# developer, componentize-dotnet makes it easy to compile your code to WebAssembly components using a single tool. This Bytecode Alliance project is a NuGet package that can be used to create a fully AOT-compiled component from a .NET application—giving .NET developers a component experience comparable to those in Rust and TinyGo.

Announcing WASI 0.2.1

Welcome to the Bytecode Alliance blog. The Bytecode Alliance is a nonprofit organization dedicated to creating secure new software foundations, building on standards such as WebAssembly and WebAssembly System Interface (WASI).

The XZ Backdoor and Wasmtime

We are aware that the account responsible for the recent XZ backdoor contributed a documentation-only pull request to Wasmtime, however Wasmtime’s safety remains intact. We have reviewed the pull request in detail and confirmed that it only modified a single markdown file, and contained no changes to source code, build systems, or binaries. Furthermore, the documentation was not altered in such a way that it could trick unsuspecting readers into sabotaging themselves.

February 2024 Community Stream

On February’s community stream, Bytecode Alliance Technical Steering Committee Director Bailey Hayes and Consulting Executive Director David Bryant provided updates on individual projects, SIGs, and direction for the ecosystem.

Announcing Jco 1.0

We’re happy to announce the 1.0 release of Jco: a native Javascript WebAssembly toolchain and runtime built for WebAssembly Components and WASI 0.2 ¹. Jco can natively run Wasm Components inside of Node.js, making it easy to take libraries written in different programming languages and execute them using the Node.js runtime. And by implementing the entirety of the WASI 0.2 API surface, those components can access the network, filesystem, and other system APIs available in the Node.js runtime.

Plumber’s Summit Day 2: Async, DevEx, and the road ahead

Last week, the Bytecode Alliance Plumber’s Summit gathered in Raleigh, NC to map the road ahead for the WebAssembly ecosystem.

You can read a summary of the summit’s first day on the Bytecode Alliance blog or watch the full recording on YouTube. While much of the second day was conducted in breakout sessions, some consistent themes ran through many of those conversations, including the implementation of async and developer experience.

Plumber’s Summit Day 1: Wasmtime and plugins, WASI 0.2.1, OCI artifacts and registry roadmap

The Bytecode Alliance Plumber’s Summit gathered in Raleigh, NC on January 31, 2024 to celebrate the release of WASI 0.2 and collaborate on the next steps forward for the WebAssembly ecosystem.

The first day of the two-day summit focused on topics of general interest, while the second day adopted an “unconference” structure with more narrowly focused breakout sessions.

WASI 0.2 Launched

The WASI Subgroup voted on January 25, 2024 to launch WASI 0.2, also known as WASI Preview 2, or WASIp2! This blog post is a brief look at the present, past, and future of WASI, and a repost of an original article shared here.

Wasmtime and Cranelift in 2023

It’s that time of year: time to start winding down for the winter holiday season, time to reflect on the past year, and time to think about what we can accomplish together in 2024. The Wasmtime and Cranelift projects are no exception. This article recounts Wasmtime and Cranelift progress in 2023 and explores what we might do in 2024.

WebAssembly: An Updated Roadmap for Developers

The WebAssembly (Wasm) ecosystem is transforming. Developers can look forward to a modular, virtualizable, and robust environment for building applications, libraries, and services.

We are excited to be working towards this with implementations for WASI-Preview 2. This roadmap reflects changes occurring in standards within the WebAssembly Community Group (CG) and the WASI Subgroup within the W3C. This includes WebAssembly Core, WebAssembly Component Model, WASI (WebAssembly System Interface), and a number of WASI-based interfaces. This is a big update, and we are excited about the new capabilities on the way.

Announcing: Componentize the World Hackathon - Sept 8 in Redmond, WA

The Bytecode Alliance is pleased to invite you to our upcoming event, “Componentize the World”, a comprehensive Hackathon taking place in Redmond, Washington on Friday, September 8, 2023 at the Microsoft Executive Briefing Center (Building 33). This WebAssembly hackathon is being held adjacent to the first annual Linux Foundation WasmCon, on September 6 and 7th in Bellevue, Washington .

Register for the Bytecode Alliance WebAssembly Hackathon- Componentize the World now!

Welcoming Javy: A new hosted project

We’re happy to announce the inclusion of Javy as a hosted project under the Bytecode Alliance. This post will delve into what Javy is, the motivation behind its adoption, and the process that led to its integration into the Bytecode Alliance.

Component Model Tooling Compatibility

Here at the Bytecode Alliance, we are very excited about the potential of the WebAssembly Component Model proposal and we understand that many of you are actively exploring ways to build solutions that use WebAssembly components as well!

Announcing Monthly Community Streams

I am happy to announce that the Bytecode Alliance now hosts a community stream the last Tuesday of every month.

Announcing wasi-threads

Until now, one piece missing from WebAssembly standalone engines was the ability to spawn threads. Browsers have had this ability for some time via Web Workers, but standalone engines had no standard way to do this. This post describes the work of several collaborators to bring about wasi-threads, a proposal to add threads to WASI. It will explain the history to this proposal, the work done to get to this point, and how one can experiment with threaded applications in engines like Wasmtime and WAMR. To showcase this, we’ll look at how performing parallel compression with wasi-threads drastically improves performance.

Using Wasmtime from Ruby

We’re happy to announce the release of the wasmtime Ruby gem, the official embedding of Wasmtime for Ruby.

Cranelift Progress in 2022

Continuing the tradition of a year-end progress report from last year, we are excited to report that this year has also been quite a productive one for the Cranelift project! Cranelift is our optimizing compiler backend that provides the foundation for Wasmtime, a production-ready WebAssembly virtual machine, the rustc_codegen_cranelift backend for the Rust compiler, and a number of other applications.

Wasmtime Reaches 1.0: Fast, Safe and Production Ready!

As of today, the Wasmtime WebAssembly runtime is now at 1.0! This means that all of us in the Bytecode Alliance agree that it is fully ready to use in production.

Security and Correctness in Wasmtime

The essence of software engineering is making trade-offs, and sometimes engineers even trade away security for other priorities. When it comes to running untrusted code from unknown sources, however, exceptionally strong security is simply the bar to clear for serious participation: consider the extraordinary efforts that Web browser and hypervisor maintainers take to preserve their systems’ integrity. WebAssembly runtimes also run untrusted code from untrusted sources, and therefore such efforts are also a hard requirement for WebAssembly runtimes.

Wasmtime 1.0: A Look at Performance

In preparation for our upcoming release of Wasmtime 1.0 on September 20, we have prepared two blog posts describing the work we have put into the compiler and runtime recently. This first post will describe performance-related projects: making the compiler generate faster code, making the compiler itself run faster, making Wasmtime instantiate a compiled module faster, and making Wasmtime’s runtime as efficient as possible once the module is running. Our subsequent post will describe the work we have done to ensure that Wasmtime is secure and that the compiler generates correct code. We’re excited to present all of our work in both of these directions!

Cranelift Progress Report: A Look Back at 2021

The past year has been a productive one for the Cranelift project! Cranelift is the Bytecode Alliance’s native code compiler that serves as the foundation for the Wasmtime and Lucet WebAssembly virtual machines, and is used in other contexts as well, e.g. as an alternative backend for the Rust compiler.

Making JavaScript run fast on WebAssembly

JavaScript in the browser runs many times faster than it did two decades ago. And that happened because the browser vendors spent that time working on intensive performance optimizations.

The Bytecode Alliance Calls for New Members In Mission to Build Safer Software Foundations for the Internet

SAN FRANCISCO — April 28, 2021 — The Bytecode Alliance, a community dedicated to creating new software foundations, building on standards such as WebAssembly and WebAssembly System Interface (WASI), today announced incorporation as a 501(c)(6) non-profit organization. Incorporated by Fastly, Intel, Mozilla and Microsoft, the Bytecode Alliance now invites organizations to join its cross-industry collaborative mission alongside new members Arm, DFINITY Foundation, Embark Studios, Google, Shopify, and University of California at San Diego.

As WebAssembly grows in popularity, the Bytecode Alliance opens to new members

The Bytecode Alliance has always set sights high on a goal of introducing new foundations for building software. Today, our work toward this goal is entering a new phase: we’re happy to announce the incorporation of the Bytecode Alliance as a 501(c)(6) nonprofit organization and that we are opening up membership broadly. Starting with Arm, DFINITY Foundation, Embark Studios, Google, Shopify, and University of California at San Diego, we’re excited to welcome new collaborators and truly work together on a cross-industry effort to establish the right foundations for building secure and fast software at scale.

Implementing a WASI Proposal in Wasmtime: wasi-nn

In a previous post, Machine Learning in WebAssembly: Using wasi-nn in Wasmtime, we described the wasi-nn specification and a user-level view of its usage in Wasmtime. In this post, we dive into the details of implementing the proposal using wasi-nn as an example. If you are interested in designing new WASI specifications and making them work–especially in the Wasmtime engine–you may find this post useful.

Machine Learning in WebAssembly: Using wasi-nn in Wasmtime

The wasi-nn proposal allows WebAssembly programs to access host-provided machine learning (ML) functions. This post will explain the motivation for wasi-nn, a brief look at the specification, and how to use it in Wasmtime to do machine learning inference. You may find this post interesting if you want to execute ML inference in a standalone WebAssembly runtime (i.e. not in a browser) or if you would like to understand the process for implementing new WASI specifications. In a follow-on post, Implementing a WASI proposal in Wasmtime, I explain how I implemented the wasi-nn proposal in Wasmtime using OpenVINO™.

Bytecode Alliance: One year update

We announced the Bytecode Alliance nearly a year ago, and since then it has been… quite a year 😬

WebAssembly Reference Types in Wasmtime

A few week ago, I finished implementing support for the WebAssembly reference types proposal in Wasmtime. Wasmtime is a standalone, outside-the-Web WebAssembly runtime, and the reference types proposal is WebAssembly’s first foray beyond simple integers and floating point numbers, into the exciting world of garbage-collected references. This article will explain what the reference types proposal enables, what it leaves for future proposals, and how it is implemented in Wasmtime.

Using WebAssembly from .NET with Wasmtime

Wasmtime, the WebAssembly runtime from the Bytecode Alliance, recently added an early preview of an API for .NET Core, Microsoft’s free, open-source, and cross-platform application runtime. This API enables developers to programmatically load and execute WebAssembly code directly from their .NET programs.

Multi-Value All The Wasm!

Multi-value is a proposed extension to core WebAssembly that enables functions to return many values, among other things. It is also a pre-requisite for Wasm interface types.

New Bytecode Alliance Brings the Security, Ubiquity, and Interoperability of the Web to the World of Pervasive Computing

MOUNTAIN VIEW, California November 12, 2019 – The Bytecode Alliance is a newly-formed open source community dedicated to creating new software foundations, building on standards such as WebAssembly and WebAssembly System Interface (WASI). Mozilla, Fastly, Intel, and Red Hat are founding members.

Announcing the Bytecode Alliance: Building a secure by default, composable future for WebAssembly

Today we announce the formation of the Bytecode Alliance, a new industry partnership coming together to forge WebAssembly’s outside-the-browser future by collaborating on implementing standards and proposing new ones. Our founding members are Mozilla, Fastly, Intel, and Red Hat, and we’re looking forward to welcoming many more.