Top 6 WebAssembly Runtime tools for developer in 2023.

• One of the fastest WebAssembly VMs on the market
• WasmEdge feature extensions
  • Network sockets (Rust and JavaScript SDKs)
  • Async polling (for Rust Future and JS async)
  • Tensorflow inference (Tutorial)
  • Key value storage
  • Database connector
  • Gas meters for resource constraints
• JavaScript support
  • ES6 module and std API support
  • Implement JS APIs in Rust (Tutorial)
  • Import C native shared library functions as JS functions (Tutorial)
• Cloud native management and orchestration
  • CRI-O and Kubernetes compatibility
  • Sidecar apps in Kubernetes-based service meshes
  • Dapr microservices (Tutorial)
• Cross-platform support
  • Linux OSes dated back to 2010 for both x86 and ARM CPUs
  • Mac OS X for both x86 and m1 CPUs
  • Windows
  • Microkernel and RTOS (e.g., the highly secure seL4 microkernel)
• Easy extensibility
  • Build customized runtimes with native functions in C or GO
• Easy to embed into a host application
  • Embed WasmEdge functions in C, Go, Rust, Node.js and Python host applications
  • Embedded function runtime for service mesh proxies (e.g., proxy-wasm for Envoy and MOSN proxies)

Features Detail

• Enable programs to run in any programming language
• Enable extremely portable binaries to run unmodified on any "OS" supported by Wasmer (for example, Linux, macOS, Windows and FreeBSD).
• Act as a secure bridge for Wasm modules to interact with native "OS" functionality, via Application Binary Interfaces (ABIs) such as WASI and Emscripten

• Full compliant to the W3C WASM MVP
• Small runtime binary size (~85K for interpreter and ~50K for AOT) and low memory usage
• Near to native speed by AOT and JIT
• Self-implemented AOT module loader to enable AOT working on Linux, Windows, MacOS, Android, SGX and MCU systems
• Choices of WASM application libc support: the built-in libc subset for the embedded environment or WASI for the standard libc
• The simple C APIs to embed WAMR into host environment
• The mechanism to export native APIs to WASM applications
• Multiple modules as dependencies
• Multi-thread, pthread APIs and thread managemen
• Linux SGX (Intel Software Guard Extension) support
• Source debugging support
• WAMR-IDE (Experimental) to develop WebAssembly applications with build, run and debug support
• XIP (Execution In Place) support
• Berkeley/Posix Socket support

• Fast. Wasmtime is built on the optimizing [Cranelift] code generator to quickly generate high-quality machine code either at runtime or ahead-of-time. Wasmtime's runtime is also optimized for cases such as efficient instantiation, low-overhead transitions between the embedder and wasm, and scalability of concurrent instances.

• [Secure]. Wasmtime's development is strongly focused on the correctness of its implementation with 24/7 fuzzing donated by [Google's OSS Fuzz], leveraging Rust's API and runtime safety guarantees, careful design of features and APIs through an [RFC process], a [security policy] in place for when things go wrong, and a [release policy] for patching older versions as well. We follow best practices for defense-in-depth and known protections and mitigations for issues like Spectre. Finally, we're working to push the state-of-the-art by collaborating with academic researchers to formally verify critical parts of Wasmtime and Cranelift.

• [Configurable]. Wastime supports a rich set of APIs and build time configuration to provide many options such as further means of restricting WebAssembly beyond its basic guarantees such as its CPU and Memory consumption. Wasmtime also runs in tiny environments all the way up to massive servers with many concurrent instances.

• [WASI]. Wasmtime supports a rich set of APIs for interacting with the host environment through the WASI standard.

• [Standards Compliant]. Wasmtime passes the official WebAssembly test suite, implements the official C API of wasm, and implements future proposals to WebAssembly as well. Wasmtime developers are intimately engaged with the WebAssembly standards process all along the way too.

Designed for WebAssembly

AssemblyScript targets WebAssembly's feature set specifically, giving developers low-level control over their code.

Familiar TypeScript syntax

Its similarity with TypeScript makes it easy to compile to WebAssembly without learning a new language.

Right at your fingertips

Integrates with the existing Web ecosystem - no heavy toolchains to set up. Simply npm install it!

Porting

Compile your existing projects written in C or C++ — or any language that uses LLVM — to browsers, Node.js, or wasm runtimes.

APIs

Emscripten converts OpenGL into WebGL, and has support for familiar APIs like SDL, pthreads, and POSIX, as well as Web APIs and JavaScript.

Fast

Thanks to the combination of LLVM, Emscripten, Binaryen, and WebAssembly, the output is compact and runs at near-native speed.