WasmEdge is an extensible WebAssembly runtime that executes WebAssembly bytecode in a secure sandbox for cloud, edge, and embedded applications. It functions as a multi-language compiler, compiling applications written in Rust, JavaScript, Go, and Python into WebAssembly bytecode for sandboxed execution, and as a server-side JavaScript runtime that runs JavaScript programs with ES6 modules, NPM packages, and Node.js-compatible APIs. The runtime also serves as an AI inference runtime, executing AI models from JavaScript using WASI-NN plug-ins for inference tasks on personal devices and edge hardware, and as a container-compatible Wasm engine that launches OCI-compliant WebAssembly containers integrating with Docker and Kubernetes.
The runtime distinguishes itself through its ability to run unmodified Node.js applications by implementing their built-in APIs inside a WebAssembly sandbox, and through its support for the WebAssembly Component Model for loading, linking, and instantiating modular components. It provides ahead-of-time and just-in-time compilation to accelerate execution, along with non-blocking socket APIs for concurrent network communication. The plugin-based extension system allows runtime capabilities to be extended by loading dynamically linked native plug-ins written in Rust or C/C++, and the WASI-NN inference bridge connects WebAssembly modules to neural network backends for AI model execution.
The runtime supports embedding WebAssembly functions directly into host applications written in Go, Rust, or C without spawning separate processes, and provides host function import mechanisms for registering native functions as callable imports inside the sandbox. It offers database connectivity from within WebAssembly applications, with built-in drivers for Postgres, MySQL, Redis, and Qdrant, and integrates with cloud-native infrastructure by managing WebAssembly applications as containers within Kubernetes clusters using OCI runtimes. The runtime also supports server-side rendering of React applications, streaming HTML to clients for faster page loads, and provides secure sandbox execution with system resource isolation for running untrusted code.
Spin is a WebAssembly serverless framework and development toolchain for building and running portable microservices. It functions as an event-driven orchestrator and runtime that executes WebAssembly components, allowing developers to map HTTP requests, Redis messages, and cron schedules to specific modules. The project distinguishes itself by implementing a Wasm-based AI inference gateway, enabling components to perform model inference and generate text embeddings. It utilizes the WebAssembly Component Model and WASI for language-agnostic composition and portable host interfacing, while emp
wazero is a pure Go WebAssembly runtime that compiles and executes Wasm modules without CGO or any external dependencies. It provides a zero-dependency engine that runs on every Go-supported platform, including riscv64, making it a fully self-contained solution for embedding WebAssembly execution inside Go applications. The runtime offers two execution modes: an ahead-of-time compiler that translates WebAssembly modules into platform-specific machine code for near-native performance, and an interpreter that executes bytecode directly for maximum portability across architectures. Each module i
rusty_v8 is a Rust wrapper for the V8 JavaScript engine that allows for the embedding of a JavaScript runtime into native applications. It provides core components for managing engine bindings, memory allocation, sandboxed isolates, and the execution of WebAssembly modules. The project features a native host function bridge to map Rust functions to JavaScript objects and a dedicated memory allocator to manage thread-safe allocation and heap pressure. It includes a system for compiling and executing binary WebAssembly modules within the hosted native environment. The runtime covers capabiliti