Open-source alternatives to Wasmtime

Lucet is a WebAssembly runtime and sandboxing compiler that translates WebAssembly bytecode into native machine code. It serves as a secure execution environment and native code generator designed to run untrusted code while preventing unauthorized access to host system resources. The project focuses on high-performance sandboxing by using ahead-of-time compilation to achieve near-native execution speeds. It implements software-based fault isolation and a host-call interface to manage secure communication and data exchange between the isolated module and the external host application. The sy

V8 is a high-performance JavaScript and WebAssembly engine designed to compile and execute code within host applications. It functions as an embeddable scripting engine and just-in-time compiler, providing a portable library for integrating dynamic script execution into native software environments. The engine incorporates a WebAssembly runtime to execute compiled binary code for a stack-based virtual machine at near-native speeds. It enables native application scripting by allowing a JavaScript execution environment to be embedded directly into a native program to handle dynamic logic. The

Blink is a JIT-based instruction emulator and x86-64 Linux emulator designed to run Linux binaries and ELF files across different host operating systems and architectures. It functions as a binary execution sandbox and system call simulator, providing a controlled environment for running programs. The project distinguishes itself with a terminal user interface for monitoring execution, managing breakpoints, and visualizing JIT compilation paths. It supports self-modifying code through a cache-invalidating memory model and provides execution environment isolation using restricted directory ove

CoreCLR is a runtime environment that manages the execution, memory, and basic types for applications built on the .NET platform. It serves as a managed execution environment that handles low-level system interactions and provides primitive data types for high-level application code. The project functions as a JIT compilation engine and a garbage collected runtime. It translates intermediate language into machine code at runtime for execution on specific hardware and automatically reclaims unused memory to prevent leaks. The system covers broad capability areas including managed code executi

AsmJit is a runtime machine code generator and JIT compiler backend that translates high-level definitions into executable processor instructions. It provides a unified instruction emission API and an executable memory manager to allocate and protect virtual memory pages across multiple CPU architectures. The library functions as an assembly engine for x86 and ARM, supporting cross-platform assembly generation through a unified backend. It enables the creation of optimized machine code for different CPUs while maintaining a single codebase. The project covers low-level system abstractions in

Youki is a low-level container runtime written in Rust that creates and manages isolated containers according to Open Container Initiative specifications. It serves as an execution engine that can function as a rootless container manager or a pluggable Kubernetes CRI runtime to manage pods and containers within a cluster. The project distinguishes itself by providing a Wasm container runtime capable of executing WebAssembly modules as isolated workloads compatible with standard orchestration tools. It further supports a rootless execution model, allowing isolated environments to start as non-

Lunatic is a WebAssembly runtime and concurrent process manager that implements an Erlang-inspired model of lightweight concurrency and fault tolerance. It functions as a distributed actor system where isolated processes communicate via message passing across a network of linked nodes. The system utilizes a WebAssembly sandbox environment to isolate memory and restrict system call permissions for each individual process. This capability-based security model ensures that processes are sandboxed to safely execute untrusted code. The platform provides a fault-tolerant supervision tree for hiera

Judge0 is an online code execution engine and multi-language compiler API designed to compile and run source code within isolated sandboxes. It functions as an asynchronous job processor that handles code submissions via a queue and provides a secure environment to run arbitrary programs while preventing unauthorized system access. The system distinguishes itself through a multi-stage compilation pipeline and a flexible execution model that supports both single-file submissions and multi-file program execution via archives. It employs an isolate-based sandboxing mechanism to enforce strict ha

LuaJIT is a high-performance Lua language implementation and just-in-time compiler. It functions as an embedded scripting engine and dynamic binary translator that converts portable bytecode into native machine code during execution. The project focuses on high-performance scripting by translating bytecode into architecture-specific instructions to achieve execution speeds close to compiled C code. It utilizes a lightweight runtime environment designed for minimal memory overhead. The system supports binary data processing via bitwise operations and enables asynchronous task management throu

GraalVM is a polyglot virtual machine and high-performance runtime designed to execute multiple programming languages within a single environment. It functions as a JVM language toolkit for building language implementations, a native image compiler for transforming bytecode into standalone binaries, and an execution environment for LLVM bitcode and WebAssembly modules. The project is distinguished by its polyglot interoperability framework, which allows different languages to share data and execution state with low overhead. It utilizes self-modifying abstract syntax trees to optimize languag

cve-rs is a memory safety testing framework and vulnerability simulator designed to recreate buffer overflows and segmentation faults. It provides a set of safe memory primitives and a WebAssembly-based security sandbox to evaluate how programs handle unsafe memory access within an isolated execution environment. The project replaces raw pointer manipulation and type transmutation with functional alternatives, allowing for the simulation of memory-unsafe operations. It enables the reinterpretation of data types through memory representation manipulation rather than unsafe casting to study the

Isolated-vm is a library for creating secure, memory-isolated JavaScript execution environments within Node.js. It functions as a manager for the underlying engine, allowing developers to instantiate multiple independent execution contexts that share no memory or global state. This architecture is designed to support the execution of untrusted third-party code while preventing interference with the main application process. The project distinguishes itself by enforcing strict resource constraints, including memory limits and CPU execution timeouts, to ensure host system stability. It provides

Arrow-js is a reactive UI framework and server-side rendering system designed for building agentic interfaces. It functions as a reactive state manager and isomorphic routing engine, enabling the creation of web applications that utilize tagged template literals for efficient DOM updates. The project distinguishes itself by incorporating a WebAssembly code sandbox, which allows untrusted or AI-generated code to execute within a secure virtual machine to render interfaces without accessing the host DOM. It further enables agentic UI development by allowing AI agents to dynamically generate vie

ChakraCore is an embeddable JavaScript engine and high-performance scripting runtime. It provides a just-in-time compiler that converts JavaScript source code into optimized machine code during runtime to increase execution speed and throughput. The engine utilizes a multi-tiered compilation pipeline and tiered machine code generation to balance startup time with execution speed. Memory is managed via a concurrent garbage collector that reclaims unreachable objects on background threads to minimize application pauses. The project provides capabilities for embedded JavaScript execution and au

Extism is a cross-language WebAssembly plugin framework that lets applications written in any programming language load and execute plugins written in any other language. It provides a universal plugin system where host applications use idiomatic SDKs to load WebAssembly modules, call exported functions, and pass data back and forth, while plugin authors use development kits that handle memory management and host interaction so they can focus on business logic. The framework distinguishes itself through its comprehensive approach to cross-language integration, offering schema-driven binding g

This project provides a secure, containerized execution engine designed to run untrusted code within isolated environments. It functions as a library for integrating code interpretation into autonomous agents and intelligent assistant workflows, ensuring that host systems remain protected while enabling dynamic data processing and file manipulation. The platform distinguishes itself through a multi-backend architecture that abstracts diverse container runtimes, allowing for flexible deployment and automated backend failover. It supports interactive, multi-turn workflows by maintaining persist

This project is a multi-language compiler collection and cross-platform toolchain used to translate source code from various programming languages into optimized machine code for different hardware architectures. It provides a suite of tools including an optimizing compiler backend, a machine code generator, and a comprehensive runtime library suite that implements necessary execution environments and support functions. The system utilizes a multi-pass compilation pipeline and pluggable language front-ends to process source code into intermediate representations. It distinguishes itself throu

Dify-sandbox is a secure runtime environment designed for the execution of untrusted code snippets. It functions as a containerized sandbox that isolates processes from the host operating system, ensuring that arbitrary scripts can be run without granting them unauthorized access to sensitive data or critical system resources. The project distinguishes itself through a multi-layered security approach that combines kernel-level isolation with strict resource management. By utilizing Linux namespaces and container-based process isolation, it partitions system resources to maintain visibility bo

Boa is a high-performance JavaScript engine and parser designed to execute JavaScript code and analyze source code structure. It functions as a runtime environment for executing scripts to automate tasks or process data, providing both a command-line JavaScript interpreter and a tool for converting source code into abstract syntax trees. The engine is capable of compiling to WebAssembly, allowing the runtime to be deployed and executed within web browser environments. It includes an interactive read-eval-print loop for real-time logic testing and snippet execution via a terminal. The system

Lua is an embeddable scripting language written in ISO C, designed to be integrated into host applications for runtime customization. It provides a C-based scripting engine and a prototype-based object model that utilizes associative arrays and metatables to implement inheritance and complex data structures. The language features a cooperative multitasking system that manages concurrent execution threads via coroutines and an incremental garbage collector for automatic memory management. It includes a safe code sandbox to isolate global state and run untrusted scripts within a protected envir

Baserow is a self-hosted, no-code relational database platform built on PostgreSQL. It provides a spreadsheet-like interface for structuring and managing data without writing code, while exposing all database resources via a REST API to support headless architectures. The platform distinguishes itself by integrating large language models and embedding servers to power AI assistants and automated data generation. It further extends its utility as a no-code application builder, allowing users to create custom internal portals, dashboards, and business tools using visual logic and managed data.

This project provides a full Python interpreter compiled to WebAssembly, enabling the execution of Python code and scientific libraries directly within web browsers and server-side environments. By bridging the gap between language runtimes, it allows developers to run computational tasks, manage packages, and perform data analysis in client-side environments without requiring a backend server. The platform distinguishes itself through a comprehensive foreign function interface that enables bidirectional data exchange, object proxying, and function calling between Python and JavaScript. It in

Whisper.cpp is a high-performance, local-first speech recognition engine designed to run large-scale machine learning models on consumer hardware. It functions as a portable library that converts audio into text, supporting both static file transcription and real-time stream processing. By utilizing a lightweight inference engine and weight quantization, the project minimizes memory and compute overhead, allowing for efficient execution without reliance on external cloud APIs or internet connectivity. The project distinguishes itself through a hardware-agnostic compute abstraction that offloa

JupyterLite is a WebAssembly-based interactive notebook environment that enables browser-based computing without a backend server. It provides a client-side data science sandbox where users can execute programming language kernels and run interactive notebooks entirely within the web browser. The project allows for the creation of tailored distributions by pre-installing specific language packages, bundling custom wheels, and applying environment configurations. It supports the generation of static sites that can be deployed to any standard HTTP host, including the ability to package the envi

AssemblyScript is a compiler and tooling suite used for WebAssembly module development. It converts a subset of TypeScript syntax into binary modules to achieve high execution speeds and cross-platform binary execution. The project focuses on translating typed source code into the compact binary format required by WebAssembly runtimes. This allows for the movement of computationally heavy logic into binary modules for browser performance optimization and execution across different operating systems. The compilation process involves TypeScript-compatible syntax analysis and the generation of

Linera is a multi-chain smart contract platform designed for horizontal scalability through a microchain-based distributed ledger. By partitioning state into independent, parallel chains that share a common validator set, the protocol enables high-performance execution of modular applications. The system utilizes a WebAssembly-based runtime to ensure secure, platform-independent execution of contract logic across the network. The platform distinguishes itself through an asynchronous messaging framework that coordinates state changes between chains by queuing messages for execution in subseque