• fitzgen

    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.

  • ericgregory

    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.

  • yoshuawuyts

    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 1. 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.

    1. WebAssembly Components are an extension to WebAssembly to create strongly typed interfaces between different programs. WASI 0.2 is a re-work of the “WebAssembly System Interfaces” based on WebAssembly Components. The previous version of WASI was not based on components, and as a result was rather limited in what it could express. 

  • ericgregory

    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.

  • ericgregory

    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.

  • sunfishcode

    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.

  • bytecodealliance

    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.

  • ricochet

    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.

  • liamrandall

    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!

  • saulecabrera

    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.

  • peterhuene

    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!

  • ricochet

    Announcing Monthly Community Streams

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

  • abrown

    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.

  • jbourassa

    Using Wasmtime from Ruby

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

  • cfallin

    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.

  • linclark

    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.

  • fitzgen

    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.

  • cfallin

    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!

  • cfallin

    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.

  • linclark

    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.

  • bytecodealliance

    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.

  • tschneidereit

    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.

  • abrown

    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.

  • abrown

    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™.

  • linclark

    Bytecode Alliance: One year update

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

  • fitzgen

    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.

  • peterhuene

    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.

  • fitzgen

    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.

  • bytecodealliance

    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.

  • linclark

    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.