A WebAssembly value, covering all WASM numeric and reference types.

Use the constructor directly or via encode and decode.

The type of a WebAssembly value. Used in function signatures and global/table type descriptors.

Global mutability.

A WebAssembly limit (min, optional max) as used in table and memory types.

WebAssembly proposals that can be enabled in Configure.

The execution mode for the WasmEdge runtime.

An error returned by the WasmEdge runtime.

Thrown as a Haskell exception by all public API functions that encounter a failed WasmEdge_Result. Can also be caught as SomeException.

A computation that may return a WasmEdgeError. Use throwOnLeft to re-raise as an exception, or pattern-match directly.

Maps to the C WasmEdge_ErrCategory enum.

Format a WasmEdgeError into a human-readable string with a hex error code.

Throw a WasmEdgeError as an IO exception on Left, or unwrap Right.

Useful for step-by-step WASM pipelines where you want errors to propagate as exceptions rather than handling them inline:

withVM Nothing Nothing $ vm -> do
  loadWasmFile vm "module.wasm" >>= throwOnLeft
  validate vm                    >>= throwOnLeft
  instantiate vm                 >>= throwOnLeft
  execute vm "run" []            >>= throwOnLeft

The version string of the linked WasmEdge library (e.g., 0.18.0).

Major version number.

Minor version number.

Patch version number.

Opaque WasmEdge VM context.

Automatically retains registered host ModuleInstances to guarantee their lifetime as long as the VM is alive, preventing use-after-free bugs.

Create a VM context.

createVM mCfg mStore uses the optional Configure context mCfg and optional shared Store context mStore. Pass Nothing to use defaults.

Delete a VM context explicitly.

Scoped VM context.

Declarative configuration record for initializing a VM. Inspired by wasmedge-sdk's VmBuilder in Rust.

Default VM configuration with default options and fresh store.

Scoped VM context with declarative VMConfig.

Load, instantiate, and run a WASM file in one call.

Load, instantiate, and run a WASM module from a ByteString.

Load a WASM file into the VM (does not validate or instantiate).

Load a WASM module from bytes.

Validate the loaded WASM module.

Instantiate the loaded and validated WASM module.

Execute a function in the instantiated module.

Register and instantiate a named module from a file.

Register and instantiate a named module from bytes.

Register an existing ModuleInstance into the VM. The VM automatically retains the module to guarantee its lifetime.

Register an existing ModuleInstance into the VM under a custom alias name. The VM automatically retains the module to guarantee its lifetime.

Execute a function from a named registered module.

Typeclass for functions that can be converted into a WasmEdge host function.

Automatically converts Haskell typed arguments and results, with optional CallingFrame.

Typeclass for Haskell values that can be converted to and from a single WebAssembly value.

Typeclass for host function return values.

Create a host FunctionInstance automatically inferring its FunctionType from Haskell types.

Scoped FunctionInstance with automatic signature inference.

A type that can be serialised to and deserialised from a contiguous slice of WebAssembly linear memory.

Minimal complete definition: wasmPeek + wasmPoke.

For fixed-size types (primitives, fixed-size tuples), implement FixedWasmMemory and use fixedPeek / fixedPoke as the default methods.

For JSON-serialisable ADTs use jsonWasmPeek / jsonWasmPoke.

A WasmMemory type with a statically-known byte width. Implement this for all primitive types.

Newtype wrapper to derive WasmMemory for any type with ToJSON and FromJSON via DerivingVia.

data Person = Person { name :: Text, age :: Int }
  deriving stock (Generic, Show, Eq)
  deriving anyclass (ToJSON, FromJSON)
  deriving (WasmMemory) via (WasmJSON Person)

Write any ToJSON value into linear memory as a UTF-8 JSON blob. Returns the number of bytes written.

Read a UTF-8 JSON blob from linear memory and decode it as a FromJSON value.

The primary high-level API for calling a Wasm function that takes a serialised buffer and returns a serialised buffer.

The Wasm function must have the signature (depending on ResultEncoding):

• PackedI64: (ptr: i32, len: i32) -> i64
• SeparateI32s: (ptr: i32, len: i32) -> (i32, i32)

Internally, this bracket:

1. Allocates a scratch buffer in Wasm linear memory via the alloc export.
2. Serialises the input a into that buffer using wasmPoke.
3. Calls the Wasm function with (inputPtr, inputLen).
4. Decodes the return value as (retPtr, retLen).
5. Reads and deserialises b from Wasm memory at (retPtr, retLen).
6. Deallocates both the input and output buffers via dealloc.

Returns Left if any step fails. Deallocation is attempted on all error paths.

Like withWasmBuffer but for Wasm functions that take two buffer arguments.

Expected Wasm signature (PackedI64):

(aPtr: i32, aLen: i32, bPtr: i32, bLen: i32) -> i64

Allocate n bytes inside a Wasm module's linear memory by calling the module-exported alloc function.

Returns the pointer (as Word32) on success, or Left on failure.

Free a previously-allocated Wasm buffer by calling the module-exported dealloc function.

Configuration for the guest allocator naming convention.

How a Wasm function encodes its buffer result.

Most idiomatic Rust guest code uses PackedI64. wasm-bindgen uses SeparateI32s.

The default convention: alloc, dealloc, packed i64 result, 64 KiB scratch.

Lift a Haskell function a -> IO (Either WasmEdgeError b) into a raw HostFunc that marshals arguments through Wasm linear memory.

The generated host function:

• Expects two i32 arguments: (ptr, len) — the pointer and length of the input buffer in Wasm linear memory.
• Reads and deserialises a from that buffer using wasmPeek.
• Runs the user function.
• Serialises b into a scratch region of Wasm linear memory at 1 MiB offset.
• Returns a single i64 with (retPtr << 32 | retLen).

The function type to register with createFunction is [I32, I32] -> [I64].

Note: The scratch-region approach works for output up to ~63 MiB. For larger outputs or when the Wasm module manages its own heap, use liftMemFuncWith instead.

Like liftMemFunc but for functions with no return value (pure side-effects).

The generated host function returns no values. The function type for createFunction is [I32, I32] -> [].

Advanced variant of liftMemFunc that uses the AllocConvention to call the guest's alloc export for output buffer management.

This is the production-grade approach: the guest controls the heap, and the host allocates an output buffer via alloc before writing the result. The VM reference is needed to call back into the guest's alloc export.

The generated host function signature is [I32, I32] -> [I64] (same as liftMemFunc).

Get the linear memory instance from a CallingFrame.

The calling frame always has memory index 0 available if the guest module declares linear memory, which all practical Wasm modules do.

Returns Left if no linear memory is available (null pointer from C API).

Borrow the MemoryInstance at the given index from the caller module.

In WebAssembly, index 0 is the default linear memory. Returns Nothing if the caller module has no memory at that index or if the calling frame is invalid.

Read length bytes from the caller's linear memory at index memIdx starting at offset. Returns Nothing if the memory instance cannot be found or the range is out of bounds.

Write a ByteString into the caller's linear memory at index memIdx starting at offset.

Read a null-terminated UTF-8 / ASCII string from caller memory starting at offset, scanning up to 4096 bytes.