# Does Microsandbox Support WebAssembly? WASI Runtime and SDK Integration Explained

> Explore microsandbox WebAssembly support. Discover how its integrated WASI runtime allows sandboxed .wasm module execution across CLI, Node-TS, Rust, and Python SDKs.

- Repository: [Super Rad Company/microsandbox](https://github.com/superradcompany/microsandbox)
- Tags: deep-dive
- Published: 2026-08-20

---

**Yes, microsandbox includes first-class WebAssembly support through a built-in WASI runtime that enables sandboxed execution of `.wasm` modules across its CLI, Node-TS, Rust, and Python SDKs.**

The `superradcompany/microsandbox` project treats WebAssembly as a first-class citizen. According to the microsandbox source code, the engine integrates a dedicated WASI runtime that is exposed consistently through language-specific SDKs. This allows developers to run compiled `.wasm` binaries inside isolated sandboxes using the same interface as native guests.

## How Microsandbox Implements WebAssembly Support

### WASI Runtime Architecture

The Node-TS SDK loads a dedicated WASI binding (`@superradcompany/microsandbox-wasm32-wasi`) at the native layer. In `/sdk/node-ts/native/index.cjs`, the native module initializes this runtime and forwards it to the sandbox engine. The same WASI runtime is shared with the Python and Go SDKs through the agent-client crate in [`/packages/agent-client/rust/lib/lib.rs`](https://github.com/superradcompany/microsandbox/blob/main//packages/agent-client/rust/lib/lib.rs), which transports Wasm payloads to the guest VM.

### Rust WebAssembly Toolchain Integration

For Rust developers, microsandbox leverages the standard Rust-to-Wasm compilation pipeline. The project's dependency lock at `/sdk/ruby/ext/microsandbox/Cargo.lock` includes `wasm-bindgen`, `wasm-bindgen-futures`, and related crates required to compile Rust source into sandbox-runnable Wasm modules.

## Executing Wasm Modules in Microsandbox

### CLI Usage with `msb run`

You can launch a Wasm binary directly from the command line by specifying the `wasi` runtime:

```bash

# Assume you have a Wasm binary `hello.wasm`

msb run hello.wasm \
    --runtime wasi \
    --memory 64MiB \
    --cpu 0.5

```

### Node-TS SDK

The Node-TS SDK exposes `execWasm` on the `Sandbox` class. The following example configures a WASI sandbox and executes a `.wasm` file:

```javascript
import { Sandbox } from '@superradcompany/microsandbox';

// Create a sandbox that enables the WASI runtime
const sb = await Sandbox.create({
  runtime: 'wasi',
  memory: '64MiB',
});

// Load the Wasm module (as a Uint8Array, Buffer, or path)
await sb.execWasm('path/to/hello.wasm', {
  args: [],          // optional command‑line arguments
  env: { VAR: 'value' },
});

```

Under the hood, the Node-TS layer resolves the `@superradcompany/microsandbox-wasm32-wasi` binding in `/sdk/node-ts/native/index.cjs`.

### Rust SDK

In the Rust SDK, you configure the sandbox with the `.runtime()` and `.memory()` builders, then call `.exec_wasm()`:

```rust
use microsandbox::Sandbox;

#[tokio::main]
async fn main() -> anyhow::Result<()> {
    // Configure a sandbox that uses the WASI runtime
    let mut sandbox = Sandbox::new()
        .runtime("wasi")
        .memory("64MiB")
        .cpu(0.5)?;

    // Load and execute a Wasm binary
    sandbox.exec_wasm("examples/wasm/hello.wasm", vec![]).await?;
    Ok(())
}

```

### Python SDK

The Python SDK consumes the shared agent-client library to provide the `exec_wasm` method. As implemented in [`/sdk/python/src/sandbox.rs`](https://github.com/superradcompany/microsandbox/blob/main//sdk/python/src/sandbox.rs) (via the agent-client crate at [`/packages/agent-client/rust/lib/lib.rs`](https://github.com/superradcompany/microsandbox/blob/main//packages/agent-client/rust/lib/lib.rs)), Python callers can submit Wasm binaries to the guest VM just like the Node-TS and Rust SDKs.

## Key Source Files for WebAssembly Support

- **`/sdk/node-ts/native/index.cjs`** – Loads the `@superradcompany/microsandbox-wasm32-wasi` binding used by the Node SDK.
- **[`/packages/agent-client/rust/lib/lib.rs`](https://github.com/superradcompany/microsandbox/blob/main//packages/agent-client/rust/lib/lib.rs)** – Core transport layer that forwards Wasm payloads to the guest agent for Python, Go, and Node SDKs.
- **`/sdk/ruby/ext/microsandbox/Cargo.lock`** – Lists the Rust Wasm toolchain dependencies (`wasm-bindgen`, `wasm-bindgen-futures`) enabling Rust-to-Wasm compilation.
- **[`/sdk/python/src/sandbox.rs`](https://github.com/superradcompany/microsandbox/blob/main//sdk/python/src/sandbox.rs)** – Provides the `exec_wasm` method for the Python SDK via the shared agent client.
- **`crates/runtime/...`** – Runtime integration that selects the appropriate guest (native or WASI) based on sandbox configuration.

## Summary

- **microsandbox supports WebAssembly natively** through an integrated WASI runtime.
- The Node-TS SDK loads the WASI binding from `/sdk/node-ts/native/index.cjs`, while the Rust SDK provides `.runtime("wasi")` and `.exec_wasm()`.
- Cross-language support is unified by the agent-client crate in [`/packages/agent-client/rust/lib/lib.rs`](https://github.com/superradcompany/microsandbox/blob/main//packages/agent-client/rust/lib/lib.rs), enabling Python, Go, and Node-TS to run Wasm payloads.
- Rust developers can compile to Wasm using the standard toolchain tracked in `/sdk/ruby/ext/microsandbox/Cargo.lock`.
- Both the CLI (`msb run --runtime wasi`) and programmatic SDKs accept the same resource limits (memory, CPU) for Wasm guests as for native binaries.

## Frequently Asked Questions

### Does microsandbox support WebAssembly natively?

Yes. As implemented in the `superradcompany/microsandbox` source code, the engine ships a built-in WASI runtime and does not rely on external WebAssembly interpreters. The runtime is initialized inside the sandbox and exposed through the `@superradcompany/microsandbox-wasm32-wasi` binding.

### What WASI runtime does microsandbox use?

The project uses its own integrated WASI binding across all SDKs. The Node-TS entry point at `/sdk/node-ts/native/index.cjs` loads this binding, while [`/packages/agent-client/rust/lib/lib.rs`](https://github.com/superradcompany/microsandbox/blob/main//packages/agent-client/rust/lib/lib.rs) handles the underlying transport of Wasm binaries to the guest VM.

### Can I compile Rust code to WebAssembly for microsandbox?

Yes. The repository includes the standard Rust Wasm toolchain. The presence of `wasm-bindgen` and `wasm-bindgen-futures` in `/sdk/ruby/ext/microsandbox/Cargo.lock` confirms that Rust code can be compiled to `.wasm` and executed inside a microsandbox via the Rust, Node-TS, or Python SDKs.

### Is WebAssembly sandboxing available in all microsandbox SDKs?

Yes. The same WASI runtime is exposed to Node-TS, Python, and Go through the shared agent-client library. Each SDK provides an `exec_wasm` or `execWasm` method, and the CLI supports `--runtime wasi`, allowing any supported language to run WebAssembly workloads under identical isolation policies.