Pros of Wasmtime

• Performance: Wasmtime is designed to be a high-performance WebAssembly runtime, with a focus on efficient execution and low overhead.
• Modularity: Wasmtime is built with a modular architecture, allowing for easy integration with other components and the ability to customize the runtime.
• Ecosystem: Wasmtime is part of the Bytecode Alliance, a collaboration of companies and individuals working to improve the WebAssembly ecosystem.

Cons of Wasmtime

• Complexity: Wasmtime is a more complex and feature-rich runtime compared to Wasmi, which may make it more challenging to set up and configure.
• Learning Curve: Developers new to WebAssembly may find the Wasmtime ecosystem and documentation more daunting than the simpler Wasmi.
• Overhead: Wasmtime's focus on performance and features may come with some additional overhead compared to the more lightweight Wasmi.

Code Comparison

Wasmi:

let mut store = Store::new();
let module = Module::from_bytes(&store, &wasm_bytes)?;
let instance = Instance::new(&store, &module, &[])?;
let result = instance.get_export("add")?.get_func().unwrap()(&[42.into(), 24.into()])?;

Wasmtime:

let mut config = Config::new();
let engine = Engine::new(&config);
let module = Module::from_binary(&engine, &wasm_bytes)?;
let mut store = Store::new(&engine);
let instance = Instance::new(&mut store, &module, &[])?;
let result = instance.get_export("add")?.get_func().unwrap()(&mut store, &[42.into(), 24.into()])?;

Pros of WebAssembly/WASI

• Provides a standardized interface for WebAssembly modules to interact with the host environment, making it easier to write portable and secure WebAssembly applications.
• Supports a wide range of host environments, including the web, servers, and embedded systems.
• Offers a rich set of system APIs, including file I/O, networking, and process management, allowing WebAssembly modules to perform a wide range of tasks.

Cons of WebAssembly/WASI

• The WASI specification is still evolving, and there may be some inconsistencies or missing features compared to more mature system APIs.
• Adoption of WASI may be slower than some other WebAssembly-related projects, as it requires coordination and agreement among various stakeholders.
• The learning curve for developers who are new to WebAssembly and WASI may be steeper compared to more established technologies.

Code Comparison

wasmi-labs/wasmi

fn execute_module(
    module: &Module,
    imports: &ModuleImportResolver,
    params: &[RuntimeValue],
) -> Result<Vec<RuntimeValue>, Error> {
    let mut instance = ModuleInstance::new(module, imports)?;
    instance.run_start_function()?;
    instance.invoke_export("_start", params)
}

WebAssembly/WASI

fn run_wasm(wasm_bytes: &[u8]) -> Result<(), anyhow::Error> {
    let mut store = Store::new(&Engine::default());
    let module = Module::new(&store, wasm_bytes)?;
    let instance = Instance::new(&module, &imports(&mut store))?;
    let start = instance.get_export("_start").unwrap().into_func().unwrap();
    start.call(&mut store, &[])?;
    Ok(())
}

Pros of WebAssembly/wabt

• Provides a comprehensive set of tools for working with WebAssembly, including a disassembler, assembler, and interpreter.
• Supports a wide range of WebAssembly features, including the latest version of the specification.
• Offers a well-documented and actively maintained codebase.

Cons of WebAssembly/wabt

• May have a larger codebase and dependencies compared to wasmi-labs/wasmi, which could make it less suitable for certain use cases.
• May have a steeper learning curve for developers unfamiliar with the WebAssembly ecosystem.

Code Comparison

WebAssembly/wabt (wabt_wasm2wat.cc):

void WasmBinaryReader::OnFunctionBody(uint32_t index) {
  if (options_->read_debug_names) {
    ReadLocalNames(index);
  }

  stream_->WriteMemoryDump(data_, end_ - data_, "code", index);
  ReadFunctionBody(index);
}

wasmi-labs/wasmi (lib.rs):

pub fn execute_module(
    module: &Module,
    args: &[RuntimeValue],
) -> Result<Vec<RuntimeValue>, Error> {
    let mut instance = ModuleInstance::new(module)?;
    let main_function = instance.find_export_by_name("main")
        .ok_or(Error::Function("main"))?
        .as_func()
        .ok_or(Error::Function("main"))?;
    main_function.invoke(args)
}

Pros of wasm-bindgen

• Focuses on JavaScript interoperability, making it easier to use WebAssembly in web applications
• Provides high-level bindings and automatic generation of JavaScript glue code
• Supports a wide range of data types and complex structures

Cons of wasm-bindgen

• Limited to Rust-to-WebAssembly compilation, not suitable for other languages
• May introduce additional overhead due to the generated bindings
• Requires learning a specific set of macros and attributes

Code Comparison

wasm-bindgen:

#[wasm_bindgen]
pub fn add(a: i32, b: i32) -> i32 {
    a + b
}

wasmi:

pub fn add(a: i32, b: i32) -> i32 {
    a + b
}

Summary

wasm-bindgen is specifically designed for Rust-to-WebAssembly compilation with a focus on JavaScript interoperability. It provides high-level bindings and automatic generation of glue code, making it easier to use WebAssembly in web applications. However, it's limited to Rust and may introduce some overhead.

wasmi, on the other hand, is a WebAssembly interpreter that can be used in various contexts, not just web applications. It doesn't provide the same level of JavaScript interoperability but offers more flexibility in terms of language support and execution environments.