Learn WASMTIME with Real Code Examples

# wasmtime/demo/main.rs
use wasmtime::*;

fn main() -> anyhow::Result<()> {
    let engine = Engine::default();
    let module = Module::from_file(&engine, "hello.wasm")?;
    let mut store = Store::new(&engine, ());
    let instance = Instance::new(&mut store, &module, &[])?;
    let run = instance.get_typed_func::<(), (), _>(&mut store, "run")?;
    run.call(&mut store, ())?;
    Ok(())
}

A basic Rust program that loads and runs a WebAssembly module using Wasmtime.

# wasmtime/demo/add.rs
use wasmtime::*;

fn main() -> anyhow::Result<()> {
    let engine = Engine::default();
    let module = Module::from_file(&engine, "add.wasm")?;
    let mut store = Store::new(&engine, ());
    let instance = Instance::new(&mut store, &module, &[])?;
    let add = instance.get_typed_func::<(i32, i32), i32, _>(&mut store, "add")?;
    let result = add.call(&mut store, (2, 3))?;
    println!("Result: {}", result);
    Ok(())
}

Calls a function named 'add' from a WASM module.

# wasmtime/demo/memory.rs
use wasmtime::*;

fn main() -> anyhow::Result<()> {
    let engine = Engine::default();
    let module = Module::from_file(&engine, "memory.wasm")?;
    let mut store = Store::new(&engine, ());
    let instance = Instance::new(&mut store, &module, &[])?;
    let memory = instance.get_memory(&mut store, "mem").expect("memory not found");
    memory.write(&mut store, 0, &[1,2,3,4])?;
    let mut buffer = [0;4];
    memory.read(&mut store, 0, &mut buffer)?;
    println!("Memory: {:?}", buffer);
    Ok(())
}

Reads and writes WebAssembly memory.

# wasmtime/demo/host.rs
use wasmtime::*;

fn main() -> anyhow::Result<()> {
    let engine = Engine::default();
    let mut store = Store::new(&engine, ());
    let func = Func::wrap(&mut store, |x: i32| {
        println!("Called with {}", x);
    });
    let module = Module::from_file(&engine, "host.wasm")?;
    let instance = Instance::new(&mut store, &module, &[func.into()])?;
    Ok(())
}

Defines a host function callable from WASM.

# wasmtime/demo/global.rs
use wasmtime::*;

fn main() -> anyhow::Result<()> {
    let engine = Engine::default();
    let module = Module::from_file(&engine, "global.wasm")?;
    let mut store = Store::new(&engine, ());
    let instance = Instance::new(&mut store, &module, &[])?;
    let global = instance.get_global(&mut store, "counter").expect("global not found");
    global.set(&mut store, Val::I32(42))?;
    println!("Global value set.");
    Ok(())
}

Reads and sets a global variable in WASM module.

# wasmtime/demo/table.rs
use wasmtime::*;

fn main() -> anyhow::Result<()> {
    let engine = Engine::default();
    let module = Module::from_file(&engine, "table.wasm")?;
    let mut store = Store::new(&engine, ());
    let instance = Instance::new(&mut store, &module, &[])?;
    let table = instance.get_table(&mut store, "tbl").expect("table not found");
    table.set(&mut store, 0, Val::FuncRef(None))?;
    Ok(())
}

Accesses and updates a WebAssembly table.

# wasmtime/demo/async.rs
use wasmtime::*;
use futures::executor::block_on;

fn main() -> anyhow::Result<()> {
    let engine = Engine::default();
    let module = Module::from_file(&engine, "async.wasm")?;
    let mut store = Store::new(&engine, ());
    let instance = Instance::new(&mut store, &module, &[])?;
    let func = instance.get_typed_func::<(), i32, _>(&mut store, "compute")?;
    let result = block_on(func.call_async(&mut store, ()))?;
    println!("Async result: {}", result);
    Ok(())
}

Calls an async WASM function with Wasmtime.

# wasmtime/demo/error.rs
use wasmtime::*;

fn main() -> anyhow::Result<()> {
    let engine = Engine::default();
    let module = Module::from_file(&engine, "error.wasm")?;
    let mut store = Store::new(&engine, ());
    let instance = Instance::new(&mut store, &module, &[])?;
    let func = instance.get_typed_func::<(), (), _>(&mut store, "fail")?;
    match func.call(&mut store, ()) {
        Ok(_) => println!("Success"),
        Err(e) => println!("Error: {}", e),
    }
    Ok(())
}

Handles runtime errors from WASM function calls.

# wasmtime/demo/wasi.rs
use wasmtime::*;
use wasmtime_wasi::{WasiCtxBuilder, Wasi};

fn main() -> anyhow::Result<()> {
    let engine = Engine::default();
    let module = Module::from_file(&engine, "wasi_program.wasm")?;
    let mut store = Store::new(&engine, ());
    let wasi = Wasi::new(&mut store, WasiCtxBuilder::new().inherit_stdout().build());
    let instance = Instance::new(&mut store, &module, &[])?;
    Ok(())
}

Runs a WASI WebAssembly module using Wasmtime.