Crate wasmtime

Wasmtime’s embedding API

Wasmtime is a WebAssembly engine for JIT-compiled or ahead-of-time compiled WebAssembly modules and components. More information about the Wasmtime project as a whole can be found in the documentation book whereas this documentation mostly focuses on the API reference of the wasmtime crate itself.

This crate contains an API used to interact with WebAssembly modules or WebAssembly components. For example you can compile WebAssembly, create instances, call functions, etc. As an embedder of WebAssembly you can also provide guests functionality from the host by creating host-defined functions, memories, globals, etc, which can do things that WebAssembly cannot (such as print to the screen).

The wasmtime crate is designed to be safe, efficient, and ergonomic. This enables executing WebAssembly without the embedder needing to use unsafe code, meaning that you’re guaranteed there is no undefined behavior or segfaults in either the WebAssembly guest or the host itself.

The wasmtime crate can roughly be thought of as being split into two halves:

• One half of the crate is similar to the JS WebAssembly API as well as the proposed C API and is intended for working with WebAssembly modules. This API resides in the root of the wasmtime crate’s namespace, for example wasmtime::Module.

• The second half of the crate is for use with the WebAssembly Component Model. The implementation of the component model is present in wasmtime::component and roughly mirrors the structure for core WebAssembly, for example component::Func mirrors Func.

An example of using Wasmtime to run a core WebAssembly module looks like:

use wasmtime::*;

fn main() -> wasmtime::Result<()> {
    let engine = Engine::default();

    // Modules can be compiled through either the text or binary format
    let wat = r#"
        (module
            (import "host" "host_func" (func $host_hello (param i32)))

            (func (export "hello")
                i32.const 3
                call $host_hello)
        )
    "#;
    let module = Module::new(&engine, wat)?;

    // Host functionality can be arbitrary Rust functions and is provided
    // to guests through a `Linker`.
    let mut linker = Linker::new(&engine);
    linker.func_wrap("host", "host_func", |caller: Caller<'_, u32>, param: i32| {
        println!("Got {} from WebAssembly", param);
        println!("my host state is: {}", caller.data());
    })?;

    // All wasm objects operate within the context of a "store". Each
    // `Store` has a type parameter to store host-specific data, which in
    // this case we're using `4` for.
    let mut store: Store<u32> = Store::new(&engine, 4);

    // Instantiation of a module requires specifying its imports and then
    // afterwards we can fetch exports by name, as well as asserting the
    // type signature of the function with `get_typed_func`.
    let instance = linker.instantiate(&mut store, &module)?;
    let hello = instance.get_typed_func::<(), ()>(&mut store, "hello")?;

    // And finally we can call the wasm!
    hello.call(&mut store, ())?;

    Ok(())
}

Core Concepts

There are a number of core types and concepts that are important to be aware of when using the wasmtime crate:

• Engine - a global compilation and runtime environment for WebAssembly. An Engine is an object that can be shared concurrently across threads and is created with a Config with many knobs for configuring behavior. Compiling or executing any WebAssembly requires first configuring and creating an Engine. All Modules and Components belong to an Engine, and typically there’s one Engine per process.

• Store - container for all information related to WebAssembly objects such as functions, instances, memories, etc. A Store<T> allows customization of the T to store arbitrary host data within a Store. This host data can be accessed through host functions via the Caller function parameter in host-defined functions. A Store is required for all WebAssembly operations, such as calling a wasm function. The Store is passed in as a “context” to methods like Func::call. Dropping a Store will deallocate all memory associated with WebAssembly objects within the Store. A Store is cheap to create and destroy and does not GC objects such as unused instances internally, so it’s intended to be short-lived (or no longer than the instances it contains).

• Linker (or component::Linker) - host functions are defined within a linker to provide them a string-based name which can be looked up when instantiating a WebAssembly module or component. Linkers are traditionally populated at startup and then reused for all future instantiations of all instances, assuming the set of host functions does not change over time. Host functions are Fn(..) + Send + Sync and typically do not close over mutable state. Instead it’s recommended to store mutable state in the T of Store<T> which is accessed through Caller<'_, T> provided to host functions.

• Module (or Component) - a compiled WebAssembly module or component. These structures contain compiled executable code from a WebAssembly binary which is ready to execute after being instantiated. These are expensive to create as they require compilation of the input WebAssembly. Modules and components are safe to share across threads, however. Modules and components can additionally be serialized into a list of bytes to later be deserialized quickly. This enables JIT-style compilation through constructors such as Module::new and AOT-style compilation by having the compilation process use Module::serialize and the execution process use Module::deserialize.

• Instance (or component::Instance) - an instantiated WebAssembly module or component. An instance is where you can actually acquire a Func (or component::Func) from, for example, to call.

• Func (or component::Func) - a WebAssembly function. This can be acquired as the export of an Instance to call WebAssembly functions, or it can be created via functions like Func::wrap to wrap host-defined functionality and give it to WebAssembly. Functions also have typed views as TypedFunc or component::TypedFunc for a more efficient calling convention.

• Table, Global, Memory, component::Resource - other WebAssembly objects which can either be defined on the host or in wasm itself (via instances). These all have various ways of being interacted with like Func.

All “store-connected” types such as Func, Memory, etc, require the store to be passed in as a context to each method. Methods in wasmtime frequently have their first parameter as either impl AsContext or impl AsContextMut. These traits are implemented for a variety of types, allowing you to, for example, pass the following types into methods:

• &Store<T>
• &mut Store<T>
• &Caller<'_, T>
• &mut Caller<'_, T>
• StoreContext<'_, T>
• StoreContextMut<'_, T>

A Store is the sole owner of all WebAssembly internals. Types like Func point within the Store and require the Store to be provided to actually access the internals of the WebAssembly function, for instance.

WASI

The wasmtime crate does not natively provide support for WASI, but you can use the wasmtime-wasi crate for that purpose. With wasmtime-wasi all WASI functions can be added to a Linker and then used to instantiate WASI-using modules. For more information see the WASI example in the documentation.

Crate Features

The wasmtime crate comes with a number of compile-time features that can be used to customize what features it supports. Some of these features are just internal details, but some affect the public API of the wasmtime crate. Wasmtime APIs gated behind a Cargo feature should be indicated as such in the documentation.

• runtime - Enabled by default, this feature enables executing WebAssembly modules and components. If a compiler is not available (such as cranelift) then Module::deserialize must be used, for example, to provide an ahead-of-time compiled artifact to execute WebAssembly.

• cranelift - Enabled by default, this features enables using Cranelift at runtime to compile a WebAssembly module to native code. This feature is required to process and compile new WebAssembly modules and components.

• cache - Enabled by default, this feature adds support for wasmtime to perform internal caching of modules in a global location. This must still be enabled explicitly through Config::cache_config_load or Config::cache_config_load_default.

• wat - Enabled by default, this feature adds support for accepting the text format of WebAssembly in Module::new and Component::new. The text format will be automatically recognized and translated to binary when compiling a module.

• parallel-compilation - Enabled by default, this feature enables support for compiling functions in parallel with rayon.

• async - Enabled by default, this feature enables APIs and runtime support for defining asynchronous host functions and calling WebAssembly asynchronously. For more information see Config::async_support.

• profiling - Enabled by default, this feature compiles in support for profiling guest code via a number of possible strategies. See Config::profiler for more information.

• all-arch - Not enabled by default. This feature compiles in support for all architectures for both the JIT compiler and the wasmtime compile CLI command. This can be combined with Config::target to precompile modules for a different platform than the host.

• pooling-allocator - Enabled by default, this feature adds support for PoolingAllocationConfig to pass to Config::allocation_strategy. The pooling allocator can enable efficient reuse of resources for high-concurrency and high-instantiation-count scenarios.

• demangle - Enabled by default, this will affect how backtraces are printed and whether symbol names from WebAssembly are attempted to be demangled. Rust and C++ demanglings are currently supported.

• coredump - Enabled by default, this will provide support for generating a core dump when a trap happens. This can be configured via Config::coredump_on_trap.

• addr2line - Enabled by default, this feature configures whether traps will attempt to parse DWARF debug information and convert WebAssembly addresses to source filenames and line numbers.

• debug-builtins - Enabled by default, this feature includes some built-in debugging utilities and symbols for native debuggers such as GDB and LLDB to attach to the process Wasmtime is used within. The intrinsics provided will enable debugging guest code compiled to WebAssembly. This must also be enabled via Config::debug_info as well for guests.

• component-model - Enabled by default, this enables support for the wasmtime::component API for working with components.

• gc - Enabled by default, this enables support for a number of WebAssembly proposals such as reference-types, function-references, and gc. Note that the implementation of the gc proposal itself is not yet complete at this time.

• threads - Enabled by default, this enables compile-time support for the WebAssembly threads proposal, notably shared memories.

• call-hook - Disabled by default, this enables support for the [Store::call_hook] API. This incurs a small overhead on all entries/exits from WebAssembly and may want to be disabled by some embedders.

• memory-protection-keys - Disabled by default, this enables support for the [PoolingAllocationConfig::memory_protection_keys] API. This feature currently only works on x64 Linux and can enable compacting the virtual memory allocation for linear memories in the pooling allocator. This comes with the same overhead as the call-hook feature where entries/exits into WebAssembly will have more overhead than before.

More crate features can be found in the manifest of Wasmtime itself for seeing what can be enabled and disabled.

Re-exports

• pub use anyhow::Error;
• pub use anyhow::Result;

Modules

• component
  Embedding API for the Component Model
• unix
  Unix-specific extension for the wasmtime crate.

Structs

• AnyRef
  An anyref GC reference.
• ArrayRef
  A reference to a GC-managed array instance.
• ArrayRefPre
  An allocator for a particular Wasm GC array type.
• ArrayType
  The type of a WebAssembly array.
• Caller
  A structure representing the caller’s context when creating a function via Func::wrap.
• CodeBuilder
  Builder-style structure used to create a Module or pre-compile a module to a serialized list of bytes.
• CodeMemory
  Management of executable memory within a MmapVec
• CompiledModule
  A compiled wasm module, ready to be instantiated.
• Config
  Global configuration options used to create an Engine and customize its behavior.
• Engine
  An Engine which is a global context for compilation and management of wasm modules.
• EngineWeak
  A weak reference to an Engine.
• EqRef
  A reference to a GC-managed object that can be tested for equality.
• Export
  An exported WebAssembly value.
• ExportType
  A descriptor for an exported WebAssembly value.
• ExternRef
  An opaque, GC-managed reference to some host data that can be passed to WebAssembly.
• FieldType
  The type of a struct field or an array’s elements.
• FrameInfo
  Description of a frame in a backtrace for a WasmBacktrace.
• FrameSymbol
  Debug information for a symbol that is attached to a FrameInfo.
• Func
  A WebAssembly function which can be called.
• FuncType
  The type of a WebAssembly function.
• GcHeapOutOfMemory
  An error returned when attempting to allocate a GC-managed object, but the GC heap is out of memory.
• Global
  A WebAssembly global value which can be read and written to.
• GlobalType
  A WebAssembly global descriptor.
• I31
  A 31-bit integer.
• ImportType
  A descriptor for an imported value into a wasm module.
• Instance
  An instantiated WebAssembly module.
• InstancePre
  An instance, pre-instantiation, that is ready to be instantiated.
• Linker
  Structure used to link wasm modules/instances together.
• ManuallyRooted
  A rooted reference to a garbage-collected T with arbitrary lifetime.
• Memory
  A WebAssembly linear memory.
• MemoryAccessError
  Error for out of bounds Memory access.
• MemoryType
  A descriptor for a WebAssembly memory type.
• MemoryTypeBuilder
  A builder for MemoryTypes.
• Module
  A compiled WebAssembly module, ready to be instantiated.
• ModuleExport
  Describes the location of an export in a module.
• NoExtern
  A reference to the abstract noextern heap value.
• NoFunc
  A reference to the abstract nofunc heap value.
• PoolConcurrencyLimitError
  An error returned when the pooling allocator cannot allocate a table, memory, etc… because the maximum number of concurrent allocations for that entity has been reached.
• PoolingAllocationConfig
  Configuration options used with InstanceAllocationStrategy::Pooling to change the behavior of the pooling instance allocator.
• RefType
  Opaque references to data in the Wasm heap or to host data.
• ResourcesRequired
  A summary of the amount of resources required to instantiate a particular Module or Component.
• RootScope
  Nested rooting scopes.
• Rooted
  A scoped, rooted reference to a garbage-collected T.
• SharedMemory
  A constructor for externally-created shared memory.
• Store
  A Store is a collection of WebAssembly instances and host-defined state.
• StoreContext
  A temporary handle to a &Store<T>.
• StoreContextMut
  A temporary handle to a &mut Store<T>.
• StoreLimits
  Provides limits for a Store.
• StoreLimitsBuilder
  Used to build StoreLimits.
• StructRef
  A reference to a GC-managed struct instance.
• StructRefPre
  An allocator for a particular Wasm GC struct type.
• StructType
  The type of a WebAssembly struct.
• Table
  A WebAssembly table, or an array of values.
• TableType
  A descriptor for a table in a WebAssembly module.
• TypedFunc
  A statically typed WebAssembly function.
• UnknownImportError
  Error for an unresolvable import.
• V128
  Representation of a 128-bit vector type, v128, for WebAssembly.
• WasmBacktrace
  Representation of a backtrace of function frames in a WebAssembly module for where an error happened.
• WasmCoreDump
  Representation of a core dump of a WebAssembly module

Enums

• CallHook
  Passed to the argument of [Store::call_hook] to indicate a state transition in the WebAssembly VM.
• CodeHint
  Return value of CodeBuilder::hint
• Extern
  An external item to a WebAssembly module, or a list of what can possibly be exported from a wasm module.
• ExternType
  A list of all possible types which can be externally referenced from a WebAssembly module.
• Finality
  Indicator of whether a type is final or not.
• HeapType
  The heap types that can Wasm can have references to.
• InstanceAllocationStrategy
  Represents the module instance allocation strategy to use.
• ModuleVersionStrategy
  Configure the strategy used for versioning in serializing and deserializing crate::Module.
• MpkEnabled
  Describe the tri-state configuration of memory protection keys (MPK).
• Mutability
  Indicator of whether a global value, struct’s field, or array type’s elements are mutable or not.
• OptLevel
  Possible optimization levels for the Cranelift codegen backend.
• Precompiled
  Return value from the Engine::detect_precompiled API.
• ProfilingStrategy
  Select which profiling technique to support.
• Ref
  A reference.
• StorageType
  The storage type of a struct field or array element.
• Strategy
  Possible Compilation strategies for a wasm module.
• Trap
  Representation of a WebAssembly trap and what caused it to occur.
• UpdateDeadline
  What to do after returning from a callback when the engine epoch reaches the deadline for a Store during execution of a function using that store.
• Val
  Possible runtime values that a WebAssembly module can either consume or produce.
• ValType
  A list of all possible value types in WebAssembly.
• WaitResult
  Result of Memory::atomic_wait32 and Memory::atomic_wait64
• WasmBacktraceDetails
  Select how wasm backtrace detailed information is handled.

Constants

• DEFAULT_INSTANCE_LIMIT
  Value returned by ResourceLimiter::instances default method
• DEFAULT_MEMORY_LIMIT
  Value returned by ResourceLimiter::memories default method
• DEFAULT_TABLE_LIMIT
  Value returned by ResourceLimiter::tables default method

Traits

• AsContext
  A trait used to get shared access to a Store in Wasmtime.
• AsContextMut
  A trait used to get exclusive mutable access to a Store in Wasmtime.
• GcRef
  A common trait implemented by all garbage-collected reference types.
• IntoFunc
  Internal trait implemented for all arguments that can be passed to Func::wrap and Linker::func_wrap.
• LinearMemory
  A linear memory. This trait provides an interface for raw memory buffers which are used by wasmtime, e.g. inside [‘Memory’]. Such buffers are in principle not thread safe. By implementing this trait together with MemoryCreator, one can supply wasmtime with custom allocated host managed memory.
• MemoryCreator
  A memory creator. Can be used to provide a memory creator to wasmtime which supplies host managed memory.
• ResourceLimiter
  Used by hosts to limit resource consumption of instances.
• ResourceLimiterAsync
  Used by hosts to limit resource consumption of instances, blocking asynchronously if necessary.
• RootedGcRef
  A trait implemented for GC references that are guaranteed to be rooted:
• StackCreator
  A stack creator. Can be used to provide a stack creator to wasmtime which supplies stacks for async support.
• StackMemory
  A stack memory. This trait provides an interface for raw memory buffers which are used by wasmtime inside of stacks which wasmtime executes WebAssembly in for async support. By implementing this trait together with StackCreator, one can supply wasmtime with custom allocated host managed stacks.
• WasmParams
  A trait used for Func::typed and with TypedFunc to represent the set of parameters for wasm functions.
• WasmResults
  A trait used for Func::typed and with TypedFunc to represent the set of results for wasm functions.
• WasmRet
  A trait implemented for types which can be returned from closures passed to Func::wrap and friends.
• WasmTy
  A trait implemented for types which can be arguments and results for closures passed to Func::wrap as well as parameters to Func::typed.
• WasmTyList
  Trait implemented for various tuples made up of types which implement WasmTy that can be passed to Func::wrap_inner and [HostContext::from_closure].

Unions

• ValRaw
  A “raw” and unsafe representation of a WebAssembly value.