Calls and guest state

Call an export

result, err := inst.Call(
	ctx,
	"add",
	wago.ValueI32(20),
	wago.ValueI32(22),
)
if err != nil {
	return err
}

fmt.Println(result[0].I32()) // 42

Call checks the values against the export's Wasm signature.

Wasm type	Constructor	Reader
`i32`	`wago.ValueI32(v)`	`value.I32()`
`i64`	`wago.ValueI64(v)`	`value.I64()`
`f32`	`wago.ValueF32(v)`	`value.F32()`
`f64`	`wago.ValueF64(v)`	`value.F64()`

SIMD and reference types have dedicated values too. Check value.Type() when the signature is discovered dynamically.

Honor cancellation

ctx, cancel := context.WithTimeout(parent, 250*time.Millisecond)
defer cancel()

out, err := inst.Call(ctx, "work", wago.ValueI32(1000))

A background context keeps the ordinary fast path. A cancellable context lets Wago interrupt long-running guest execution. Blocking Go work inside a host function still needs its own deadline.

Read and write memory

if ok := inst.Write(128, []byte("hello")); !ok {
	return fmt.Errorf("guest memory write is out of bounds")
}

data, ok := inst.Read(128, 5)
if !ok {
	return fmt.Errorf("guest memory read is out of bounds")
}
fmt.Println(string(data))

Read returns a copy. Typed little-endian helpers include ReadUint32Le, ReadUint64Le, WriteUint32Le, and their floating-point counterparts.

For zero-copy access to the default memory, use Instance.Memory().Bytes(). The returned view reflects live guest state, so keep instance serialization rules in mind.

Read and write globals

count, err := inst.GlobalValue("count")
if err != nil {
	return err
}
fmt.Println(count.I32())

if err := inst.SetGlobalValue("count", wago.ValueI32(100)); err != nil {
	return err
}

Setting an immutable global or supplying the wrong value type returns an error.

Low-level calls

Package-level Compile, Instantiate, and Invoke use raw uint64 slots with helpers such as wago.I32 and wago.AsI32. Use that path for a deliberately low-level embedder. The runtime API is the better default for typed values, context, plugins, and lifecycle.

Calls and guest state ​

Call an export ​

Honor cancellation ​

Read and write memory ​

Read and write globals ​

Low-level calls ​

Next ​