bytecodealliance/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.
• 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.

Star-Verlauf