Microsandbox Performance Characteristics: Sub-100ms Boot Times and Minimal Resource Overhead

Microsandbox delivers sub-100ms startup latency, single-digit megabyte memory footprints, and low CPU overhead by combining a lightweight KVM-based hypervisor (libkrun), the smoltcp networking stack, and an async Tokio runtime.

Microsandbox is an open-source sandboxing runtime designed for fast, secure execution of untrusted workloads in micro-VMs. Understanding its performance characteristics helps you evaluate whether it fits latency-sensitive or resource-constrained deployment scenarios.

Instant Startup: Sub-100ms Boot Times

Microsandbox achieves average boot times under 100ms on Apple M1 hardware. This measurement covers the full path from CLI invocation to guest code execution.

The README explicitly documents this metric with a footnote defining the boot-time measurement methodology at README.md lines 36-38. Real-world timing with the CLI confirms this claim:

# Run a sandbox and time the boot

time msb run python -- echo "ready"

On an M1 Mac, this typically reports ≈0.09s real elapsed time. This performance stems from libkrun, the lightweight hypervisor included as a Git submodule at vendor/libkrunfw/, which minimizes initialization overhead compared to full-system VMMs.

Minimal Memory Footprint

Each sandbox consumes only a few megabytes of RAM — the sum of:

• The compressed VM image size
• A tiny kernel footprint
• Minimal runtime overhead from libkrun

The libkrun hypervisor deliberately avoids the bloat of traditional hypervisors by implementing only the essential KVM primitives needed for Linux guests. This contrasts sharply with Firecracker or QEMU, which carry larger memory footprints despite similar isolation guarantees.

Low CPU Overhead

Microsandbox configures guests with a single vCPU by default, keeping CPU overhead to baseline KVM context-switch costs. The host kernel handles scheduling without additional virtualization tax.

You can verify actual CPU usage via the built-in metrics system:

# Start a sandbox in background

msb create --name bench python &

# Stream live metrics (1-second updates)

msb metrics bench

The msb metrics command consumes data from crates/metrics-collector/lib/lib.rs, which implements a runtime metrics API streaming per-sandbox CPU percentage and memory usage directly from the guest.

Efficient Networking with smoltcp

Network performance relies on two specialized crates:

• crates/network/ — Wraps smoltcp, a pure-Rust TCP/IP stack designed for resource-constrained environments
• crates/vsock/ — Implements host-guest communication via virtio sockets

Together these yield low-latency, low-bandwidth host-to-guest traffic without the overhead of a full network stack in the guest. The smoltcp stack avoids kernel networking paths, reducing context switches and memory copies.

For high-throughput scenarios, establish a vsock channel directly:

use microsandbox::{Sandbox, vsock::Vsock};

#[tokio::main]
async fn main() -> anyhow::Result<()> {
    let sandbox = Sandbox::builder("vsock-demo")
        .image("python")
        .cpus(1)
        .memory(256)
        .create()
        .await?;

    // Open vsock channel on port 1234
    let mut channel = Vsock::connect(&sandbox, 1234).await?;
    channel.write_all(b"ping").await?;
    
    let mut resp = vec![0u8; 4];
    channel.read_exact(&mut resp).await?;
    println!("Guest replied: {:?}", std::str::from_utf8(&resp)?);

    sandbox.stop().await?;
    Ok(())
}

The vsock implementation provides zero-copy socket semantics between host and guest processes.

Deterministic Snapshot and Fork Performance

Microsandbox supports warm-worker patterns through snapshot-fork semantics. Creating a snapshot of a stopped sandbox and booting from it takes essentially the same time as a fresh boot — the snapshot contains a ready-to-run memory image.

Benchmark this behavior using the example at examples/rust/snapshot-fork/:

use microsandbox::Sandbox;

#[tokio::main]
async fn main() -> anyhow::Result<()> {
    // Create and stop a sandbox
    let sandbox = Sandbox::builder("snap")
        .image("python")
        .cpus(1)
        .memory(512)
        .create()
        .await?;
    sandbox.stop().await?;

    // Snapshot the stopped instance
    let snapshot = sandbox.snapshot().await?;

    // Fork and measure boot time
    let start = std::time::Instant::now();
    let fork = snapshot.fork().await?;
    println!("Fork boot time: {:.2?}", start.elapsed());

    fork.stop().await?;
    Ok(())
}

On M1 hardware, fork boot times remain under 100ms, enabling millisecond-scale worker pool scaling.

Scalable Concurrency via Tokio

The runtime leverages Tokio 1.x with multi-threaded scheduler, as specified in Cargo.toml (line 50). This architecture allows:

• Hundreds of concurrent sandboxes without blocking
• Efficient I/O multiplexing across guest boundaries
• Predictable latency under load

The async runtime coordinates sandbox lifecycle, network I/O, and metrics collection without thread-per-sandbox overhead.

Zero-Leak Secret Handling

Secrets are injected via the host-side API at sdk/rust/src/sandbox/secret.rs, never written into the guest image. This design:

• Eliminates runtime cost for secret shuffling
• Prevents secret leakage through image caching
• Avoids guest-side decryption overhead

Secrets traverse the vsock channel directly from host memory into the guest process, leaving no persistent trace.

Performance Comparison Summary

Characteristic	Microsandbox Implementation	Typical Alternative
Boot time	<100ms (libkrun)	500ms–2s (Firecracker/QEMU)
Memory per sandbox	~5–20 MB	50–200 MB
Network stack	smoltcp in userspace	Kernel networking + virtio
Host-guest IPC	Native vsock sockets	Serial console or network
Concurrency model	Tokio async	Thread-per-VM or process pool

Summary

• Sub-100ms cold boot via libkrun hypervisor at vendor/libkrunfw/
• Megabyte-scale memory footprint per sandbox instance
• Single vCPU default with streamable metrics from crates/metrics-collector/lib/lib.rs
• Efficient networking through smoltcp (crates/network/) and vsock (crates/vsock/)
• Snapshot-fork parity enabling warm-worker scaling under 100ms
• Tokio-based concurrency supporting dense sandbox packing
• Zero-overhead secrets injected via sdk/rust/src/sandbox/secret.rs

Frequently Asked Questions

What hardware achieves the documented sub-100ms boot time?

The <100ms measurement was recorded on an Apple M1 Mac. Performance on other platforms depends on KVM availability and CPU characteristics — Linux with KVM typically achieves similar results, while Windows with WHP (Windows Hypervisor Platform) may show slightly higher latency due to hypervisor abstraction layers.

How does Microsandbox compare to Firecracker for performance?

Microsandbox trades Firecracker's full Linux compatibility for lower overhead. Firecracker boots in ~125ms with more complete device support; Microsandbox targets <100ms with minimalist I/O via smoltcp and vsock. Choose Microsandbox for latency-critical, network-light workloads; Firecracker for broader guest OS compatibility.

Can I run hundreds of Microsandbox instances on one host?

Yes. The Tokio multi-threaded scheduler (Cargo.toml line 50) and minimal per-sandbox memory footprint (single-digit MB) enable dense packing. The msb metrics command helps monitor host resource consumption to identify actual limits for your workload pattern.

Where is the snapshot data stored and how large is it?

Snapshots contain the full guest memory image plus metadata, typically matching the sandbox's configured memory size (default 512MB, compressible). Storage location is configurable; the snapshot() method in the Rust SDK writes to a path you specify, with copy-on-write semantics available on supported filesystems.

{
  "mcpServers": {
    "instagit": {
      "command": "npx",
      "args": ["-y", "instagit@latest"]
    }
  }
}