# bytecodealliance/wasm-micro-runtime

**Attribution required: if you use, quote, or summarise this content, you must credit and link back to [awesome-repositories.com](https://awesome-repositories.com/repository/bytecodealliance-wasm-micro-runtime).**

5,788 stars · 759 forks · C · apache-2.0

## Links

- GitHub: https://github.com/bytecodealliance/wasm-micro-runtime
- awesome-repositories: https://awesome-repositories.com/repository/bytecodealliance-wasm-micro-runtime.md

## Topics

`aot` `assembly-script` `embedded` `interpreter` `iot` `jit` `pthread` `runtime` `sgx` `wasi-nn` `wasi-threads` `wasm` `wasm-socket` `webassembly`

## Tags

### Programming Languages & Runtimes

- [WebAssembly](https://awesome-repositories.com/f/programming-languages-runtimes/runtime-execution-environments/webassembly.md) — Provides a lightweight C runtime for executing WebAssembly bytecode on resource-constrained devices. ([source](https://bytecodealliance.github.io/wamr.dev))
- [Compact WebAssembly Interpreters](https://awesome-repositories.com/f/programming-languages-runtimes/compact-webassembly-interpreters.md) — Executes WebAssembly modules using a small interpreter that keeps peak memory usage as low as 365 kilobytes. ([source](https://github.com/bytecodealliance/wasm-micro-runtime/wiki/Performance))
- [Bytecode Interpreters](https://awesome-repositories.com/f/programming-languages-runtimes/compiler-interpreter-internals/compiler-infrastructure/compilers/bytecode-interpreters.md) — Runs WebAssembly bytecode through a bytecode interpreter prioritizing minimal memory usage.
- [Wasm](https://awesome-repositories.com/f/programming-languages-runtimes/compiler-interpreter-internals/compiler-infrastructure/compilers/bytecode-interpreters/wasm.md) — Runs WebAssembly bytecode through a bytecode interpreter to prioritize minimal memory usage over execution speed. ([source](https://bytecodealliance.github.io/wamr.dev/blog/introduction-to-wamr-running-modes/))
- [Ahead-Of-Time Compilers](https://awesome-repositories.com/f/programming-languages-runtimes/compiler-interpreter-internals/compiler-toolchains/execution-mode-engines/ahead-of-time-kernel-compilation/ahead-of-time-compilers.md) — Compiles WebAssembly bytecode to native machine code before execution for near-native performance. ([source](https://github.com/bytecodealliance/wasm-micro-runtime/wiki/Performance))
- [WebAssembly Execution Modes](https://awesome-repositories.com/f/programming-languages-runtimes/compiler-interpreter-internals/compiler-toolchains/execution-mode-engines/webassembly-execution-modes.md) — Supports interpreter, AOT, and JIT execution modes selectable per WebAssembly module.
- [Cross-Platform WebAssembly Runtimes](https://awesome-repositories.com/f/programming-languages-runtimes/cross-platform-webassembly-runtimes.md) — Runs WebAssembly modules on Linux, Windows, macOS, Android, Zephyr, NuttX, and other embedded platforms. ([source](https://cdn.jsdelivr.net/gh/bytecodealliance/wasm-micro-runtime@main/README.md))
- [WebAssembly Function Execution](https://awesome-repositories.com/f/programming-languages-runtimes/generator-functions/function-execution-models/webassembly-function-execution.md) — Provides C APIs to create execution environments and run WebAssembly functions from native code. ([source](https://bytecodealliance.github.io/wamr.dev/blog/understand-the-wamr-stacks/))
- [Host Function Exposure](https://awesome-repositories.com/f/programming-languages-runtimes/host-function-exposure.md) — Exposes native host functions to WebAssembly modules and calls Wasm functions from the host side.
- [Host Runtime Integration](https://awesome-repositories.com/f/programming-languages-runtimes/host-runtime-integration.md) — Integrates the WebAssembly runtime into custom host environments using simple C APIs. ([source](https://cdn.jsdelivr.net/gh/bytecodealliance/wasm-micro-runtime@main/README.md))
- [Wasm](https://awesome-repositories.com/f/programming-languages-runtimes/just-in-time-compilation/wasm.md) — Compiles WebAssembly bytecode to native code at runtime to balance platform-agnostic distribution with near-native performance. ([source](https://bytecodealliance.github.io/wamr.dev/blog/introduction-to-wamr-running-modes/))
- [Multi-Mode WebAssembly Execution Engines](https://awesome-repositories.com/f/programming-languages-runtimes/multi-mode-webassembly-execution-engines.md) — Supports fast and classic interpreters, ahead-of-time compilation, and just-in-time compilation with tiered optimization for flexible execution. ([source](https://cdn.jsdelivr.net/gh/bytecodealliance/wasm-micro-runtime@main/README.md))
- [Optimized WebAssembly Interpreters](https://awesome-repositories.com/f/programming-languages-runtimes/optimized-webassembly-interpreters.md) — Executes WebAssembly modules using an optimized interpreter that delivers high throughput while keeping memory usage moderate. ([source](https://github.com/bytecodealliance/wasm-micro-runtime/wiki/Performance))
- [Cross-Platform Wasm Runtimes](https://awesome-repositories.com/f/programming-languages-runtimes/runtime-execution-environments/runtime-environments/runtime-management-utilities/pre-release-runtime-installers/multi-version-installations/platform-runtimes/cross-platform-wasm-runtimes.md) — Loads and executes WebAssembly modules on Linux, Windows, macOS, Android, and embedded platforms.
- [Ahead-of-Time Wasm Execution](https://awesome-repositories.com/f/programming-languages-runtimes/runtime-execution-environments/webassembly/embedded-wasm-runtimes/ahead-of-time-wasm-execution.md) — Compiles WebAssembly bytecode into native machine code before runtime for near-native speed with a small memory footprint. ([source](https://bytecodealliance.github.io/wamr.dev/blog/introduction-to-wamr-running-modes/))
- [Native API Export to Wasm](https://awesome-repositories.com/f/programming-languages-runtimes/runtime-execution-environments/webassembly/embedded-wasm-runtimes/native-api-export-to-wasm.md) — Registers host-side functions so WebAssembly modules can call them during execution. ([source](https://cdn.jsdelivr.net/gh/bytecodealliance/wasm-micro-runtime@main/README.md))
- [Embedded WebAssembly Runtimes](https://awesome-repositories.com/f/programming-languages-runtimes/runtime-execution-environments/webassembly/embedded-webassembly-runtimes.md) — Ships a runtime optimized for running WebAssembly on resource-constrained embedded devices. ([source](https://cdn.jsdelivr.net/gh/bytecodealliance/wasm-micro-runtime@main/README.md))
- [Tiered JIT Compilation](https://awesome-repositories.com/f/programming-languages-runtimes/compiler-interpreter-internals/compiler-infrastructure/compiler-optimizations/just-in-time-compilation/tiered-jit-compilation.md) — Switches from a lightweight fast JIT to a high-performance LLVM JIT during execution for optimal throughput.
- [WebAssembly](https://awesome-repositories.com/f/programming-languages-runtimes/compiler-interpreter-internals/compiler-infrastructure/compilers/bytecode-interpreters/webassembly.md) — Provides a compact interpreter for WebAssembly bytecode with minimal memory usage.
- [In-Place WebAssembly Execution Engines](https://awesome-repositories.com/f/programming-languages-runtimes/in-place-webassembly-execution-engines.md) — Runs WebAssembly modules directly from flash or read-only memory without copying them to random-access memory first. ([source](https://cdn.jsdelivr.net/gh/bytecodealliance/wasm-micro-runtime@main/README.md))
- [WebAssembly JIT Compilers](https://awesome-repositories.com/f/programming-languages-runtimes/jit-compilation-engines/webassembly-jit-compilers.md) — Compiles WebAssembly bytecode to native code at runtime with tiered JIT optimization.
- [WebAssembly Multi-Threading](https://awesome-repositories.com/f/programming-languages-runtimes/language-features-paradigms/concurrency-models/concurrency/execution-models/multi-threaded-execution/webassembly-multi-threading.md) — Supports multi-threaded WebAssembly execution with pthread API integration. ([source](https://cdn.jsdelivr.net/gh/bytecodealliance/wasm-micro-runtime@main/README.md))
- [Host-Wasm Shared Memory Buffers](https://awesome-repositories.com/f/programming-languages-runtimes/runtime-execution-environments/webassembly/embedded-wasm-runtimes/host-wasm-shared-memory-buffers.md) — Allocates a buffer from the Wasm heap so both host and module can read and write the same memory. ([source](https://bytecodealliance.github.io/wamr.dev/blog/understand-the-wamr-heaps/))
- [Multi-Threading Runtimes](https://awesome-repositories.com/f/programming-languages-runtimes/runtime-execution-environments/webassembly/multi-threading-runtimes.md) — Manages concurrent WebAssembly execution with pthread API and advanced proposal support.
- [Post-MVP Features](https://awesome-repositories.com/f/programming-languages-runtimes/runtime-execution-environments/webassembly/post-mvp-features.md) — Implements advanced WebAssembly proposals like SIMD, reference types, and garbage collection. ([source](https://cdn.jsdelivr.net/gh/bytecodealliance/wasm-micro-runtime@main/README.md))
- [WASI-libc Memory Allocators](https://awesome-repositories.com/f/programming-languages-runtimes/wasi-implementations/wasi-libc-memory-allocators.md) — Uses the WASI-libc memory allocator to handle malloc and free calls from the Wasm module. ([source](https://bytecodealliance.github.io/wamr.dev/blog/understand-the-wamr-heaps/))

### DevOps & Infrastructure

- [WebAssembly](https://awesome-repositories.com/f/devops-infrastructure/cross-platform-deployments/webassembly.md) — Runs WebAssembly modules across Linux, Windows, macOS, Android, and embedded RTOS platforms.

### Web Development

- [Lifecycle Controllers](https://awesome-repositories.com/f/web-development/dynamic-loading-strategies/binary-module-loaders/webassembly-module-loaders/lifecycle-controllers.md) — Provides C APIs for explicit loading, instantiation, and unloading of WebAssembly modules.
- [Lifecycle Managers](https://awesome-repositories.com/f/web-development/dynamic-loading-strategies/binary-module-loaders/webassembly-module-loaders/lifecycle-managers.md) — Provides explicit C APIs for loading, instantiating, and unloading WebAssembly modules. ([source](https://bytecodealliance.github.io/wamr.dev))

### Artificial Intelligence & ML

- [Wasm Execution Stack Buffers](https://awesome-repositories.com/f/artificial-intelligence-ml/tiled-processing/cooperative-tile-processors/shared-memory-stack-managers/wasm-execution-stack-buffers.md) — Supplies a buffer for the Wasm function call stack during execution from the host or runtime. ([source](https://bytecodealliance.github.io/wamr.dev/blog/the-wamr-memory-model/))

### Data & Databases

- [In-Place Execution from Flash](https://awesome-repositories.com/f/data-databases/data-access-querying/memory-mapped-file-access/flash-memory-access/in-place-execution-from-flash.md) — Executes WebAssembly modules directly from flash memory without copying to RAM.

### Development Tools & Productivity

- [Wasm-Native Stack Merging](https://awesome-repositories.com/f/development-tools-productivity/dynamic-variable-evaluators/stack-frame-inspectors/native-stack-unwinders/wasm-native-stack-merging.md) — Merges WebAssembly call frames into the native stack during AOT and JIT execution, eliminating a separate stack buffer.
- [WebAssembly Native Stack Integration](https://awesome-repositories.com/f/development-tools-productivity/dynamic-variable-evaluators/stack-frame-inspectors/native-stack-unwinders/webassembly-native-stack-integration.md) — Integrates WebAssembly call frames directly into the native stack during AOT and JIT execution. ([source](https://bytecodealliance.github.io/wamr.dev/blog/understand-the-wamr-stacks/))
- [WebAssembly Stack Frame Managers](https://awesome-repositories.com/f/development-tools-productivity/dynamic-variable-evaluators/stack-frame-inspectors/webassembly-stack-frame-managers.md) — Manages a dedicated stack buffer for WebAssembly call frames during interpreter execution. ([source](https://bytecodealliance.github.io/wamr.dev/blog/understand-the-wamr-stacks/))
- [WebAssembly AOT Compilers](https://awesome-repositories.com/f/development-tools-productivity/native-compilation/native-aot-compilation/webassembly-aot-compilers.md) — Compiles WebAssembly bytecode to native machine code ahead of time for near-native performance.

### Networking & Communication

- [Socket Communication](https://awesome-repositories.com/f/networking-communication/socket-communication.md) — Lets WebAssembly modules use standard socket APIs for network communication. ([source](https://cdn.jsdelivr.net/gh/bytecodealliance/wasm-micro-runtime@main/README.md))

### Operating Systems & Systems Programming

- [Custom Memory Allocators](https://awesome-repositories.com/f/operating-systems-systems-programming/kernel-core-internals/process-and-memory-management/memory-management/allocation-strategies/dynamic-memory-allocation/custom-memory-allocators.md) — Accepts user-provided malloc and free to control how the runtime allocates memory. ([source](https://bytecodealliance.github.io/wamr.dev/blog/the-wamr-memory-model/))
- [Instance Memory Managers](https://awesome-repositories.com/f/operating-systems-systems-programming/kernel-core-internals/process-and-memory-management/memory-management/allocation-strategies/dynamic-memory-allocation/custom-memory-allocators/linear-memory-managers/instance-memory-managers.md) — Allocates memory for an instance's structure, functions, linear memory, and exports, freed when destroyed. ([source](https://bytecodealliance.github.io/wamr.dev/blog/the-wamr-memory-model/))
- [Module Lifecycle Memory Managers](https://awesome-repositories.com/f/operating-systems-systems-programming/kernel-core-internals/process-and-memory-management/memory-management/allocation-strategies/dynamic-memory-allocation/custom-memory-allocators/managed-memory-allocators/module-lifecycle-memory-managers.md) — Allocates and frees memory for a module's structure, file buffer, and compiled code when loaded or unloaded. ([source](https://bytecodealliance.github.io/wamr.dev/blog/the-wamr-memory-model/))
- [WebAssembly Memory Allocators](https://awesome-repositories.com/f/operating-systems-systems-programming/kernel-core-internals/process-and-memory-management/memory-management/allocation-strategies/dynamic-memory-allocation/custom-memory-allocators/managed-memory-allocators/pluggable-memory-allocators/webassembly-memory-allocators.md) — Supports fixed-pool, custom, and system malloc strategies for WebAssembly runtime memory.
- [Wasm Instance Heap Allocators](https://awesome-repositories.com/f/operating-systems-systems-programming/kernel-core-internals/process-and-memory-management/memory-management/allocation-strategies/dynamic-memory-allocation/custom-memory-allocators/managed-memory-allocators/wasm-instance-heap-allocators.md) — Provides a heap inside Wasm linear memory for dynamic allocation by the module or host. ([source](https://bytecodealliance.github.io/wamr.dev/blog/understand-the-wamr-heaps/))
- [Fixed-Size Memory Pool Managers](https://awesome-repositories.com/f/operating-systems-systems-programming/kernel-core-internals/process-and-memory-management/memory-management/allocation-strategies/dynamic-memory-allocation/custom-memory-allocators/preallocated-memory-pools/fixed-size-memory-pool-managers.md) — Restricts all runtime memory to a pre-allocated region for predictable behavior on constrained devices. ([source](https://bytecodealliance.github.io/wamr.dev/blog/the-wamr-memory-model/))
- [Fixed-Pool Allocators](https://awesome-repositories.com/f/operating-systems-systems-programming/kernel-core-internals/process-and-memory-management/memory-management/allocation-strategies/dynamic-memory-allocation/custom-memory-allocators/preallocated-memory-pools/fixed-size-memory-pool-managers/fixed-pool-allocators.md) — Provides a fixed-pool memory allocation strategy for predictable behavior on constrained devices.
- [Host-Managed Wasm Heaps](https://awesome-repositories.com/f/operating-systems-systems-programming/kernel-core-internals/process-and-memory-management/memory-management/allocation-strategies/dynamic-memory-allocation/memory-allocation-tracers/heap-allocation-strategies/dynamic-heap-allocators/host-managed-wasm-heaps.md) — Uses a built-in allocator to manage a heap when the Wasm module does not export malloc and free. ([source](https://bytecodealliance.github.io/wamr.dev/blog/understand-the-wamr-heaps/))
- [Platform Default Allocators](https://awesome-repositories.com/f/operating-systems-systems-programming/kernel-core-internals/process-and-memory-management/memory-management/allocation-strategies/dynamic-memory-allocation/system-memory-allocation/platform-default-allocators.md) — Uses the platform's default malloc and free for all runtime memory allocations. ([source](https://bytecodealliance.github.io/wamr.dev/blog/the-wamr-memory-model/))
- [Runtime Global Memory Managers](https://awesome-repositories.com/f/operating-systems-systems-programming/virtual-memory-management/runtime-memory-limits/runtime-global-memory-managers.md) — Holds memory for native API registration, execution stack, and threading support across the runtime's lifecycle. ([source](https://bytecodealliance.github.io/wamr.dev/blog/the-wamr-memory-model/))

### Software Engineering & Architecture

- [Wasm Execution Mode Selection](https://awesome-repositories.com/f/software-engineering-architecture/execution-control/execution-modes/wasm-execution-mode-selection.md) — Sets interpreter, ahead-of-time, or just-in-time execution mode for individual loaded modules or as a runtime default. ([source](https://bytecodealliance.github.io/wamr.dev/blog/introduction-to-wamr-running-modes/))
- [Dynamic JIT Tiering](https://awesome-repositories.com/f/software-engineering-architecture/function-execution-engines/just-in-time-compilers/dynamic-jit-tiering.md) — Switches from a lightweight fast JIT to a high-performance LLVM JIT during execution for quick startup and optimal throughput. ([source](https://bytecodealliance.github.io/wamr.dev/blog/introduction-to-wamr-running-modes/))