wasmerio/wasmer

This system is a WebAssembly runtime engine that provides a unified API for executing modules across multiple backends, including native compilers (Cranelift, LLVM, Singlepass) and JavaScript engines (V8, JS). It supports advanced WebAssembly features such as exception handling, reference types, shared memory, and asynchronous execution, while offering comprehensive tooling for package management, deployment, and performance benchmarking.

54 changes.

This period focused on the foundational rewrite of the Wasmer v4 runtime, featuring complete rewrites of the Cranelift and Singlepass compilers and the introduction of a new modular compiler middleware architecture. It also established the official WebAssembly C API, expanded support for V8 and WebAssembly exception handling, and restructured the CLI for better deployment management.

67 changes.

This period focused on expanding the WASIX runtime with comprehensive networking, threading, and dynamic linking capabilities, alongside a major refactoring of the engine and compiler infrastructure for better modularity and performance. Significant work was also dedicated to introducing a robust package management system in the CLI and enhancing the C API with unstable extensions for middleware and parser introspection.

54 changes.

The project introduced a multi-backend API architecture supporting sys, V8, and JS runtimes, enabling asynchronous execution and shared memory across diverse environments. Concurrently, the CLI was significantly expanded with new commands for managing namespaces, domains, secrets, volumes, and network interfaces, alongside a new journaling system for WASM state snapshots.

37 changes.

This period focused on implementing comprehensive WebAssembly exception handling, including DWARF-based unwinding, Tag, and ExternRef support across the VM and all major backends (sys, V8, JS). It also involved restructuring backend selection logic, introducing experimental async execution and host interrupts, and expanding the SDK with new deployment and package management tools.

Users can now manage the CDN cache for their Edge apps directly from the CLI. New subcommands under \wasmer app cdn\ allow enabling or disabling the cache (\enable\, \disable\), checking its current status and metrics (\status\), and clearing cached content (\purge\). These commands interact with the backend API to configure and query CDN cache settings for a specific app.

lib/cli/src/commands/app · high confidence

Users can now run \wasmer app regions list\ to view a table of available Edge regions, displaying the region name, city, and country code. This new subcommand queries the backend API for region data and renders it using the \comfy-table\ library, supporting standard CLI options for output formatting and quiet mode.

lib/cli/src/commands/app/regions · high confidence

The CLI now includes a new \namespace\ command group with subcommands to create, get, and list namespaces. Users can create namespaces with optional display names and descriptions (supporting interactive prompts or non-interactive flags), retrieve specific namespace details by name, and list all available namespaces. These commands utilize the \wasmer\_backend\_api\ for backend interactions and support configurable output formatting.

lib/cli/src/commands/namespace · high confidence

The VM now includes a new implementation for parsing GCC-style Language-Specific Data Areas (LSDA) and DWARF Call Frame Information to resolve exception actions on Unix-like systems. This change introduces the \lib/vm/src/libcalls/eh/dwarf\ module, containing a \DwarfReader\ for decoding packed DWARF data streams and an \eh\ module that implements the personality function logic to identify landing pads and catch handlers. This enables proper exception unwinding and handling for targets using the Itanium C++ ABI (such as x86\_64-pc-windows-gnu and Linux), replacing or supplementing previous mechanisms.

lib/vm/src/libcalls/eh/dwarf · high confidence

The VM now implements a two-stage personality function and unwinding logic for Unix-like and GNU-Windows targets, enabling proper matching of WASM exception tags against catch clauses by leveraging the VMContext. This change introduces the \gcc\ module with \wasmer\_eh\_personality\ and \wasmer\_eh\_personality2\ to handle stack unwinding and tag resolution, while stubbing out these functions with panics for MSVC and WASM targets to maintain build compatibility.

lib/vm/src/libcalls/eh · high confidence

Users can now derive the \ValueType\ trait for structs marked with \\#\[repr(C)\]\ or \\#\[repr(transparent)\]\. The generated implementation automatically zeroes out padding bytes within the struct and between its fields, ensuring safe and consistent memory representation for Wasm interoperability.

lib/derive/src · high confidence

This change introduces a new library (lib/c-api-imports) that enables WebAssembly modules to import and use the Wasm C API (specifically version 0) via host-provided functions. It handles the detection of the 'wasm\_c\_api\_v0' import namespace, validates version compatibility, and automatically registers the necessary host-side implementations for C API functions. Additionally, it integrates with the WASIX runtime by implementing instantiation hooks to ensure that imported memories and indirect function tables are correctly prepared and configured during module instantiation, allowing seamless interaction between WASIX environments and C API-based WebAssembly modules.

lib/c-api-imports · high confidence

Introduces a new \Metering\ middleware that tracks the number of WebAssembly operators executed and enforces a configurable limit on total execution cost. Users can define a custom cost function to assign points to specific operators and set an initial point limit; if the limit is exhausted, execution is stopped. The middleware exposes global variables (\wasmer\_metering\_remaining\_points\ and a boolean for exhaustion) to allow inspection of remaining points and recovery from exhausted states.

lib/middlewares/src · high confidence

The \benches/\ directory now includes a comprehensive set of benchmarks to measure Wasmer's performance across key operations. The new suite covers module compilation (using remote artifacts for small, medium, and large workloads), module deserialization (rkyv), runtime execution of various algorithms, and the performance of function imports and static/dynamic function calls. These benchmarks allow users to track performance regressions or improvements in compilation speed, instantiation, and execution latency across different backends like Cranelift, LLVM, and Singlepass.

benches · high confidence

The repository now includes configuration files for code formatting (\.clang-format\), Git attributes (\.gitattributes\), and typo checking (\.typos.toml\), along with a new \AGENTS.md\ guide for AI agents contributing to the project. Additionally, Git submodules for the WebAssembly spec tests, N-API bindings, and test files have been initialized.

(repo-wide) · high confidence

This change introduces the internal utility layer for the new \wasmer app secret\ subcommand. The \utils\ module provides functions to read secrets from \.env\ files, retrieve and resolve app identifiers (supporting both explicit flags and interactive prompts), and fetch secret values from the backend via the \wasmer\_backend\_api\. Additionally, it implements table rendering for CLI output, displaying secret names and sanitized values, as well as metadata like last-updated timestamps for backend secrets.

lib/cli/src/commands/app/secrets/utils · high confidence

The API now includes new \Tag\ and \ExternRef\ types, allowing users to handle WebAssembly exceptions and pass opaque references through Wasm code. The \Extern\ enum has been extended to include \Tag\, enabling the import and export of exception handlers alongside functions, globals, memories, and tables. \ExternRef\ provides a mechanism to wrap and downcast arbitrary Rust values into Wasm-compatible references, with backend-specific implementations for Sys, V8, and JS runtimes.

lib/api/src/entities/external · high confidence

The API now exposes the \Exception\ entity, allowing users to create WebAssembly exceptions with specific tags and payloads, and to inspect those exceptions by retrieving their tag and payload values. This change introduces the necessary runtime types and backend abstractions to handle exception objects within the store, enabling the throwing and catching of exceptions in WebAssembly modules.

lib/api/src/entities/exception · high confidence

The Cranelift compiler backend now includes generated trampolines to facilitate calling dynamic host functions and invoking WebAssembly functions from host code. This change introduces \make\_trampoline\_dynamic\_function\ for bridging Wasm to dynamic host calls and \make\_trampoline\_function\_call\ for standard Wasm function invocations, handling argument marshaling, stack slot management, and return value unpacking via the ABI layer.

lib/compiler-cranelift/src/trampoline · high confidence

The JS backend now includes new utility modules to handle the conversion of Wasmer values to and from JavaScript values (including support for ExternRefs) and to enforce thread-safety integrity checks on JavaScript objects during debug builds. These changes ensure that data passed between the WebAssembly instance and the JavaScript environment is correctly marshaled and that cross-thread access issues are caught early in development.

lib/api/src/backend/js/utils · high confidence

The CLI now includes a new \net\ module that provides TUN/TAP device creation and management. This allows the CLI to establish virtual network interfaces, connect to remote networking endpoints via WebSocket, and configure static IP addresses and routes on the host system, including automatic privilege escalation via sudo when necessary.

lib/cli/src/net · high confidence

The \lib/api\ crate now includes initial support for the V8 engine, enabled via the \v8\ feature flag. This introduces a build script that downloads, caches, and links prebuilt V8 artifacts (wee8) for supported platforms (macOS, Linux, Windows, Android), handling symbol renaming to avoid collisions with Wasmer's own exports. The crate's README has been updated to reflect these capabilities and provide usage examples.

lib/api · high confidence

The V8 backend now includes a new \convert\ module that handles the translation of values and types between the V8 engine and Wasmer. This addition enables the runtime to correctly map primitive types (such as I32, I64, F32, F64, V128) and function references during interop, while explicitly panicking for unsupported types like ExternRefs and ExceptionRefs to prevent undefined behavior.

lib/api/src/backend/v8/utils · high confidence

The WASIX library now includes a new \console\ module that provides the infrastructure for an interactive terminal experience. This adds a \Console\ struct for managing the interactive runtime loop, along with a \cconst\ module defining terminal control sequences (cursor movement, colors, screen clearing) and key codes. The console also bundles static welcome, help, and about text resources, enabling users to run interactive WASI applications with a familiar command-line interface.

lib/wasix/src/os/console · high confidence

The Cranelift compiler debug module now includes an address map module that defines data structures for transforming WebAssembly source addresses into native code locations. This introduces types for managing value labels ranges and stack slots per local function, as well as structures to track VM context information such as memory offsets (defined vs. imported) and stack slot allocations.

lib/compiler-cranelift/src/debug · high confidence

A new \interrupt\_registry\ module has been added to the VM library to enable embedding applications to interrupt long-running WebAssembly computations. On Unix systems, this is implemented using OS signals (SIGUSR1) and atomic state tracking to safely interrupt specific stores from other threads, while non-Unix platforms receive no-op stubs to maintain API compatibility. The module exposes an \InterruptInstallGuard\ that automatically cleans up interrupt state when dropped, allowing embedders to safely pause or stop WASM execution without blocking the main thread.

_lib/vm/src/interrupt\registry · high confidence

The WASIX runtime now exposes an \InstantiationHook\ trait and \InstantiationState\ mechanism, allowing users to inject custom logic during the creation of module instances. This enables the addition of custom imports and post-instantiation configuration for processes, threads, and dynamically linked side modules, while ensuring thread-safety for concurrent instantiations.

lib/wasix/src/runtime · high confidence

The JavaScript VM backend now supports WebAssembly tags and ExternRefs. This is implemented by adding new VM types (VMTag, VMExternRef) and updating the VMExtern enum to include Tag exports, enabling the backend to handle exception handling features and object references in WebAssembly modules running in JavaScript environments.

lib/api/src/backend/js/vm · high confidence

A new Rust-based runner tool has been added to automate the building and execution of C API examples. It automatically locates the Wasmer root directory, triggers the necessary build steps (make build-capi and make package-capi) if the package directory is missing, and then iterates through a defined set of C test cases (such as instance, memory, and wasi) to verify the C API functionality across different platforms.

lib/c-api/examples/wasmer-capi-examples-runner · high confidence

The login command now supports an interactive browser-based authentication flow. When running \wasmer login\, the CLI starts a local server to receive the authentication token from the browser, eliminating the need to manually copy-paste tokens. If the browser fails to open or the user prefers, the command falls back to prompting for a token via the command line or using the \WASMER\_TOKEN\ environment variable.

lib/cli/src/commands/auth/login · high confidence

The wasix command subsystem now includes a built-in \wasmer\ command that allows users to execute WebAssembly files (.wasm, .wat) and WebC packages directly. This new capability, implemented in \cmd\_wasmer.rs\, enables the runtime to spawn and manage these workloads as subprocesses, handling argument passing, environment setup, and output redirection for both standard WASM modules and packaged WebC binaries.

lib/wasix/src/os/command/builtins · high confidence

The Cranelift compiler backend has been completely rewritten to support the Wasmer v4 architecture. This change introduces a new module structure with dedicated files for ABI lowering, address mapping, configuration, DWARF exception handling, ELF object emission, and heap management. The compiler now supports parallel compilation, experimental artifact formats, and improved exception handling with DWARF/LSDA generation. The backend is no longer supported on Windows and requires Rust 2024 Edition.

lib/compiler-cranelift/src · high confidence

The journaling system in lib/wasix now captures and replays a significantly broader range of WASI syscalls, including file descriptor operations (close, duplicate, renumber, seek, write, and flag/rights configuration), file and directory management (create, remove, rename, link, symlink, open), network socket lifecycle events (bind, connect, accept, listen), and network port configuration (DHCP, routing, address management). This ensures that snapshots and journal replays can accurately restore complex application states involving file I/O, directory structures, and network connectivity.

lib/wasix/src/journal/effector/syscalls · high confidence

The sys backend now includes an experimental async execution API that allows WebAssembly functions to be called asynchronously, enabling non-blocking execution and concurrent handling of host futures. This change introduces a new \async\_runtime\ module that manages coroutine-based execution and integrates with the store's async context. Additionally, the backend supports experimental host interrupts, allowing running computations to be interrupted via a registry mechanism, which returns a specific host interrupt trap when triggered. These features are gated behind feature flags (\experimental-async\ and \experimental-host-interrupt\) and are part of the broader effort to modernize the sys backend's execution model.

lib/api/src/backend/sys · high confidence

The C API now exposes the internal WebAssembly parser operators through the \wasmer\_parser\_operator\_t\ enum, allowing C consumers to inspect and handle specific WebAssembly bytecode instructions (such as \I32Add\, \Call\, \Block\, etc.) during parsing. This change introduces a new module \lib/c-api/src/wasm\_c\_api/unstable/parser\ containing the operator definitions, which are derived from the \wasmer\_api::wasmparser\ crate, enabling finer-grained control over the parsing process in C applications.

_lib/c-api/src/wasm\_c\api/unstable/parser · high confidence

The \HostFunction\ trait in the API layer has been refactored to dispatch to specific backend implementations based on the selected runtime. The new implementation in \lib/api/src/entities/function/host\ allows host functions to be compiled for various backends, including the existing sys-based backends (Headless, LLVM, Cranelift, Singlepass) and newly supported JavaScript engines (Js, V8). This enables users to leverage host functions in environments that rely on JavaScript or V8 runtimes, expanding the compatibility of WebAssembly modules beyond native code execution.

lib/api/src/entities/function/host · high confidence

Added the \compact\unwind\ module within the SystemV unwind engine, introducing \CompactUnwindEntry\ and \CompactUnwindManager\ to parse and manage \\\_compact\unwind\ section data. This change enables the runtime to register dynamic unwind information with libunwind via \\\_unw\_add\_find\_dynamic\_unwind\_sections\, allowing for more efficient stack unwinding on platforms that support this format.

lib/compiler/src/engine/unwind/systemv · high confidence

The \lib/c-api\ crate is introduced, exposing a C and C++ interface for the Wasmer WebAssembly runtime. This new API provides C-compatible bindings for error management, allowing C/C++ consumers to retrieve the last error message via \wasmer\_last\_error\_length\ and \wasmer\_last\_error\_message\, and includes a \wasmer\_setup\_tracing\ function to configure logging verbosity and output for Wasmer internals.

lib/c-api/src · high confidence

Added a new Rust-based Swift library that exposes a \run\_package\ function, allowing users to execute WebAssembly Component Model (WEBC) packages from Swift applications. The implementation uses UniFFI to generate Swift bindings, sets up a Tokio runtime for async execution, and leverages Wasmer's \PluggableRuntime\ and \WasiRunner\ to run the package's entrypoint command and capture its standard output.

lib/swift · high confidence

The V8 backend now includes concrete entity implementations for core WebAssembly components, including Engine, Module, Instance, Global, Table, Tag, and Exception. These files provide the V8-specific bindings and wrappers for managing the V8 engine lifecycle, instantiating modules, and handling WebAssembly globals, tables, and tags. Note that Exception and ExternRef entities are currently stubbed with unimplemented errors, indicating that exception handling and extern reference support are not yet available in this backend.

lib/api/src/backend/js/entities, lib/api/src/backend/v8/entities · high confidence

This release introduces the official WebAssembly C API for Wasmer, providing a standard C interface to compile, validate, and instantiate WebAssembly modules. The new API includes functions to manage the engine and store, create and delete modules, instantiate them with imports, and retrieve exports. It also supports WAT-to-WASM conversion, trap handling with null-terminated messages, and version introspection. The implementation is structured into dedicated modules for engine, store, module, instance, externals, values, traps, and utilities, with comprehensive inline C examples and documentation to guide integration.

_lib/c-api/src/wasm\_c\api · high confidence

This location introduces the initial version of the \wasmer-backend-api\ library, a GraphQL API client for the Wasmer backend built on the Cynic crate. The release includes the initial GraphQL schema, documentation, and a changelog documenting the migration from a legacy API implementation to the new Cynic-based client, along with fixes for log querying and the addition of methods for retrieving DeployApp/Version by unique ID.

lib/backend-api · high confidence

The \bin\_factory\ module now centralizes how WASIX locates and runs commands. It introduces \BinFactory\ to manage both built-in commands and local WebAssembly packages, supporting lazy loading of packages from disk and caching resolved binaries. The new \BinaryPackage\ struct tracks command ownership via \package\ and \origin\_package\ IDs, enabling correct resolution when a command is declared by one package but executes code from another. Execution is handled by refactored \spawn\_exec\ and \spawn\_exec\_wasm\ functions that import package mounts, resolve modules, and launch tasks, while \package\_command\_by\_name\ ensures backward compatibility by falling back to the entrypoint or single-command selection when no explicit command name is provided.

_lib/wasix/src/bin\factory · high confidence

Added the \wai-bindgen-wasmer\ crate, providing the runtime support layer for WebAssembly Interface Types (WAI) bindings with Wasmer. This includes a \GuestError\ enum for detailed error reporting, a \Le\ type for safe little-endian memory access, a \BorrowChecker\ for managing memory regions and pointer safety, and \Slab\/\Table\ structures for resource handle management.

lib/wai-bindgen-wasmer/src · high confidence

This change adds an unofficial WASI integration layer to the Wasm C API, exposing C-compatible functions to configure and manage WebAssembly System Interface environments. Users can now create WASI configurations via \wasi\_config\_new\, set environment variables and arguments, pre-open directories, and map host directories to guest paths. The API also provides control over standard I/O inheritance (stdin, stdout, stderr) and creates WASI environments (\wasi\_env\_new\) that integrate with the C API's store and instance models, enabling WASI-capable modules to be executed through the C interface.

_lib/c-api/src/wasm\_c\api/wasi · high confidence

Added new types in the wasix module to represent thread initialization and memory layout details. The \ThreadStartType\ enum distinguishes between main thread execution and spawned threads by storing the start pointer for the latter. The \WasiMemoryLayout\ struct defines the memory boundaries for a thread's stack (upper and lower limits), guard size, total stack size, and the base address for Thread Local Storage (TLS), providing necessary context for thread recreation and dynamic linking.

lib/wasi-types/src/wasix · high confidence

The CLI now includes a new \auth\ subcommand group containing \login\, \logout\, and \whoami\ commands. The \logout\ command allows users to log out of their current registry and optionally revoke their authentication token via a new \--revoke-token\ flag (or interactive prompt). Upon logout, the CLI automatically switches the active registry to the default production registry if no other tokens remain, or to the first available registry otherwise. The \whoami\ command displays the currently logged-in user and registry.

lib/cli/src/commands/auth · high confidence

Added a new \lib/compiler/src/object\ module that provides a dedicated API for creating object files from Wasm compilation results. This includes an \ObjectError\ type for handling unsupported binary formats, architectures, and serialization issues, along with functions to initialize object targets (\get\_object\_for\_target\), emit raw data (\emit\_data\), and write full compilation outputs with relocations and debug sections (\emit\_compilation\).

lib/compiler/src/object · high confidence

The in-memory file system implementation has been restructured into a modular architecture (file, file\_opener, filesystem, offloaded\_file, stdio) that introduces several new capabilities. Users can now mount external file systems into specific paths via \mount\ and \mount\_directory\_entries\, and recursively merge file systems using \union\. Large data sets can be handled efficiently by offloading file content to an mmap-backed store via \OffloadBackingStore\, reducing memory pressure. The file system also supports creating read-only files with copy-on-write semantics, referencing files from other file systems via \ArcFile\ and \ArcDirectory\ nodes, and resolving symbolic links through \SymlinkNode\. Standard I/O streams (stdin, stdout, stderr) are now emulated as virtual files with async read/write support.

_lib/virtual-fs/src/mem\fs · high confidence

The \lib/backend-api/src\ module has been restructured to provide a new, dedicated client library for interacting with the Wasmer backend API. This change introduces a new \WasmerClient\ that supports proxy configuration, configurable request timeouts, and optional GraphQL variable logging via the \WASMER\_API\_INSECURE\_LOG\_VARIABLES\ environment variable. The library implements type-safe GraphQL queries and mutations using the Cynic client, covering operations such as app volume management (including S3 credential rotation), app redeployment, token revocation, nonce creation, and package binding retrieval. It also adds support for paginated result streaming and WebSocket-based subscriptions for real-time updates on package version readiness and autobuild deployments.

lib/backend-api/src · high confidence

Added new \WasmPtr\, \WasmRef\, and \WasmSlice\ types in \lib/api/src/utils/mem\ that provide safe, bounds-checked access to WASM linear memory from host code. These utilities allow reading and writing values and slices without manual pointer arithmetic, automatically handling alignment checks and preventing out-of-bounds or overflow errors via the new \MemoryAccessError\ type.

lib/api/src/utils/mem · high confidence

This change adds the core \FunctionEnv\, \FunctionEnvMut\, and \Function\ types for the \sys\ backend runtime. Users can now create and manage host function environments that store state within the store, access mutable host data from within WebAssembly host functions, and invoke typed WebAssembly functions with proper store context management. The implementation includes support for experimental async execution and host interrupts, providing the foundational API for binding host functions to WebAssembly modules in the sys backend.

lib/api/src/backend/sys/entities/function · high confidence

The package system now uses a unified \WasmerPackageVolume\ trait to manage file contents, supporting both on-disk (\FsVolume\) and in-memory (\MemoryVolume\) representations. This change allows the package builder to handle metadata, assets, and symlinks through a consistent interface, enabling more flexible packaging workflows and better separation of concerns between volume access and package serialization.

lib/package/src/package/volume · high confidence

A new \wasmer-cache\ library is introduced, providing a generic \Cache\ trait and a concrete \FileSystemCache\ implementation to store and load compiled WebAssembly modules. This allows applications to persist compiled artifacts to disk, enabling faster startup times by skipping recompilation. The cache uses a 32-byte \Hash\ (backed by Blake3) as a key for storing and retrieving modules, and includes logic to automatically remove corrupted cache files upon deserialization failure.

lib/cache/src · high confidence

The WASIX runtime now includes a new \BuiltinPackageLoader\ implementation that manages package loading with a builder-style API. Users can configure an in-memory cache (enabled by default), a persistent filesystem cache directory, and HTTP authentication tokens mapped by hostname. The loader also supports configurable hash integrity validation modes (no validation, warn on mismatch, or fail on mismatch) and allows disabling the in-memory cache or swapping the HTTP client. This replaces the previous default behavior with a more flexible, configurable package loading mechanism.

_lib/wasix/src/runtime/package\loader · high confidence

The compiler now exposes an \ArtifactBuild\ type in the \artifact\_builders\ module, allowing WebAssembly modules to be compiled into a serializable artifact that can be instantiated later. This new abstraction decouples the compilation phase from instantiation, supporting features like module-level middleware errors and progress callbacks during the compilation process. Additionally, the module includes architecture-specific libcall trampoline generation for AArch64, x86\_64, RISC-V, and LoongArch64 to handle libcall relocations.

_lib/compiler/src/artifact\builders · high confidence

The WASI runtime now exposes a \Capabilities\ configuration structure that allows users to control specific runtime behaviors, particularly around threading and I/O polling. This includes settings for enabling or disabling asynchronous threading and deep sleep, limiting the maximum number of threads, capping the number of \poll\_oneoff\ subscriptions, and enabling an exponential CPU backoff mechanism when no run tokens are held. These capabilities can be initialized with defaults or merged/updated to fine-tune resource usage and execution models for WASI modules.

lib/wasix/src · high confidence

The virtual-net library now includes a complete remote networking architecture, adding a \RemoteNetworkingClient\ and \RemoteNetworkingServer\ that communicate over async I/O or WebSocket streams using configurable serialization formats (Bincode, JSON, MessagePack, CBOR). This enables bridging local network interfaces to remote endpoints. Additionally, a new \Ruleset\ module allows users to define inbound and outbound firewall rules (allow/deny) for IPv4, IPv6, and DNS traffic, which are enforced by the new \LocalNetworking\ host implementation.

lib/virtual-net · high confidence

The WASI subsystem now exposes the \platform\_clock\_res\_get\ and \platform\_clock\_time\_get\ syscalls, implementing the Snapshot 0 clock interface. These APIs allow workloads to query clock resolutions and retrieve current time values, with platform-specific implementations provided for WASM targets (using local time), Linux/FreeBSD/Android/macOS, and Windows (using \GetTickCount64\ and system time).

lib/wasix/src/syscalls · high confidence

The VM runtime now includes foundational support for the WebAssembly Exception Handling and Reference Types proposals. This change introduces new internal types to manage \VMExceptionObj\ and \VMExceptionRef\ for structured error handling, alongside \VMExternObj\ and \VMExternRef\ to allow WebAssembly code to hold opaque references to host data. Additionally, the \VMTag\ type is added to represent exception tags, and the \TableElement\ enum is extended to support \ExternRef\ in addition to \FuncRef\. These components are integrated into the \StoreObjects\ context and the \VMExtern\ export enum, enabling the VM to correctly allocate, track, and pass these new object types during execution.

lib/vm/src · high confidence

The API layer now supports instantiating WebAssembly modules using multiple backend runtimes—specifically \sys\, \v8\, and \js\—allowing users to choose the execution engine that best fits their environment. This change introduces new entity structures such as \BackendInstance\, \BackendTrap\, and \BackendStore\ to abstract the underlying runtime, while updating core types like \Value\ and \Instance\ to handle runtime-specific details like exception references and function calls. Users can now leverage the \imports!\ macro and \Instance::new\ to work with these backends, enabling more flexible deployment options across different JavaScript and native environments.

lib/api/src/entities · high confidence

The \sys\ runtime backend now includes a concrete \Store\ implementation that manages the WebAssembly engine and trap handlers, exposing conversion methods to integrate with the broader backend store abstraction. Additionally, an experimental host interrupt feature is available on Unix systems (behind the \experimental-host-interrupt\ feature flag), allowing embedders to interrupt running WebAssembly instances via the \Interrupter\ type, which also notifies pending async futures when interrupts occur.

lib/api/src/backend/sys/entities/store · high confidence

A new sys-utils library crate has been added to the project, exposing a memory module. This change establishes a dedicated location for system utility functions, specifically moving the fd\_memory functionality from the wasi crate to this new shared location.

lib/sys-utils/src · high confidence

The \lib/wasix/src/runners\ module has been introduced, establishing a new \WasiRunner\ component that supersedes previous execution logic. This change allows users to configure WASI execution with granular control over standard streams (stdin, stdout, stderr) via builder methods, and supports mounting arbitrary \FileSystem\ instances (not just host directories) at specific guest paths. It also introduces a \Runner\ trait for extensibility and handles mount conflict resolution behavior, providing a more robust foundation for running WebAssembly modules with complex filesystem requirements.

lib/wasix/src/runners · high confidence

The \lib/wasi-types\ crate has been introduced to centralize WASI and WASIX type definitions, replacing previous scattered implementations. This new module provides structured access to core WASI types (such as file descriptors, rights, and directory entries) and WASIX-specific types (including networking structures like IP addresses and hardware addresses, as well as asyncify support). Users benefit from a unified, well-organized type system that ensures correct memory layout and padding for WASI syscalls, supporting both standard WASI operations and extended WASIX features like networking and async execution.

lib/wasi-types/src · high confidence

The CLI has been reorganized into a modular command structure under \lib/cli/src/commands\, introducing several new capabilities and behavioral changes. Users can now manage package bindings with \wasmer add\ (supporting npm, yarn, pnpm, and pip), initialize projects with \wasmer init\ (migrating from Cargo.toml to \wasmer.toml\), and compile modules with \wasmer compile\. New management commands include \wasmer cache\ for cache directory operations, \wasmer config\ for centralized configuration (replacing legacy wapm config), and \wasmer cron\ for managing Edge app cron jobs. The \wasmer inspect\ command now provides detailed module introspection including Tags. System integration is enhanced via \wasmer binfmt\ for registering the Wasmer interpreter on Linux. Developer experience is improved with \wasmer gen-completions\ and \wasmer gen-manpage\ for shell autocompletion and documentation generation. The \wasmer connect\ command is currently disabled on non-Linux platforms. The \wasmer ssh\ command now supports app access and port mapping.

lib/cli/src/commands · high confidence

The \Module::new\_async\ function has been added to the API, allowing WebAssembly modules to be compiled asynchronously. This is particularly useful for JavaScript environments, where it leverages the host's asynchronous WebAssembly compilation API to avoid blocking the main thread and to support modules that browsers reject during synchronous compilation. For other backends, this function behaves equivalently to the existing synchronous \Module::new\ method.

lib/api/src/entities/module · high confidence

The API now allows calling WebAssembly functions using native types (such as i32, i64, f32, f64, and extern refs) via the \TypedFunction\ helper, which handles conversion between native values and the WebAssembly ABI. This implementation supports the \sys\, \v8\, and \js\ backends, enabling direct, typed interactions with Wasm functions without manual serialization. Additionally, asynchronous execution is supported for the \sys\ and \js\ backends, while the \v8\ backend explicitly returns an error for async calls.

lib/api/src/utils/native · high confidence

The \lib/c-api/examples\ directory now includes a complete set of C source files demonstrating the Wasmer C API, covering core capabilities such as module instantiation, function and global exports, memory management, multi-value features, host imports, early exits with traps, and WASI execution. To support these examples, a new Makefile has been added to handle compilation and linking against the Wasmer library (including MSVC support), alongside a \.gitignore\ to manage build artifacts and a \wasmer-capi-examples-runner\ Cargo project to execute the compiled binaries as integration tests.

lib/c-api/examples · high confidence

The C API now exposes a dedicated \externals\ module that implements the core WebAssembly external types—functions, globals, memories, and tables—via new Rust source files. This adds (or replaces) the C bindings for creating, copying, querying, and manipulating these objects, including null-pointer safety, type introspection, and memory access. Users can now interact with these externals through the updated C API surface.

_lib/c-api/src/wasm\_c\api/externals · high confidence

The CLI now includes new subcommands for managing edge applications: \wasmer app deployments\ (list, get, logs), \wasmer app version\ (list, get, activate), \wasmer app database list\, and \wasmer app cronjob\ support. These commands interact with the backend API to provide visibility into and control over application lifecycle, including viewing deployment logs, switching active versions, listing databases, and managing scheduled tasks.

lib/cli/src · high confidence

The CLI now includes a new \wasmer app volume\ command group with subcommands to list volumes (\list\), manage S3 credentials (\credentials\), rotate secrets (\rotate-secrets\), and enable or disable S3 endpoints for volumes (\enable-s3\). This allows users to view volume details, retrieve and rotate per-volume S3 credentials, and toggle S3 integration on specific or all app volumes.

lib/cli/src/commands/app/volumes · high confidence

The CLI now includes a \domain\ subcommand group that allows users to register new domains, list existing ones, retrieve specific domain details, and manage DNS zone files. Users can fetch zone files to local storage or sync local zone file changes back to the backend, with options to control whether missing records are deleted during synchronization.

lib/cli/src/commands/domain · high confidence

The CLI now includes a new \journal\ subcommand with six operations for managing journal files: \compact\ to reduce file size by removing redundant events, \export\ to print journal contents as JSON to stdout, \import\ to add events from JSON input on stdin, \inspect\ to display a summary of journal contents, \filter\ to create a new journal excluding specific event types (memory, threads, file system, core, snapshots, or networking), and \extract\ to apply journal changes to a memory file.

lib/cli/src/commands/journal · high confidence

The CLI now includes a new package wizard (lib/cli/src/utils/package\_wizard) that scaffolds new applications using built-in templates. Users can create projects for static websites, JavaScript workers, and Python applications, with the wizard handling directory creation, manifest generation, and file population from the new template set.

_lib/cli/src/utils/package\wizard · high confidence

The \wasmer-sdk\ library now exposes a new \app\ module that provides tooling for deploying applications to Wasmer Edge. This includes \deploy.rs\, which implements a local deployment flow that publishes a package and waits for the app to become reachable, and \deploy\_remote\_build.rs\, which implements a remote autobuild flow that zips the project directory, uploads it to R2, and triggers a backend build. The module also defines specific error types (\DeployError\, \DeployRemoteError\) and progress event enums to allow users to track deployment status.

lib/sdk/src/app · high confidence

The SDK now includes dedicated modules for managing Wasmer packages. The \publish\ module provides functionality to publish packages to the registry, supporting configurable wait states for container, native executable, and binding availability, along with progress reporting. The \search\ module enables querying the Wasmer registry for packages with support for filtering, sorting, and pagination. These changes introduce new capabilities for interacting with the package ecosystem directly from the SDK.

lib/sdk/src/package · high confidence

This change introduces the \lib/wasix/src/net\ module, establishing the core infrastructure for network operations in WASIX. It provides utilities for reading and writing IP addresses (IPv4/IPv6) and CIDR prefixes from WASI memory, and implements a robust socket abstraction layer (\socket.rs\) that supports TCP listeners, TCP streams, UDP sockets, ICMP, and raw sockets. The implementation includes detailed socket property management (timeouts, buffer sizes, reuse options), status tracking, and integration with the virtual networking backend, enabling guest modules to perform standard socket operations.

lib/wasix/src/net · high confidence

This change introduces a suite of new syscalls in the WASIX syscall layer to support advanced runtime features. It adds dynamic linking capabilities via \dlopen\, \dlsym\, and \dl\_invalid\_handle\, allowing modules to load and resolve symbols at runtime. It also implements a closure system (\closure\_allocate\, \closure\_free\, \closure\_prepare\) for generating and managing WASM function wrappers, and a context-switching API (\context\_create\, \context\_destroy\, \context\_switch\) for managing suspended and resumed execution contexts. Additionally, it includes \call\_dynamic\ for invoking functions via the indirect function table with memory-based parameters, and \callback\_signal\ for registering signal handlers.

lib/wasix/src/syscalls/wasix · high confidence

A new \secrets\ subcommand has been added to the \wasmer app\ CLI, providing a complete set of tools to manage application secrets. Users can now create, update, delete, list, and reveal secrets directly from the command line. The commands support importing and exporting secrets in \env\, \json\, and \yaml\ formats via the \--from-file\ and \--output\ flags, and include an optional \--redeploy\ flag to automatically redeploy the app after secret changes are applied.

lib/cli/src/commands/app/secrets · high confidence

The virtual-io library now includes a new Selector component that manages asynchronous I/O events using the mio crate, replacing previous polling mechanisms. This change introduces a robust waker system (lib/virtual-io/src/waker.rs) that allows Rust futures to block on I/O readiness, and a new InterestHandler architecture (lib/virtual-io/src/interest.rs) to manage read/write/closed/error events. The Selector (lib/virtual-io/src/selector.rs) handles event registration, deregistration, and interest updates via a thread-safe queue, ensuring that I/O events are correctly propagated to waiting tasks. This provides a more reliable and efficient way to handle network and file I/O in asynchronous contexts.

lib/virtual-io · high confidence

The \lib/compiler/src\ directory now contains the core \wasmer-compiler\ crate, introducing a structured compiler API with \Compiler\ and \CompilerConfig\ traits, alongside new modules for return-value ABI classification (\abi.rs\), ELF relocatable object emission and linking (\elf.rs\), and DWARF \.eh\_frame\ unwind table generation (\dwarf.rs\). This change adds support for serializing compiled modules into native ELF artifacts (in addition to the existing rkyv format) and provides progress reporting hooks for compilation phases, enabling better debugging, deterministic artifact generation, and integration with native toolchains.

lib/compiler/src · high confidence

The \lib/api/macro-wasmer-engine-test\ crate introduces the \engine\_test\ procedural macro attribute. When applied to a test function, this macro generates conditional test variants: a JavaScript-specific test (guarded by the \js\ feature flag and using \wasm\_bindgen\_test\) and a native test (guarded by \sys\ or \wasm-c-api\ feature flags). This allows a single test definition to automatically run in both JavaScript and native environments without duplicating test code.

lib/api/macro-wasmer-engine-test · high confidence

The \examples/\ directory has been reorganized and expanded with a new \README.md\ that documents the available examples in a structured, difficulty-based order. New examples have been added to cover core concepts such as Hello World, module instantiation, error handling, and memory interaction, as well as advanced topics like imports/exports, tables, globals, and function references. The collection also includes specific examples for different compilers (Cranelift, LLVM, Singlepass), engine configurations (headless, dylib, cross-compilation), and features like early exit and multi-value support.

examples · high confidence

The \lib/sys-utils/src/memory/fd\_memory\ module introduces a new memory implementation that uses file descriptors and \mmap\ to back WebAssembly linear memories. This change adds \FdMmap\ for low-level memory mapping via temporary files and \memories.rs\ to manage Wasm linear memory growth, copying, and access control using this backend. The module exports \VMMemory\, \VMOwnedMemory\, \VMSharedMemory\, and \initialize\_memory\_with\_data\, providing a new strategy for memory allocation that may impact performance and resource usage for Wasm instances relying on this backend.

_lib/sys-utils/src/memory/fd\memory · high confidence

The \lib/journal\ crate has been introduced to handle the serialization and persistence of WASM process states for snapshotting and restoration. It defines a comprehensive \JournalEntry\ enum that records detailed runtime events, including memory updates, thread lifecycle, file descriptor operations, and socket interactions. The crate provides \WritableJournal\ and \ReadableJournal\ traits for managing log streams, supports compressed and base64-encoded data storage for efficiency, and includes a strongly-typed \SnapshotTrigger\ system to configure when snapshots are taken (e.g., on idle, explicit request, or specific signals).

lib/journal/src · high confidence

The WASIX journaling system now supports replaying a broader range of operations, including file descriptor management (open, close, duplicate, renumber, seek, write, and flag/time updates), thread lifecycle events (creation and closure), module initialization, and snapshot triggers. This allows the runtime to accurately reconstruct the state of WASI applications from journal logs, ensuring that file handles, thread contexts, and memory updates are correctly restored during replay.

lib/wasix/src/syscalls/journal/actions · high confidence

A new \lib/package\ crate has been introduced to centralize WebAssembly container (WebC) loading and feature management. It provides utilities to load containers from disk or bytes, automatically detecting and parsing WebC v2 and v3 formats as well as tarball archives. Additionally, it includes bidirectional conversion functions to map between internal \Features\ objects and WebAssembly feature string annotations, supporting capabilities such as SIMD, bulk memory, reference types, threads, exceptions, memory64, wide arithmetic, tail calls, and multi-memory.

lib/package/src · high confidence

The CLI now includes a comprehensive set of new subcommands under the \package\ namespace to manage WebAssembly Component (WebC) packages. Users can build packages from a \wasmer.toml\ manifest (\package build\), download packages from the registry by name or hash with optional unpacking (\package download\), inspect package metadata without downloading (\package get\), search the registry with advanced filters like owner, license, and download count (\package search\), visualize dependency trees (\package tree\), and extract package contents to a directory (\package unpack\). These commands provide a complete local workflow for creating, retrieving, inspecting, and extracting packages, complementing the existing push, publish, and tag commands.

lib/cli/src/commands/package · high confidence

The scripts directory now includes a comprehensive set of tools to streamline the release process and aid in performance debugging. The new \make-release.py\ script automates the creation of release branches, version bumps across submodules, and changelog generation by querying merged pull requests, while \publish.py\ handles the topological sorting and publishing of crates to crates.io. Additionally, \find-fn-in-perfmap.py\ and \wasmer-perf-record.py\ provide utilities for resolving JIT-compiled function names from instruction pointers and annotating hot functions with sample percentages, respectively. A new \update-version.py\ script replaces the previous shell-based versioning, and an Alpine Linux dependency installation script ensures consistent build environments for CI.

scripts · high confidence

The \lib/types/src/stack\ module now exposes core types for stack tracing and error debugging, including \FrameInfo\ (describing WebAssembly backtrace frames with module/function names and source offsets), \SourceLoc\ (representing instruction positions within a module), and \TrapInformation\ (capturing trap codes and native code offsets). These types are serializable via rkyv and optionally serde, enabling better visibility into runtime errors and traps for users.

lib/types/src/stack · high confidence

The \lib/api/src/backend/sys/entities/memory\ module introduces a new implementation for WebAssembly memory in the sys runtime. This includes a \Memory\ struct that wraps the underlying VM memory handle, providing methods for size, growth, and reset operations. Crucially, it adds support for shared memory via \SharedMemory\ and \SharedMemoryOps\, enabling atomic wait/notify operations across threads. A new \MemoryView\ type is also introduced to safely read and write memory contents, including bounds-checked read/write methods and bulk copy operations.

lib/api/src/backend/sys/entities/memory · high confidence

The WASIX runtime now includes a dedicated task management layer in \lib/wasix/src/os/task\ that centralizes process and thread lifecycle handling. This change introduces a \WasiControlPlane\ to manage task counts and process registration, and implements an exponential CPU backoff mechanism that throttles process execution when no active run tokens are held, helping to prevent resource exhaustion. The new structure also provides robust task status tracking and signal handling, forming the foundation for improved snapshotting and thread management capabilities.

lib/wasix/src/os/task · high confidence

The \lib/vm/src/trap\ module introduces a unified trap handling system for the Wasmer VM. It adds a configurable stack pool with thread-local caching to optimize coroutine stack allocation and reuse, exposing functions to get, set, and drain stack sizes. The module supports a new \baremetal\ feature that provides a signal-free trap handler backend for environments without OS signals, routing traps through a host-installed unwinder callback. Additionally, it defines the \Trap\ and \UnwindReason\ types to categorize traps (user, wasm, lib, OOM, uncaught exception) and provides a trampoline function to execute Wasm code on dedicated stacks while catching traps.

lib/vm/src/trap · high confidence

A new \utils\ module has been added to the API library, introducing the \IntoBytes\ trait to standardize the conversion of various binary data types (such as \Vec\<u8\>\, \&\[u8\]\, and \&str\) into \bytes::Bytes\. This module also includes a polyfill implementation that traverses WebAssembly modules to create corresponding import and export types, specifically enforcing validation to reject exported \ExternRef\ types when using the V8 backend to prevent host API boundary issues. Additionally, runtime macros and native interaction utilities are provided to support the broader multi-backend API architecture.

lib/api/src/utils · high confidence

The \lib/wasix/src/utils\ module now provides core infrastructure for the WASI runtime. It introduces \WasiVersion\ detection logic to identify WASI and WASIX module versions via import namespaces, and \StoreSnapshot\ for serializing and restoring WebAssembly global state using bincode. Additionally, it adds concurrency utilities including \ThreadLocalExecutor\ for thread-local async task spawning, \WasiDummyWaker\ for polling futures outside an async runtime, \OwnedRwLock\ guards for safe lock ownership transfer, and \WasiParkingLot\ for thread parking. A \js\_error\ helper is also included for the \js\ feature to extract error messages from JavaScript values.

lib/wasix/src/utils · high confidence

The \lib/config\ crate has been introduced to centralize configuration types for Wasmer. It defines the \AppConfigV1\ schema for \app.yaml\ files, supporting features such as HTTP health checks, scheduled jobs with cron triggers and jitter, SSH server capabilities, and locality settings. It also provides the \Package\ struct for \wasmer.toml\ manifests, including package identification, hashing, and ABI definitions. The library includes a tool to generate JSON schemas for these types and enforces strict parsing rules, such as rejecting build metadata in version requirements.

lib/config · high confidence

The CLI now supports retrieving and rotating S3 credentials on a per-volume basis. The new \wasmer app volumes credentials\ command lists S3-enabled volumes and outputs their access keys, secret keys, and endpoints in JSON, YAML, table, or rclone configuration formats. Additionally, the \wasmer app volumes credentials rotate-secrets\ command allows users to rotate secrets for all S3-enabled volumes or a specific one, printing the new credentials to stdout while reporting individual rotation statuses and failures to stderr.

lib/cli/src/commands/app/volumes/credentials · high confidence

The WASIX OS environment now supports a pluggable command system, allowing built-in commands to be registered and executed dynamically. This change introduces a \VirtualCommand\ trait and a \Commands\ registry that maps command paths (e.g., \/bin/wasmer\) to handler implementations. Users can now extend the OS with custom commands or replace existing ones, as the command execution logic is no longer hardcoded but driven by the registered command map.

lib/wasix/src/os/command · high confidence

The Singlepass compiler has been completely rewritten to support x86\_64, ARM64, and RISC-V architectures. This change introduces a new modular code generation structure with separate emitter files for each architecture (emitter\_x64, emitter\_arm64, emitter\_riscv) and a unified codegen module. The compiler now supports multi-value WebAssembly operations, experimental unaligned memory accesses, and DWARF-based unwind information generation. Configuration options include NaN canonicalization, experimental artifact formats, and configurable thread counts for parallel compilation. The new implementation uses dynasm for assembly generation and includes proper handling of calling conventions for each target architecture.

lib/compiler-singlepass/src · high confidence

The API now allows host functions to be defined as asynchronous, enabling WebAssembly modules to call Rust functions that return futures and suspend execution without blocking the runtime thread. This is exposed via new \new\_async\ and \new\_with\_env\_async\ methods on the \Function\ entity, gated by the \experimental-async\ feature. Additionally, the API introduces \Tag\ and \ExnRef\ types to support the WebAssembly exception handling proposal, allowing modules to define and throw exceptions that can be caught by host code or other WebAssembly modules.

lib/api/src/entities/function · high confidence

WASIX now supports loading and linking dynamically linked WASM modules (side modules) at runtime. This change introduces a linker subsystem that parses the \dylink.0\ custom section to determine memory, table, and symbol requirements, and handles the resolution of imports (including \GOT.mem\ and \GOT.func\ entries) across multiple instance groups. It also manages shared memory allocation, indirect function table growth, and Thread-Local Storage (TLS) symbol resolution, allowing complex C/C++-compiled WASM binaries with shared library dependencies to be executed within the WASIX environment.

lib/wasix/src/state/linker · high confidence

The Wasmer CLI now supports reproducible builds via the \WASMER\_REPRODUCIBLE\_BUILD\ environment variable. When enabled, the build process sets the build date to 'UNKNOWN' instead of the current time, ensuring that builds are deterministic and identical across different times. This is particularly useful for packaging and distribution where build reproducibility is required.

lib/cli · high confidence

Users can now convert WebC (WebAssembly Component) archives into standard Wasmer package directories. This change introduces a new conversion module that reads the WebC manifest to reconstruct the package metadata (name, version, dependencies), extracts filesystem volumes to the target directory, and processes WebAssembly atoms as modules. This enables workflows where existing WebC artifacts can be re-imported or inspected as native Wasmer packages.

lib/package/src/convert · high confidence

The VM module now provides a unified abstraction layer that allows the \sys\, \v8\, and \js\ engines to coexist in a single build. This change introduces generic wrapper types (such as \VMMemory\, \VMSharedMemory\, and \VMExceptionRef\) that dispatch operations to the underlying engine-specific implementations via runtime macros. For users, this means the API can now support multiple execution backends simultaneously, with memory sharing and exception handling mechanisms adapted to work across these different engines.

lib/api/src/vm · high confidence

Added an unstable C API for the metering middleware, allowing users to track and limit the number of WebAssembly operators executed. The new \wasmer\_metering\_new\ function accepts an initial point limit and a user-defined cost function (mapped to \wasmer\_parser\_operator\_t\) to assign costs to specific operators. The resulting metering instance can be converted into a generic \wasmer\_middleware\_t\ and attached to a configuration via \wasm\_config\_push\_middleware\. The API also provides \wasmer\_metering\_delete\ for cleanup, \wasmer\_metering\_get\_remaining\_points\ to check the current limit, and \wasmer\_metering\_points\_are\_exhausted\ to detect when execution limits have been reached.

_lib/c-api/src/wasm\_c\api/unstable/middlewares · high confidence

The C API now exposes a new \unstable\ module containing Wasmer-specific extensions. Users can configure engine features (such as SIMD, threads, and reference types) via \wasmer\_features\_t\ and apply them using \wasm\_config\_set\_features\. The API provides runtime introspection to check if the build is headless (\wasmer\_is\_headless\) or if specific backends like LLVM, Cranelift, or Singlepass are available (\wasmer\_is\_backend\_available\). It also introduces target specification types (\wasmer\_target\_t\, \wasmer\_triple\_t\, \wasmer\_cpu\_features\_t\) for cross-compilation, module name management (\wasmer\_module\_name\, \wasmer\_module\_set\_name\), and a new function to create modules directly from an engine (\wasmer\_module\_new\). Additionally, WASI support includes \wasi\_get\_unordered\_imports\ to retrieve imports with their associated module and extern names.

_lib/c-api/src/wasm\_c\api/unstable · high confidence

The V8 runtime backend now supports creating host functions with typed signatures via \Function::new\_typed\ and calling them through \TypedFunction::call\_v8\, enabling direct native ABI interactions without manual value marshaling. Additionally, a new \FunctionEnv\ and \FunctionEnvMut\ system allows host functions to maintain and mutate persistent state across calls, with environments stored within the \Store\ and accessed via \Function::new\_with\_env\.

lib/api/src/backend/v8/entities/function · high confidence

The LLVM compiler backend has been removed for Windows targets. Attempting to use the LLVM compiler on Windows will now result in a compile-time error, directing users to switch to the V8 backend instead.

lib/compiler-llvm/src · high confidence

The \src/webassembly\ directory has been cleaned up by deleting the legacy runtime implementation files: \compilation.rs\, \environ.rs\, \errors.rs\, \instance.rs\, \memory.rs\, \module.rs\, and \utils.rs\. This removes the old Cranelift-based compilation, memory management, and instance handling logic from the WebAssembly module, likely as part of a broader refactoring to a new runtime architecture.

src/webassembly · high confidence

The previous command-line interface for executing WebAssembly modules has been removed. This change eliminates the standalone binary entry point that previously accepted a file path, converted WAT to WASM if necessary, and triggered compilation, effectively stripping out the old user-facing execution workflow in favor of the new internal architecture.

src · high confidence

The engine implementation has been restructured into distinct modules (artifact, builder, code\_memory, inner, link, mapped\_binary, resolver, tunables) to separate compilation, memory management, and linking concerns. A new \EngineBuilder\ provides a fluent API for configuring compilers, targets, and features, while the \Artifact\ type now explicitly supports both in-memory compilation and archived (serialized) module loading. The \Tunables\ trait is now a dedicated component for managing memory and table styles, and the engine's internal state is encapsulated in \EngineInner\ with thread-safe access via \Arc\<Mutex\<\>\>\. This change improves modularity and allows for headless engine usage without a compiler.

lib/compiler/src/engine · high confidence

The compiler's translator module has been restructured to support a pluggable middleware pipeline for parsing and translating WebAssembly modules. This change introduces \ModuleMiddleware\ and \FunctionMiddleware\ traits, allowing external components to intercept and transform module metadata and function bytecode during compilation. It also adds a \MiddlewareBinaryReader\ to manage operator streams through these middleware chains, replacing the previous monolithic translation approach with a more modular and extensible design.

lib/compiler/src/translator · high confidence

The LLVM compiler's translation logic has been restructured from a single monolithic file into distinct modules (\code\, \intrinsics\, \state\, and \trampoline\). This change improves code organization and maintainability by separating the core function translation logic, LLVM/VM intrinsic definitions, control-flow state management, and trampoline generation. Users benefit from a more robust and easier-to-maintain compiler backend, which supports ongoing features like exception handling, SIMD, and multi-memory proposals without the complexity of a single large file.

lib/compiler-llvm/src/translator · high confidence

A change to existing behaviour in benches/mods — 1 commit, 7 files.

benches/mods · medium confidence · unverified

The OS module now includes a comprehensive set of POSIX error constants (ERR\_EPERM through ERR\_ENOMEDIUM) and a helper function to map exit codes to human-readable messages, improving error reporting clarity. Additionally, common OS utilities for detecting mobile devices and SSH connections have been added to support platform-specific behavior.

lib/wasix/src/os · high confidence

The store entity layer has been restructured to support asynchronous execution and multiple backend engines (sys, v8, js). A new \StoreAsync\ type and \LocalRwLock\ provide async-aware locking for concurrent access, while \StoreContext\ manages thread-local context stacks for both sync and async execution paths. The \StoreInner\ now wraps a \BackendStore\ enum, allowing the same store API to work across different runtime backends, and \StoreObjects\ delegates object management to the active backend.

lib/api/src/entities/store · high confidence

The C API's engine module has been rewritten to expose a \wasmer\_backend\_t\ enum (Cranelift, LLVM, Singlepass, Headless, V8) and rename configuration functions from \wasmer\_engine\config\\*\ to \wasmer\_backend\config\\*\. Engine creation now explicitly matches against these backend variants, allowing users to select specific backends via configuration, while the default engine behavior is preserved through the \Default\ implementation.

_lib/c-api/src/wasm\_c\api/engine · high confidence

The main C API header file has been renamed from \wasmer\_wasm.h\ to \wasmer.h\. The old \wasmer\_wasm.h\ header is now deprecated and simply includes the new \wasmer.h\ while emitting a compiler warning to guide users to the new name.

lib/c-api · high confidence

The CLI's utility functions have been consolidated into a new \lib/cli/src/utils\ module, introducing format-preserving YAML editing for \app.yaml\ files to retain user formatting (comments, key order, quoting) during updates. The module also adds improved interactive prompts for application and package identification, a new \parse\_volume\ function that correctly handles Windows path colons for volume mapping, and support for parsing relative timestamps.

lib/cli/src/utils · high confidence

The \lib/compiler\ crate now includes a new README that documents the base compiler implementation, the \ModuleInfo\ translation process, and the \CompilerConfig\ and \Compiler\ traits required to create custom compilers. Additionally, a new \build.rs\ script has been added to handle the compilation of \libunwind.c\ for Unix targets, supporting reliable detection of libunwind via weak symbols.

lib/compiler · high confidence

Compilation-related types (such as \CompiledFunction\, \Relocation\, \CustomSection\, and \ModuleMetadata\) have been moved from \wasmer\_types\ into the new \lib/compiler/src/types\ module. This change introduces an experimental 'Artifact' format for compiled modules, enabling serialization via \rkyv\ and optional \serde\. The new types support GOT-based relocations, \compact\_unwind\ tables for Mach-O, and track maximum stack usage per function, providing a structured foundation for saving and loading compiled WebAssembly artifacts.

lib/compiler/src/types · high confidence

The Cranelift translator module has been reorganized into a new file structure, splitting the translation logic into dedicated files for code translation (\code\_translator.rs\), function state management (\func\_state.rs\), and the main translator entry point (\func\_translator.rs\). This change introduces support for WebAssembly exception handling (EH) by adding types for \Tag\ and \ExnRef\, implementing bounds checking for memory accesses in a new \bounds\_checks.rs\ module, and integrating unwind information generation. The translator now uses \FunctionIndex\ and \FunctionType\ instead of the previous \FuncIndex\ and \FuncType\ naming, and relies on \wasmparser\ for parsing while interacting with \wasmer\_types\ for core types.

lib/compiler-cranelift/src/translator · high confidence

The logic for determining the default WebAssembly backend has been updated to prioritize explicit feature flags (sys-default, v8-default, js-default) before falling back to a standard priority order (Cranelift, Singlepass, LLVM, Headless). This ensures that the default runtime is selected predictably based on the enabled features, preventing panics when no runtime is explicitly configured but at least one is available.

lib/api/src/backend · high confidence

The Wasmer CLI now enables telemetry and update notifications by default. This is implemented in the \lib/cli/src/config\ module, where the \WasmerConfig\ struct's \Default\ implementation sets \telemetry\_enabled\ and \update\_notifications\_enabled\ to \true\. Users will now have these features active unless they explicitly disable them in their \wasmer.toml\ configuration file.

lib/cli/src/config · high confidence

The 'container unpack' CLI command has been removed and replaced with a placeholder that directs users to use 'wasmer package unpack' instead. This change reflects a rebranding or structural shift in the CLI where container-related operations are now grouped under the 'package' namespace, ensuring users are guided to the correct, updated command syntax.

lib/cli/src/commands/container · high confidence

The \PrimaryMap\ and \SecondaryMap\ data structures in the entity module now implement \rkyv\ serialization traits (\Archive\, \RkyvSerialize\, \RkyvDeserialize\), enabling safe, checked, zero-copy deserialization of module artifacts. This change allows these maps to be archived and deserialized without the overhead of standard serialization, significantly improving load times for cached modules, while retaining optional \serde\ support via the \enable-serde\ feature.

lib/types/src/entity · high confidence

The WASIX TTY implementation now correctly handles backspace, carriage returns, and line feeds in both canonical and non-canonical modes, ensuring that input characters are processed as expected by users. It also switches terminal size detection to the maintained \terminal\_size\ crate, providing accurate column and row counts for the console. These changes fix previous issues where line breaks and backspaces were not rendered or processed correctly, leading to a more reliable interactive terminal experience.

lib/wasix/src/os/tty · high confidence

The trap handling subsystem has been refactored to provide more accurate backtraces for WebAssembly traps. The new implementation in \lib/compiler/src/engine/trap\ distinguishes between non-ELF artifacts (which use per-instruction address maps for precise source location mapping) and ELF-backed artifacts (which fall back to DWARF line info via \addr2line\). This ensures that when a trap occurs, users see the correct function names, line numbers, and source locations in the resulting stack trace, rather than generic or missing information. The change also introduces a global cache for frame information that is properly registered and unregistered with module lifecycles, preventing crashes during exit by avoiding access to backtrace information after the runtime has begun shutting down.

lib/compiler/src/engine/trap · high confidence

The JavaScript backend now provides more robust error diagnostics by introducing a dedicated \Trap\ error type that distinguishes between user errors and JavaScript exceptions, allowing developers to inspect and downcast runtime failures. Additionally, the backend adds experimental support for the JavaScript Promising API (JSPI) via a new \jspi\ module, which manages active store lifecycles and interfaces with WebAssembly's \promising\ and \Suspending\ features to enable async execution in supported environments.

lib/api/src/backend/js · high confidence

The CLI's package publishing flow has been updated to use a new R2 upload mechanism, which streams packages in smaller chunks to provide a smoother, more responsive progress bar. Additionally, users can now choose to wait for specific components (container, native executables, or bindings) to become ready after publishing, rather than waiting for all of them or none, providing more control over the deployment process.

lib/cli/src/commands/package/common · high confidence

When running a package without the \--net\ flag, the CLI now prompts the user to explicitly allow or deny networking access. Users can choose 'yes', 'no', or 'always'; selecting 'always' saves the preference to a local cache file (based on package identity or path hash) so future runs bypass the prompt. The prompt is a single-line input accepting 'y', 'n', or 'a', and users can bypass the prompt entirely by passing \--net\.

lib/cli/src/commands/run/capabilities · high confidence

The \lib/api/src/utils/macros\ module now provides \gen\_rt\_ty\ and \match\_rt\ macros to automatically generate and match against runtime types for the \sys\, \v8\, and \js\ backends. This refactoring centralizes the boilerplate for handling multiple JavaScript engine implementations, allowing the API to support these specific backends through a unified, feature-gated interface.

lib/api/src/utils/macros · high confidence

The \lib/api/src/backend/sys/entities\ module now provides the concrete implementations for the \sys\ runtime's core WebAssembly entities, including Engine, Module, Instance, Store, Table, Memory, Global, Function, Tag, Exception, and ExternRef. This change establishes the foundational data structures and traits (such as \NativeEngineExt\) required to manage the WebAssembly execution context, handle compilation and instantiation, and support features like exception handling with tags and payloads, as well as extern/funcref references within the sys backend.

lib/api/src/backend/sys/entities · high confidence

The JavaScript backend now includes dedicated implementations for function environments (\FunctionEnv\, \FunctionEnvMut\) and store object handles (\StoreHandle\, \StoreObjects\). These changes enable proper management of host state and external references (ExternRefs) within the JS runtime, supporting both synchronous and asynchronous (JSPI) function calls with correct error bubbling and type safety.

lib/api/src/backend/js/entities/function · high confidence

The \lib/api/src\ module now exposes a structured error hierarchy including \LinkError\, \InstantiationError\, and \RuntimeError\. \LinkError\ handles module instantiation failures such as import mismatches or resource shortages, while \InstantiationError\ distinguishes between linking issues, start-function traps, and CPU feature mismatches. \RuntimeError\ provides detailed runtime failure information, including the ability to capture and display WebAssembly traces and trap codes, and supports wrapping custom user errors or uncaught exceptions for better debugging and error propagation.

lib/api/src · high confidence

The JavaScript backend's memory handling has been rewritten to use a new \MemoryBuffer\ and \MemoryView\ structure that interacts with \js\_sys::Uint8Array\ and \WebAssembly.Memory\. A key behavioral change is the introduction of a hard cap on shared memory growth: the maximum pages for shared memories are now bounded to 32,767 (approx. 2 GiB) to prevent issues with QuickJS's signed 32-bit length representation. Additionally, the backend now implements a fallback mechanism that attempts to create shared memories with smaller maximums if the browser rejects the initially requested size, and it correctly handles memory growth errors by mapping JavaScript \RangeError\ exceptions to Wasmer's \MemoryError::CouldNotGrow\.

lib/api/src/backend/js/entities/memory · high confidence

The journal's compaction process has been updated to filter out transient events, such as local disk redo logs (SQLite), ensuring they are not retained in the final compacted journal. This change is implemented in the \lib/journal/src/concrete\ module, which introduces new concrete journal types including \CompactingJournal\, \CompactingLogFileJournal\, \CompactingTransactionJournal\, and \AutoConsistentJournal\. These components work together to manage event lifecycles, with the compaction logic specifically designed to discard events that are no longer relevant to the persistent state, thereby reducing journal size and improving efficiency.

lib/journal/src/concrete · high confidence

The journal effector logic has been reorganized into distinct modules (memory\_and\_snapshot, process\_exit, thread\_state, etc.) to improve clarity and maintainability. Memory snapshotting is now optimized by using a 512-byte region resolution, hashing memory pages to skip unchanged regions, combining adjacent dirty regions, and applying LZ4 compression before writing to the journal. Thread state and process exit events are now handled by dedicated modules that save and apply journal entries for thread spawning, state restoration, and process termination, ensuring consistent journaling across these lifecycle events.

lib/wasix/src/journal/effector · high confidence

The journal module in lib/wasix now uses conditional compilation to switch between a functional effector and an unimplemented stub based on the 'journal' feature flag, while re-exporting symbols from the wasmer\_journal crate.

lib/wasix/src/journal · high confidence

The journal subsystem in \lib/wasix/src/syscalls/journal\ has been reorganized into a modular set of files to handle process checkpointing and state restoration. The new \JournalSyscallPlayer\ struct and its \play\_event\ method now drive the replay of journal entries, while dedicated modules like \restore\_snapshot\ and \wait\_for\_snapshot\ manage the restoration of memory, file descriptors, and background threads. This change also introduces \clear\_ethereal\ to reset ephemeral state and \do\_checkpoint\_from\_outside\ to trigger checkpoints, effectively separating the mechanics of journaling from the core syscall implementation.

lib/wasix/src/syscalls/journal · high confidence

The file descriptor memory module has been relocated from the wasi crate to the sys-utils crate and is now gated to Linux targets only. This change ensures that the memory utilities are available in a shared system utilities location while restricting their compilation to Linux environments, removing them from the WASI-specific context.

lib/sys-utils/src/memory · high confidence

The \wasmer run\ command has been significantly refactored, introducing several breaking changes and new capabilities. The \--mapdir\ and \--map\ arguments have been replaced by a new \--volume\ argument for directory mappings, and the \--entrypoint\ alias has been removed in favor of a dedicated \--invoke\ argument for selecting entry functions in single WASM modules. The command now supports asynchronous threading (controlled via \--enable-async-threads\), networking (via \--net\), and offline dependency resolution (via \--offline\). Additionally, users can now load environment variables from files using \--env-file\, set the working directory with \--cwd\, and enable experimental N-API support with \--experimental-napi\. The underlying runtime architecture has also been updated to use a new Context API and improved WASI runner implementations.

lib/cli/src/commands/run · high confidence

The Windows installer (wasmer.iss) now explicitly sets the WASMER\_CACHE\_DIR environment variable to the user's profile cache directory and ensures the installer's bin and wapm\_packages paths are removed from the system PATH during uninstallation, preventing leftover path entries after removal.

scripts/windows-installer · high confidence

The HTTP client layer in lib/wasix has been refactored into a modular architecture that provides a unified \HttpClient\ trait with distinct, platform-specific implementations. For host environments, the \ReqwestHttpClient\ is now available, featuring a configurable connect timeout (defaulting to 10 seconds) and an optional response body chunk timeout to prevent stalls during large downloads. For JavaScript/WebAssembly environments, a new \WebHttpClient\ has been introduced, which includes a workaround for async deadlock issues in syscalls by optionally accepting a \VirtualTaskManager\ to offload fetch operations to a background thread. The module also defines standard \HttpRequest\ and \HttpResponse\ types with conversion support from the \http\ crate, and exposes a \default\_http\_client()\ function that automatically selects the appropriate implementation based on enabled features (e.g., \host-reqwest\ or \js\).

lib/wasix/src/http · high confidence

The WASIX runtime now uses a new, pluggable module caching system that replaces the previous implementation. Users benefit from a \ModuleCache\ trait that supports multiple storage strategies, including an in-memory \SharedCache\ (default for most environments), a \ThreadLocalCache\ for browser contexts, and a \FileSystemCache\ for persistent disk storage. A key behavioral improvement is the \FallbackCache\ combinator, which allows chaining a fast primary cache with a slower secondary one (e.g., memory + disk), automatically promoting modules from the fallback to the primary cache on hit to speed up future loads. Additionally, the system now supports progress reporting during module loading via \ModuleLoadProgressReporter\, allowing applications to track download, compilation, and cache-hit states, and to abort loading if necessary. The cache keys now incorporate the engine's deterministic ID and artifact format to ensure correct module retrieval across different compilation configurations.

_lib/wasix/src/runtime/module\cache · high confidence

The package resolver has been refactored into a modular system that supports resolving dependencies from multiple sources, including a remote GraphQL registry (BackendSource), local filesystem paths (FileSystemSource), local directory-based registries (LocalRegistrySource), and in-memory stores for testing (InMemorySource). These sources are orchestrated by a MultiSource component that can merge results or stop at the first match based on configurable strategies. The resolution logic now uses the petgraph library to build and validate dependency graphs, detecting cycles and duplicate versions, and supports both named and hashed package identifiers.

lib/wasix/src/runtime/resolver · high confidence

The Nix build system for the Wasmer CLI has been rewritten to use the Crane library, enabling incremental builds that skip dependency recompilation when only Rust source changes. The package now installs shell completions for Bash, Zsh, and Fish, and includes C header files (wasmer.h, wasm.h, etc.) in the output. Support for the V8 JavaScript engine is provided via a new prebuilt V8 derivation and an update script, while Emscripten support has been removed.

scripts/nix · high confidence

The CLI has been restructured into two distinct binaries: \wasmer\ and \wasmer\_headless\. The standard \wasmer\ binary now enforces that at least one compilation backend (such as cranelift, singlepass, or v8) is enabled at compile time, failing with a clear error if none are selected, whereas the new \wasmer\_headless\ binary allows execution without any backend features. This change ensures users explicitly configure the compilation engine when using the main binary, while providing a lighter, headless alternative for scenarios where compilation is not required.

lib/cli/src/bin · high confidence

The engine module has been restructured to support a multi-backend architecture. A new \EngineRef\ type and \AsEngineRef\ trait allow temporary, non-owning handles to engines, enabling more flexible interactions with stores and modules. The internal engine implementation is now wrapped in a \BackendEngine\ type that dispatches operations (like deserialization and deterministic ID generation) to specific backends (sys, v8, js) based on compile-time features. The public \Engine\ type now exposes an opaque \EngineId\ and delegates backend-specific logic to the internal abstraction, while retaining methods for deterministic IDs, artifact formats, and feature queries.

lib/api/src/entities/engine · high confidence

The WASI runtime now uses a conditional storage strategy for instance handles: it employs a global pointer for system builds (sys/sys-minimal) and switches to a thread-local storage mechanism for JavaScript builds. This change introduces new \WasiInstanceHandlesPointer\ and guard types in \lib/wasix/src/state/handles\ that allow safe, non-sendable access to WASI instance state (such as memory, function tables, and asyncify callbacks) specifically within the current thread, addressing concurrency constraints in browser environments while maintaining the existing global access pattern for native targets.

lib/wasix/src/state/handles · high confidence

The file system layer in \lib/wasix/src/fs\ has been restructured to replace the previous \FdList\ implementation with a new, optimized data structure that ensures file descriptors are always allocated as the lowest available number, matching POSIX requirements. This change introduces dedicated modules for file descriptor handling (\fd.rs\), inode guarding (\inode\_guard.rs\), and POSIX path resolution (\path\_posix.rs\), which together provide more robust lifecycle management for open files, sockets, and pipes. The refactoring also adds support for event notifications and epoll integration, ensuring that file operations and asynchronous I/O are handled with stricter locking orders to prevent race conditions and deadlocks, while maintaining compatibility with existing WASI syscalls.

lib/wasix/src/fs · high confidence

The internal state management for WASIX has been reorganized into a dedicated \lib/wasix/src/state\ module, introducing a new \WasiEnvBuilder\ for configuring WASI environments and a \ContextSwitchingEnvironment\ to handle asynchronous thread switching and execution. This change consolidates state handling, improves the handling of context switches and signal dispositions, and exposes the context-switching API for use by custom task managers, while also refining how journals and snapshots are initialized and restored within the environment lifecycle.

lib/wasix/src/state · high confidence

The instance creation and lifecycle logic in the VM has been restructured into three new modules: \allocator.rs\, \mod.rs\, and \ref.rs\. The \InstanceAllocator\ now handles the raw memory layout and allocation of the dynamically-sized \Instance\ structure, including its embedded \vmctx\ region. A new \InstanceRef\ type wraps the instance in an \Arc\ to provide safe, thread-shared access and automatic deallocation, replacing the previous \InstanceHandle\ mechanism. The core \Instance\ struct in \mod.rs\ has been updated to store \ModuleInfo\ as an \Arc\ and manage local memories, tables, globals, and tags via internal store handles, while passive data segments are now shared across instances to avoid deep copies.

lib/vm/src/instance · high confidence

The memory subsystem has been restructured to support multiple runtime backends (sys, v8, js) via a new \BackendMemory\ abstraction, replacing the previous single-backend design. This change introduces \SharedMemory\ and \MemoryOps\ types, enabling memory to be detached from a store and shared across threads or attached to different stores, which resolves previous memory leak issues with subprocesses and allows for more flexible memory management. The \Memory::copy\_to\_store\ method is now deprecated in favor of the new \copy\ and \attach\ pattern, and the \Memory::size\ function has been added to retrieve memory size in pages.

lib/api/src/entities/memory · high confidence

The package loader now defaults to a 'lossy' strictness mode, meaning that issues like missing files or paths outside the base directory are treated as warnings rather than hard errors, improving backwards compatibility for interactive or edited manifests. Additionally, when building packages, the system now respects \.wasmerignore\ files to exclude specific files; if no such file is present, it defaults to ignoring \.git\ folders and hidden files, replacing the previous behavior.

lib/package/src/package · high confidence

The \wasmer-types\ crate now uses a chunked thread-local allocator for \StoreId\, significantly reducing global atomic contention and improving multi-threaded performance. Additionally, the serialized module artifact format version has been bumped to 24 to accommodate these internal structural changes, ensuring that existing cached modules are invalidated and rebuilt with the new format.

lib/types/src · high confidence

The C API now provides a unified configuration structure (\wasm\_config\_t\) that supports multiple compilation backends, including the new V8 engine alongside existing sys-based backends (Cranelift, LLVM, Singlepass, and Headless). Users can now configure backend-specific options such as NaN canonicalization for sys engines and set execution targets via the new \wasm\_config\_set\_target\ function. Additionally, the API exposes \wasm\_config\_push\_middleware\ to attach middlewares to the engine configuration, allowing for more flexible engine customization across different backend implementations.

_lib/c-api/src/wasm\_c\api/engine/config · high confidence

The \lib/api/src/entities/function/env\ module now provides a unified \FunctionEnv\ and \FunctionEnvMut\ API that abstracts over the underlying runtime backends (\sys\, \v8\, and \js\). This change introduces an internal \BackendFunctionEnv\ enum that dispatches environment operations to the specific backend implementation based on the active store type, allowing host state management to remain consistent regardless of the JavaScript engine or system runtime in use. Additionally, when the \experimental-async\ feature is enabled, the module exposes \AsyncFunctionEnvMut\ and related handles to support asynchronous access to function environment data.

lib/api/src/entities/function/env · high confidence

The memory buffer subsystem has been refactored to support multiple runtime backends, including the newly added JavaScript (V8) engine. The \MemoryBuffer\ type now delegates to a \BackendMemoryBuffer\ that abstracts over \sys\, \v8\, and \js\ implementations via runtime macros. This allows the API to handle memory reads, writes, and length queries uniformly across different execution environments, while specifically noting that JS-owned buffers are tracked separately to optimize performance.

lib/api/src/entities/memory/buffer · high confidence

The memory view API in the API layer has been refactored to support multiple runtime backends (sys, v8, and js) through a unified \BackendMemoryView\ abstraction. This change introduces new capabilities for users, specifically the ability to copy memory contents to a vector (\copy\_to\_vec\, \copy\_range\_to\_vec\) and to copy memory ranges directly between different memory objects (\copy\_to\_memory\, \copy\_range\_to\_memory\), alongside existing read/write operations.

lib/api/src/entities/memory/view · high confidence

The engine's unwind registration logic has been restructured into a unified \UnwindRegistry\ interface that automatically selects the appropriate implementation for the target platform: Windows x64 uses \RtlAddFunctionTable\ for runtime function entries, Unix systems use System V ABI frame registration (supporting both libunwind and libgcc detection via weak symbols), and macOS ARM64 utilizes compact unwind tables. A new \DummyUnwindRegistry\ serves as a no-op fallback for unsupported architectures, ensuring the compiler does not crash on platforms lacking native unwind support.

lib/compiler/src/engine/unwind · high confidence

The WASI type definitions in \lib/wasi-types/src/wasi\ have been regenerated and supplemented with manual implementations. The generated bindings now include updated clock identifiers (\Clockid\, \Snapshot0Clockid\) and error codes (\Errno\), with all enums marked \\#\[non\_exhaustive\]\ to prevent undefined behavior from invalid guest input. Manual code in \bindings\_manual.rs\ and \wasix\_manual.rs\ adds socket-specific rights helpers, type conversions between snapshot versions, and new structures for thread-local storage, subscriptions, and stack snapshots (\StackSnapshot\), ensuring correct memory alignment and padding for WASIX compatibility.

lib/wasi-types/src/wasi · high confidence

The WebAssembly C API header in lib/api/third-party/wee8/wasm.h has been updated to the latest upstream version of wasm\_c\_api. This update introduces support for shared memory and tags, aligning the API with the latest WebAssembly standards and enabling new capabilities for memory management and exception handling in WebAssembly modules.

lib/api/third-party · high confidence

The V8 backend now supports shared memory, allowing WebAssembly memory to be safely transferred between different stores via a new \VMSharedMemory\ type that wraps the underlying shared memory pointer. This change is accompanied by a refactor of internal type naming, where \Runtime\\ types have been renamed to \Backend\\ types, and the introduction of a \VMFunctionEnvironment\ struct to manage function context contents. These changes enable concurrent execution capabilities and improve memory safety bounds across linear-memory-related types.

lib/api/src/backend/v8/vm · medium confidence

The V8 backend's memory handling has been restructured to improve safety and functionality. A new \MemoryView\ type has been introduced to provide safe, bounds-checked read and write operations on WebAssembly linear memory, replacing direct pointer access. The \Memory\ struct now includes a \copy\ method that creates a \SharedMemory\ instance, and the view layer supports copying memory ranges to vectors or other memory objects. Additionally, the \reset\ operation is explicitly unsupported for V8 memory, returning an error, and the \size\ function is implemented to return the current memory size in pages.

lib/api/src/backend/v8/entities/memory · high confidence

The V8 backend implementation now allows user code to throw custom errors that are properly propagated through the runtime. Previously, only native Wasm traps were supported; the new \Trap\ struct in \error.rs\ distinguishes between native C-API traps and user-defined errors (\InnerTrap::User\), enabling downcasting and type checking of user exceptions. This change ensures that errors thrown from within the V8-hosted environment are correctly captured and converted into the platform's standard \RuntimeError\ type.

lib/api/src/backend/v8 · high confidence

The virtual filesystem implementation has been significantly restructured, introducing new wrapper types such as ArcBoxFile, ArcFile, and ArcFileSystem to better manage shared file references and cloneable filesystem instances. A new CopyOnWriteFile implementation has been added to optimize union and merge operations by deferring file copies until write access is required. The RootFileSystemBuilder has been updated to support memory limiting for temporary filesystems and now includes /dev/shm in the default root filesystem. Additionally, the codebase now includes specialized file types like BufferFile for /dev/zero emulation, CombineFile for duplex pipes, and DualWriteFile for debugging write operations.

lib/virtual-fs/src · high confidence

The WASI syscall implementations in \lib/wasix/src/syscalls/wasi\ have been reorganized from a monolithic structure into individual, dedicated source files (e.g., \args\_get.rs\, \fd\_read.rs\, \clock\_time\_get.rs\). This change introduces a \legacy\ module containing wrappers for the older WASI Snapshot0 ABI, ensuring backward compatibility for guest modules relying on the previous interface while the main implementation uses the current types. The refactoring also integrates journaling snapshot triggers into key operations like environment variable access and file descriptor reads.

lib/wasix/src/syscalls/wasi · high confidence

The WASIX runtime's task manager has been refactored to decouple WASM thread execution from the main Tokio runtime. Instead of running threads directly on the Tokio event loop, the system now uses a \rusty\_pool\-backed thread pool (\TokioTaskManager\) to handle WASM tasks. This change addresses blocking issues (such as STDIN blocking shutdown) and stalling problems by ensuring that long-running or blocking WASM operations do not starve the async runtime. The \VirtualTaskManager\ trait now delegates execution to this separate pool, while Tokio is retained only for managing the runtime handle and non-blocking async utilities.

_lib/wasix/src/runtime/task\manager · high confidence

The \lib/c-api/src/wasm\_c\_api/types\ module has been reorganized into individual files (export, extern, frame, function, global, import, memory, mutability, reference, table, tag, value) to improve consistency and maintainability. This change introduces initial support for WebAssembly references (\externref\/\funcref\) via the \wasm\_ref\_t\ surface, allowing C embedders to manage host info and finalizers for reference types. It also adds \wasm\_frame\_t\ to expose stack frame information (module name, function name, offsets) for debugging and error reporting. Additionally, the module implements \wasm\_externtype\_copy\ for safe duplication of external types and refactors internal type handling to eliminate memory leaks in functions like \wasm\_functype\_new\ and \wasm\_globaltype\_content\.

_lib/c-api/src/wasm\_c\api/types · high confidence

This change fixes race conditions in the WASIX epoll implementation that could cause missed events or incorrect readiness states. Specifically, it ensures that multiple events for the same file descriptor are delivered correctly to avoid race conditions, fixes the cleanup logic when removing file descriptors from epoll sets, and corrects the readiness detection for TCP connections. These fixes improve the reliability of asynchronous I/O operations for applications relying on epoll.

lib/wasix/src/os/epoll · high confidence

The VM now includes a vendored copy of the \compiler-builtins\ stack probe implementation to resolve undefined symbol errors for \\_\_rust\_probestack\ during linking. This change ensures that stack overflow guard pages are correctly enforced on x86 and x86\_64 platforms, preventing potential security vulnerabilities like stack clashes, while maintaining compatibility with Windows-specific stack checking routines.

lib/vm/src/probestack · high confidence

25 commits adding/updating tests in tests/compilers/wasmu; Added C API test infrastructure and helper headers; Added C and C++ API example tests for core WebAssembly features; Added C and C++ API header files for WebAssembly testing; Added CLI integration test infrastructure; Added Rust WASI test suite for process exit, file system operations, and thread behavior; Added Rust-based C API test runner; Added WASIX integration and unit tests; Added WAST test runner for WebAssembly spec tests; Added WebAssembly spec test suite; Added WebAssembly test examples; Added build script for compiler test derive; Added commented-out test for fd mmap memory functionality; Added compile-fail test harness for the derive library; Added compile-fail tests for WasmerEnv macro validation; Added comprehensive integration tests for the Wasmer CLI; Added custom WAST regression tests for Wasmer; Added filesystem cache benchmarks for WASM module store and load operations; Added iOS integration test for DylibExample; Added iOS integration test for WASM dylib execution; Added iOS integration test project for dylib loading; Added integration test for JavaScript script execution via QuickJS; Added integration test for WASI CWD annotation; Added integration test for nested mounted paths in UnionFilesystem; Added integration test for package publishing; Added integration tests for Axum and JavaScript package deployments; Added integration tests for CLI package get and search commands; Added integration tests for CLI version and help output; Added integration tests for PHP and static website deployment packages; Added integration tests for WASI filesystem mount and shared file descriptors; Added test-generator library for automated test suite generation; Added tests for WASI socket sendto() behavior; Added tests for the compiler-test-derive macro; Added wasmer-argus registry package testsuite; Comprehensive compiler test suite for WASM execution and compilation; Establishes test ignore lists for compiler and platform-specific failures; Expanded API test coverage for store lending, async execution, and reference types; Expanded CLI integration test coverage for WASI and core utilities; New WASIX integration test harness with C/C++ fixtures; New fuzzing targets for compiler backends and determinism; Removed WebAssembly spec test harness and associated test files; Updated package manifest snapshot tests.

Updated Rust dependencies and lockfile across 40 manifests to address security advisories, resolve yanked crate issues, and align with the latest stable releases.

(dependencies) · high confidence

The \lib/\ directory now includes a README that outlines the modular crate architecture, detailing components such as the public APIs (Rust, JS, C), compilers (Cranelift, LLVM, Singlepass), engines, WASI integration, and middlewares. Additionally, the \lib/napi\ submodule has been updated to a specific commit, reflecting changes to the Node.js API integration.

lib · high confidence

Written by watchdog.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

• CAI 45 → 55 (+9.5)
• Rubric changed (rubric-2026.08.15 → rubric-2026.09.15) — scores are not directly comparable.

• Code Health 91 → 79 (-11.8)
• Architecture 69 → 68 (-0.5)
• Maturity 59 → 76 (+16.8)
• Readiness 27 → 81 (+53.7)
• Security 56 → 67 (+10.1)
• Event Sourcing 100 (new)
• Accessibility 36 (new)

• Coverage not measured — test suite did not build
• Dimension evaluation failed
• High IaC: DS-0002 (lib/c-api/tests/wasm-c-api/Dockerfile)
• High IaC: DS-0029 (lib/c-api/tests/wasm-c-api/Dockerfile)
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• …and 40 more

• Artifact::from_parts_with_module_file (cognitive 37) (lib/compiler/src/engine/artifact.rs)
• Artifact::from_parts_with_module_file (cyclomatic 21) (lib/compiler/src/engine/artifact.rs)
• AsyncCallFuture::poll (cognitive 16) (lib/api/src/backend/sys/async_runtime.rs)
• AsyncifyPoller::poll (cognitive 18) (lib/wasix/src/syscalls/mod.rs)
• BackendType::get_engine (cognitive 44) (lib/cli/src/backend.rs)
• BackendType::get_engine (cyclomatic 32) (lib/cli/src/backend.rs)
• Boundary-crossing change coupling: code.rs ↔ tunables.rs (lib/compiler-llvm/src/translator/code.rs)
• Boundary-crossing change coupling: config.rs ↔ config.rs (lib/compiler-cranelift/src/config.rs)
• Boundary-crossing change coupling: config.rs ↔ config.rs (lib/compiler-llvm/src/config.rs)
• CI installs an unverified third-party binary (.github/workflows/benchmark.yaml)
• CI installs an unverified third-party binary (.github/workflows/test.yaml)
• CI installs an unverified third-party binary (.github/workflows/test.yaml)
• Change coupling clique: context_create.rs, context_destroy.rs, context_switch.rs (lib/wasix/src/syscalls/wasix/context_create.rs)
• Change coupling: binary_package.rs ↔ outputs.rs (lib/wasix/src/bin_factory/binary_package.rs)
• Change coupling: client.rs ↔ server.rs (lib/virtual-net/src/client.rs)
• Change coupling: codegen.rs ↔ machine_x64.rs (lib/compiler-singlepass/src/codegen.rs)
• Change coupling: create.rs ↔ mod.rs (lib/cli/src/commands/app/create.rs)
• Change coupling: deploy.rs ↔ mod.rs (lib/cli/src/commands/app/deploy.rs)
• Change coupling: epoll_ctl.rs ↔ epoll_wait.rs (lib/wasix/src/syscalls/wasix/epoll_ctl.rs)
• Change coupling: exec.rs ↔ mod.rs (lib/wasix/src/bin_factory/exec.rs)
• …and 1978 more

• 118 commits — 80 feature/other, 38 fixes

• (root) — 27 commits
• lib/wasix — 17 commits
• lib/api — 14 commits
• (repo) — 10 commits
• .github/workflows — 9 commits
• lib/cli — 5 commits
• lib/compiler — 5 commits
• lib/compiler-singlepass — 5 commits
• lib/compiler-llvm — 3 commits
• tests/integration — 3 commits
• .cargo/config.toml — 2 commits
• lib/types — 2 commits
• scripts/nix — 2 commits
• .github/ci-constants.env — 1 commit
• docs/SECURITY.md — 1 commit
• fuzz/fuzz_targets — 1 commit
• lib/backend-api — 1 commit
• lib/compiler-cranelift — 1 commit
• lib/config — 1 commit
• lib/virtual-net — 1 commit

• fix: Potential fix for pull request finding
• fix: fix CI
• fix: fix function signature on macOS
• fix: fix(LLVM): fix missing canonicalization leading to error (#6945)
• fix: fix(LLVM): use correct BBs as PHI inputs in call_indirect (#6965)
• fix: fix(Singlepass): drop wrong constant folding for emit comparison on x86_64 (#6880)
• fix: fix(Singlepass): simplify stack rounding logic (#6895)
• fix: fix(Table): add resource allocation tracking for local Tables (#16)
• fix: fix(Table): handle table.grow boundary limit
• fix: fix(VMOffsets): handle gracefully u32 -> i32 casting (#6904)
• fix: fix(api): give each call its own store context entry
• fix: fix(api): make demangling optional for browser builds
• fix: fix(api): preserve V8 externref boundaries
• fix: fix(api-js): address async API review feedback
• fix: fix(api-js): address async API review feedback
• fix: fix(api-js-backend): Add support for ExternRefs in Wasmer JS backend
• fix: fix(api-js-backend): Allow up to 4Gb memory pointers in JS backend
• fix: fix(api-js-backend): Properly annotate all tables, not just imported ones
• fix: fix(api-js-backend): add copy_range_to_memory to the MemoryViews
• fix: fix(api-js-backend): bubble js panics up so errors are inspectable
• …and 98 more

Written by watchdog.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

wasmerio/wasmer was measured the same way every project in this corpus was: the same rubric, at a pinned commit, with the result published in full. Point a surveyor at a repository you know and see whether you agree with it.