Hello, world! - Wasmtime

# Hello, world!

You can also browse this source code online and clone the wasmtime repository to run the example locally.

This example shows off how to instantiate a simple wasm module and interact with it. For more information about the types used here be sure to review the core concepts of the `wasmtime` API as well as the general API documentation.

## `hello.wat`

    (module
      (func $hello (import "" "hello"))
      (func (export "run") (call $hello))
    )

## `hello.rs`

    //! Small example of how to instantiate a wasm module that imports one function,
    //! showing how you can fill in host functionality for a wasm module.

    // You can execute this example with `cargo run --example hello`

    use wasmtime::*;

    struct MyState {
        name: String,
        count: usize,
    }

    fn main() -> Result<()> {
        // First the wasm module needs to be compiled. This is done with a global
        // "compilation environment" within an `Engine`. Note that engines can be
        // further configured through `Config` if desired instead of using the
        // default like this is here.
        println!("Compiling module...");
        let engine = Engine::default();
        let module = Module::from_file(&engine, "examples/hello.wat")?;

        // After a module is compiled we create a `Store` which will contain
        // instantiated modules and other items like host functions. A Store
        // contains an arbitrary piece of host information, and we use `MyState`
        // here.
        println!("Initializing...");
        let mut store = Store::new(
            &engine,
            MyState {
                name: "hello, world!".to_string(),
                count: 0,
            },
        );

        // Our wasm module we'll be instantiating requires one imported function.
        // the function takes no parameters and returns no results. We create a host
        // implementation of that function here, and the `caller` parameter here is
        // used to get access to our original `MyState` value.
        println!("Creating callback...");
        let hello_func = Func::wrap(&mut store, |mut caller: Caller<'_, MyState>| {
            println!("Calling back...");
            println!("> {}", caller.data().name);
            caller.data_mut().count += 1;
        });

        // Once we've got that all set up we can then move to the instantiation
        // phase, pairing together a compiled module as well as a set of imports.
        // Note that this is where the wasm `start` function, if any, would run.
        println!("Instantiating module...");
        let imports = [hello_func.into()];
        let instance = Instance::new(&mut store, &module, &imports)?;

        // Next we poke around a bit to extract the `run` function from the module.
        println!("Extracting export...");
        let run = instance.get_typed_func::<(), ()>(&mut store, "run")?;

        // And last but not least we can call it!
        println!("Calling export...");
        run.call(&mut store, ())?;

        println!("Done.");
        Ok(())
    }