wasm-bridge

Goals

The goal of this crate is to "run wasmtime on the web".

Since wasmtime cannot actually run on the web, the goal is to provide a unified API for both sys (desktop) and js (web) runtimes.

How to use

The provided API is identical to wasmtime's API, so read wasmtime's documentation on how to use this crate.

Here is an example of adding three using a WASM module compiled from WAT, using wasm-bridge version 0.1.1:

```rust use wasm_bride::*;

fn add_three(number: i32) -> Result { let mut store = Store::<()>::default();

let wat = r#"
  (module
    (func $add_three (export "add_three")
      (param $p0 i32) (result i32)
      (i32.add (local.get $p0) (i32.const 3))
    )
  )
"#;
let module = Module::new(store.engine(), wat.as_bytes())?;

let instance = Instance::new(&mut store, &module, &[])?;
let add_three_wasm = instance.get_typed_func::<i32, i32>(&mut store, "add_three")?;

let result = add_three_wasm.call(&mut store, number)?;
Ok(result)

} ```

Alternatively, watch the video tutorial:

Switching from wasmtime

Simply replace the wasmtime dependency and imports with wasm-bridge, and you should be good to go.

Most of wasmtime's API is still not implemented, so you will likely run into compile errors when compiling to wasm.

Create an issue with a code snippet describing your use case.

Using component-model

Component model is available since version 0.1.2, but the support is still very limited. See Component model.

Implemented features

• Load a module from bytes or from WAT text
• Instantiate a module with or without imports
• Get (typed) exported function and call it
• Multivalue returns from exported and imported functions
• Supported value types: i32, i64, u32, u64, f32, f64
• Access store's data from Caller (imported fn)

See the no_bindgen test folder for supported example usages.