awesome-repositories.com
Blog
MCP
awesome-repositories.com

Discover the best open-source repositories with AI-powered search.

ExploreCurated searchesOpen-source alternativesSelf-hosted softwareBlogSitemap
ProjectMCP serverAboutHow we rankPress
LegalPrivacyTerms
© 2026 Bringes Technology SRL·VAT RO45896025·hello@awesome-repositories.com
bytecodealliance avatar

bytecodealliance/wasm-micro-runtime

0
View on GitHub↗

Wasm Micro Runtime

Features

  • WebAssembly - Provides a lightweight C runtime for executing WebAssembly bytecode on resource-constrained devices.
  • WebAssembly - Runs WebAssembly modules across Linux, Windows, macOS, Android, and embedded RTOS platforms.
  • Compact WebAssembly Interpreters - Executes WebAssembly modules using a small interpreter that keeps peak memory usage as low as 365 kilobytes.
  • Bytecode Interpreters - Runs WebAssembly bytecode through a bytecode interpreter prioritizing minimal memory usage.

AI search

Explore more awesome repositories

Describe what you need in plain English — the AI ranks thousands of curated open-source projects by relevance.

Start searching with AI
  • Wasm - Runs WebAssembly bytecode through a bytecode interpreter to prioritize minimal memory usage over execution speed.
  • Ahead-Of-Time Compilers - Compiles WebAssembly bytecode to native machine code before execution for near-native performance.
  • WebAssembly Execution Modes - Supports interpreter, AOT, and JIT execution modes selectable per WebAssembly module.
  • Cross-Platform WebAssembly Runtimes - Runs WebAssembly modules on Linux, Windows, macOS, Android, Zephyr, NuttX, and other embedded platforms.
  • WebAssembly Function Execution - Provides C APIs to create execution environments and run WebAssembly functions from native code.
  • Host Function Exposure - Exposes native host functions to WebAssembly modules and calls Wasm functions from the host side.
  • Host Runtime Integration - Integrates the WebAssembly runtime into custom host environments using simple C APIs.
  • Wasm - Compiles WebAssembly bytecode to native code at runtime to balance platform-agnostic distribution with near-native performance.
  • Multi-Mode WebAssembly Execution Engines - Supports fast and classic interpreters, ahead-of-time compilation, and just-in-time compilation with tiered optimization for flexible execution.
  • Optimized WebAssembly Interpreters - Executes WebAssembly modules using an optimized interpreter that delivers high throughput while keeping memory usage moderate.
  • Cross-Platform Wasm Runtimes - Loads and executes WebAssembly modules on Linux, Windows, macOS, Android, and embedded platforms.
  • Ahead-of-Time Wasm Execution - Compiles WebAssembly bytecode into native machine code before runtime for near-native speed with a small memory footprint.
  • Native API Export to Wasm - Registers host-side functions so WebAssembly modules can call them during execution.
  • Embedded WebAssembly Runtimes - Ships a runtime optimized for running WebAssembly on resource-constrained embedded devices.
  • Lifecycle Controllers - Provides C APIs for explicit loading, instantiation, and unloading of WebAssembly modules.
  • Lifecycle Managers - Provides explicit C APIs for loading, instantiating, and unloading WebAssembly modules.
  • Wasm Execution Stack Buffers - Supplies a buffer for the Wasm function call stack during execution from the host or runtime.
  • In-Place Execution from Flash - Executes WebAssembly modules directly from flash memory without copying to RAM.
  • Wasm-Native Stack Merging - Merges WebAssembly call frames into the native stack during AOT and JIT execution, eliminating a separate stack buffer.
  • WebAssembly Native Stack Integration - Integrates WebAssembly call frames directly into the native stack during AOT and JIT execution.
  • WebAssembly Stack Frame Managers - Manages a dedicated stack buffer for WebAssembly call frames during interpreter execution.
  • WebAssembly AOT Compilers - Compiles WebAssembly bytecode to native machine code ahead of time for near-native performance.
  • Socket Communication - Lets WebAssembly modules use standard socket APIs for network communication.
  • Custom Memory Allocators - Accepts user-provided malloc and free to control how the runtime allocates memory.
  • Instance Memory Managers - Allocates memory for an instance's structure, functions, linear memory, and exports, freed when destroyed.
  • Module Lifecycle Memory Managers - Allocates and frees memory for a module's structure, file buffer, and compiled code when loaded or unloaded.
  • WebAssembly Memory Allocators - Supports fixed-pool, custom, and system malloc strategies for WebAssembly runtime memory.
  • Wasm Instance Heap Allocators - Provides a heap inside Wasm linear memory for dynamic allocation by the module or host.
  • Fixed-Size Memory Pool Managers - Restricts all runtime memory to a pre-allocated region for predictable behavior on constrained devices.
  • Fixed-Pool Allocators - Provides a fixed-pool memory allocation strategy for predictable behavior on constrained devices.
  • Host-Managed Wasm Heaps - Uses a built-in allocator to manage a heap when the Wasm module does not export malloc and free.
  • Platform Default Allocators - Uses the platform's default malloc and free for all runtime memory allocations.
  • Runtime Global Memory Managers - Holds memory for native API registration, execution stack, and threading support across the runtime's lifecycle.
  • Tiered JIT Compilation - Switches from a lightweight fast JIT to a high-performance LLVM JIT during execution for optimal throughput.
  • WebAssembly - Provides a compact interpreter for WebAssembly bytecode with minimal memory usage.
  • In-Place WebAssembly Execution Engines - Runs WebAssembly modules directly from flash or read-only memory without copying them to random-access memory first.
  • WebAssembly JIT Compilers - Compiles WebAssembly bytecode to native code at runtime with tiered JIT optimization.
  • WebAssembly Multi-Threading - Supports multi-threaded WebAssembly execution with pthread API integration.
  • Host-Wasm Shared Memory Buffers - Allocates a buffer from the Wasm heap so both host and module can read and write the same memory.
  • Multi-Threading Runtimes - Manages concurrent WebAssembly execution with pthread API and advanced proposal support.
  • Post-MVP Features - Implements advanced WebAssembly proposals like SIMD, reference types, and garbage collection.
  • WASI-libc Memory Allocators - Uses the WASI-libc memory allocator to handle malloc and free calls from the Wasm module.
  • Wasm Execution Mode Selection - Sets interpreter, ahead-of-time, or just-in-time execution mode for individual loaded modules or as a runtime default.
  • Dynamic JIT Tiering - Switches from a lightweight fast JIT to a high-performance LLVM JIT during execution for quick startup and optimal throughput.
  • Container Runtimes and Platforms - WebAssembly micro runtime.
  • Runtime and Embeddings - Standalone WebAssembly runtime for embedded devices.
    • 5,990 stars·820 forks·C·Apache-2.0·26 views

    Star history

    Star history chart for bytecodealliance/wasm-micro-runtimeStar history chart for bytecodealliance/wasm-micro-runtime

    How this analysis was created: This summary and feature list are AI-generated from collected project material and can contain mistakes. Stars, license and language are imported from GitHub. Inclusion does not mean that we have tested or audited this project. Check the source documentation for any feature you depend on. Learn more on our About page.

    Projects sharing features with Wasm Micro Runtime

    These projects share indexed features with Wasm Micro Runtime. Shared tags can include platform or build tooling; verify the primary use case before treating a result as a replacement.
    • wasmedge/wasmedgeWasmEdge avatar

      WasmEdge/WasmEdge

      10,665View on GitHub↗

      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 har

      C++artificial-intelligencecloudcloud-native
      View on GitHub↗10,665
    • wazero/wazerowazero avatar

      wazero/wazero

      6,225View on GitHub↗

      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

      Goahead-of-timecompilergo
      View on GitHub↗6,225
    • bytecodealliance/lucetbytecodealliance avatar

      bytecodealliance/lucet

      4,048View on GitHub↗

      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

      Rustassemblyscriptrustwasi
      View on GitHub↗4,048
    • denoland/rusty_v8denoland avatar

      denoland/rusty_v8

      3,866View on GitHub↗

      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

      Rustrustv8
      View on GitHub↗3,866
    Compare all 30 related projects→

    Frequently asked questions

    What are the main features of bytecodealliance/wasm-micro-runtime?

    The main features of bytecodealliance/wasm-micro-runtime are: WebAssembly, Compact WebAssembly Interpreters, Bytecode Interpreters, Wasm, Ahead-Of-Time Compilers, WebAssembly Execution Modes, Cross-Platform WebAssembly Runtimes, WebAssembly Function Execution.

    Which projects share features with bytecodealliance/wasm-micro-runtime?

    Projects with overlapping indexed features include: wasmedge/wasmedge — WasmEdge is an extensible WebAssembly runtime that executes WebAssembly bytecode in a secure sandbox for cloud, edge,… wazero/wazero — wazero is a pure Go WebAssembly runtime that compiles and executes Wasm modules without CGO or any external… bytecodealliance/lucet — Lucet is a WebAssembly runtime and sandboxing compiler that translates WebAssembly bytecode into native machine code.… denoland/rusty_v8 — rusty_v8 is a Rust wrapper for the V8 JavaScript engine that allows for the embedding of a JavaScript runtime into… bytecodealliance/wasmtime — Wasmtime is a WebAssembly runtime and sandboxed bytecode executor designed to run WebAssembly bytecode on a host… assemblyscript/assemblyscript — AssemblyScript is a compiler and tooling suite used for WebAssembly module development. It converts a subset of…