microvm

module
v0.6.10 Latest Latest
Warning

This package is not in the latest version of its module.

Go to latest
Published: Nov 2, 2026 License: MIT

README

 

AerolVM logo

Run Untrusted Code Safely.
Self-Hosted or Fully-Managed Sandbox Infrastructure for AI Agents and Ephemeral Workloads.

Documentation · Quick Start · Report Bug · Request Feature · Sponsor

Tests Coverage Release OpenSSF Scorecard OpenSSF Best Practices

 

AerolVM is open-source sandbox infrastructure for running isolated code environments - self-host it on your own Linux host, or run it as a managed, multi-tenant service. Each sandbox is a fully isolated compute unit with its own filesystem, network stack, and allocated resources - create latency as low as 4ms server-side (V8 isolate warm path) and supporting OCI containers on containerd (default), gVisor, Firecracker, WASM, and V8-isolate runtimes. Built for AI agent pipelines and ephemeral CI, it ships as a single Go binary backed by Caddy for TLS routing and SQLite for state, with no external dependencies and a one-line installer.

What the project intends to do, and not do, through October 2027 is in ROADMAP.md.

Features

AerolVM provides a complete surface for building sandbox-backed products and agent workflows.

Sandboxes Execution Networking & Ports Storage & Secrets Platform & Cluster
Lifecycle (create / start / stop / destroy) Streaming exec & PTY HTTP preview URLs External storage (S3, NFS, SSHFS, rclone) Raft-coordinated cluster
Environment & resource limits Persistent PTY sessions w/ replay TCP port exposure Encrypted sandbox secrets HA failover & durability
Snapshots (stop-start persistence) SSH access per sandbox TLS + SNI port routing Custom domains Cluster ingress topology
Multi-runtime (containerd OCI / gVisor / Firecracker / WASM / Isolate) File system operations Per-sandbox egress control Sandbox tags & tenant scoping Reconciler & self-healing
GPU sandboxes Port allowlist Per-sandbox network quotas Dashboard Operational runbooks

Why AerolVM

How AerolVM compares with the two most common alternatives on the axes that matter most for AI workloads: isolation choices, cost, and running it yourself. The e2b and Daytona columns come from their own docs and repositories, as of October 2026.

AerolVM e2b Daytona
Deployment ✅ Self-host (single binary, one-line install) or managed multi-tenant SaaS E2B Cloud, a deployment E2B runs in your cloud account, or self-host on one machine (E2B Embed) Daytona Cloud, plus your own runner machines (BYOC) under Daytona's control plane
Runs locally ✅ --local flag, no DNS needed Linux hosts with KVM only (E2B Embed) ✗
Sandbox startup (server p50) Isolate ~4ms · WASM ~22ms · Firecracker ~34ms · containerd ~189ms ~200ms < 90ms
Runtime isolation ✅ OCI (containerd default) / gVisor / Firecracker / WASM / V8 isolate Firecracker (microVM) Containers by default; Linux, Windows and macOS VMs
Sandbox lifetime Unlimited Unlimited while paused; 24h running at a stretch on E2B Cloud Pro (1h Hobby) Unlimited
Serverless / Workers-style sandboxes ✅ WASM + V8 isolate ✗ ✗
TCP + TLS port routing ✅ ✗ ✗
Per-sandbox egress control ✅ Domain allowlists, filtering DNS, method/path rules, credential injection ✅ Allow/deny lists incl. domains ✅ Block all, CIDR and domain allowlists
External storage ✅ S3 / NFS / SSHFS / rclone Volumes; buckets via FUSE in a template ✅ S3 / R2 / GCS / Azure Blob and more
GPU support ✅ ✗ ✅ NVIDIA and AMD
HA cluster mode ✅ Raft + SWIM gossip Managed by E2B; Embed is one machine Managed by Daytona (failover not documented)
Drop-in SDK compat ✅ /daytona, /e2b and /runloop facades ✗ ✗
Price (100 × 2vCPU/4GB sandboxes/mo) ~$4,000 on your infra ~$12,000 ~$12,000
SDK languages TS, Python, Go, Rust, Java TS, Python TS, Python, Ruby, Go, Java
Open source ✅ MIT ✅ Apache-2.0 ✗ Public repo frozen at v0.190.0 (AGPL) in June 2026; development is private

See the full comparison →

vs e2b

e2b is the fastest managed path if you want zero infrastructure. Its runtime is open source (Apache-2.0), and E2B Embed self-hosts the whole stack on one Linux machine with KVM; past one machine, E2B runs a dedicated deployment for you. On E2B Cloud you pay per sandbox-second, and a sandbox runs at most 24 hours at a stretch before it must be paused. Every e2b sandbox is a Firecracker microVM, so every host needs KVM. AerolVM covers the same AI execution use case on infrastructure you own, with clusters in the open-source server — pick OCI on containerd, gVisor, Firecracker, WASM, or V8 isolates per sandbox — with predictable fixed-cost pricing.

Already on the e2b SDK? AerolVM's /e2b API facade means your existing code keeps working - just point E2B_API_URL at your AerolVM host.

vs Daytona

Daytona now runs agent sandboxes as a cloud service: containers by default, with VM, GPU and macOS sandboxes. In June 2026 its core development moved to a private codebase, and the public AGPL repository is frozen at v0.190.0. Its BYOC option runs sandboxes on your machines, but Daytona's control plane still manages them. AerolVM is MIT-licensed and runs entirely on your servers as a single binary you install in 60 seconds.

Already on the Daytona SDK? AerolVM's /daytona API facade lets you swap the backend without touching your SDK code - just update DAYTONA_API_URL.

Architecture

AerolVM is a single Go binary (sandboxd) wired to three components:

  • Caddy - handles wildcard TLS via DNS-01, L7 HTTP routing (<sandbox-id>.<domain>), and L4 TCP SNI routing (<sandbox-id>-<port>.<domain>). The daemon talks to the Caddy admin API; no config files are reloaded at runtime.
  • Runtimes - OCI containers (runtime: "docker" on the containerd engine by default; dockerd optional), gVisor (runsc), Firecracker (microVM), WASM (WASI workers / resident host), and V8 isolate (workerd). WASM and isolate are host-mediated and Runtime-only.
  • SQLite (WAL mode, single-writer) - stores sandbox state, the TCP host-port pool, exposed-port intents, and sealed secrets. Single-writer means no contention; WAL mode means reads never block writes.

For multi-host deployments, sandboxd nodes form a cluster using Raft (FSM-replicated placement state) and SWIM gossip (membership + capacity heartbeats). Nodes take server, worker, or ingress roles. The Raft voter count stays fixed at 3 or 5 regardless of how many workers you add - the same topology Kubernetes uses for control-plane vs. data-plane scaling. See Cluster Setup.

┌─────────────────────────────────────────────────────┐
│                    sandboxd                         │
│                                                     │
│  ┌──────────┐   ┌──────────┐   ┌─────────────────┐  │
│  │  HTTP    │   │ Service  │   │    SQLite store │  │
│  │  API v1  │──▶│  layer   │──▶│  (WAL, 1-writer)│  │
│  └──────────┘   └────┬─────┘   └─────────────────┘  │
│                      │                              │
│          ┌───────────┼───────────┐                  │
│          ▼           ▼           ▼                  │
│  containerd/gVisor  Caddy      SSH gateway            │
│  FC/WASM/isolate  admin API  (Ed25519)              │
└─────────────────────────────────────────────────────┘

Runtimes

Runtime Status Install / enable Use case
OCI / docker API (runc via containerd) ✅ Available Default engine (SB_CONTAINER_ENGINE=containerd) Broadest OCI image compatibility.
gVisor (runsc) ✅ Available --with-gvisor User-space kernel for untrusted LLM code.
Firecracker ✅ Available --with-firecracker (bare metal / KVM) MicroVM - dedicated kernel per sandbox.
WASM ✅ Available Config / cluster wasm workers WASI modules; resident host ~22ms warm create.
Isolate (V8 / workerd) ✅ Available (off by default) --with-isolate / SB_ENABLE_ISOLATE JS/TS fetch handlers; ~4ms warm server create.

Create latency (live UC-94)

Server-side create from Server-Timing (excludes client↔cluster WAN). Artifacts under integration-tests/reports/. Production deployments use the containerd engine for OCI sandboxes (runtime: "docker" on the wire).

Runtime / engine Server p50 Server p90 Server p99 Topology Notes
Isolate 4ms 6ms 19ms single-node-isolate · t3.medium Warm path (same tenant group); API p50 266ms is WAN
WASM (resident host) 22ms 46ms 50ms cluster-3-mixed-wasm · t3.large Flag-on resident host; no cold-compile tail
Firecracker (warm pool) 34ms 36ms 37ms single-node-fc · c5.metal Post warm-pool path; cold/template builds are higher
containerd (OCI default) 189ms 225ms 233ms cluster-3-mixed-containerd · t3.medium Default host engine; API runtime remains docker
gVisor 284ms 330ms 346ms cluster-3-mixed-gvisor · t3.medium User-space kernel boot cost

Reproduce: make integration-benchmark-isolate, integration-benchmark-wasm, integration-benchmark-containerd, integration-benchmark-fc, integration-benchmark-gvisor.

SDKs

AerolVM ships first-party SDKs for five languages. Install the one that matches your stack:

# TypeScript / Node.js
npm install @aerol-ai/aerolvm-sdk

# Python
pip install aerolvm

# Go
go get github.com/aerol-ai/microvm/sdk/go

# Rust
cargo add aerolvm

# Java (Maven)
# <dependency><groupId>ai.aerol</groupId><artifactId>aerolvm-sdk</artifactId></dependency>

Quick Start

TypeScript
import { MicroVM } from '@aerol-ai/aerolvm-sdk'

const client = new MicroVM({
  apiUrl: process.env.SB_API_URL,
  patToken: process.env.SB_PAT_TOKEN,
})

const sandbox = await client.create({ image: 'ubuntu:22.04' })

// Run a command and stream output
const stream = await sandbox.execStream('python3 -c "print(\'hello\')"')
stream.on('data', chunk => process.stdout.write(chunk))

// Expose a port and get a public URL
const url = await sandbox.exposePort(3000)
console.log(url) // https://<sandbox-id>-3000.sandbox.example.com

await sandbox.destroy()
Python
from aerolvm import MicroVM
import os

client = MicroVM(
    api_url=os.environ["SB_API_URL"],
    pat_token=os.environ["SB_PAT_TOKEN"],
)

sandbox = client.create(image="ubuntu:22.04")

result = sandbox.exec("python3 -c \"print('hello')\"")
print(result.stdout)

url = sandbox.expose_port(3000)
print(url)  # https://<sandbox-id>-3000.sandbox.example.com

sandbox.destroy()
Go
package main

import (
    "context"
    "fmt"
    "os"

    microvm "github.com/aerol-ai/microvm/sdk/go/pkg/microvm"
    sdktypes "github.com/aerol-ai/microvm/sdk/go/pkg/types"
)

func main() {
    client := microvm.New(microvm.Options{
        APIURL:   os.Getenv("SB_API_URL"),
        PATToken: os.Getenv("SB_PAT_TOKEN"),
    })

    ctx := context.Background()
    sandbox, _ := client.Create(ctx, sdktypes.CreateSandboxOptions{
        Image: "ubuntu:22.04",
    })

    result, _ := sandbox.Exec(ctx, "echo hello")
    fmt.Println(result.Stdout)

    sandbox.Destroy(ctx)
}

Full examples for Rust and Java are in the SDK Setup docs.

Drop-in SDK Compatibility

If you are already running the e2b, Daytona or Runloop SDK, AerolVM has API facades that accept their wire format unchanged:

Existing SDK AerolVM facade endpoint Migration
e2b Python / TypeScript /e2b/... Set E2B_API_URL=https://your-aerolvm-host
daytona Python / TypeScript /daytona/... Set DAYTONA_API_URL=https://your-aerolvm-host
Runloop Python / TypeScript /runloop/... Set RUNLOOP_BASE_URL=https://your-aerolvm-host/runloop

Using the e2b SDK → · Using the Daytona SDK → · Using the Runloop SDK →

Installation

See Server Setup for all installation paths: local development, single-node production with wildcard TLS, and multi-node cluster deployment.

Use Cases

Use Case Description
AI Code Execution Run LLM-generated code safely in kernel-isolated environments. Handle untrusted Python, JS, and shell from agent workflows without risking the host.
Ephemeral CI / Build Agents Spin up a fresh environment per job, run tests, collect artifacts, destroy. No persistent state, no environment drift.
Customer-Facing Products Ship interactive code runners, coding interview sandboxes, and per-user compute environments backed by AerolVM's isolation and port exposure.
Data Processing Pipelines Attach S3 or NFS storage, run transforms in parallel across sandboxes, extract results - with per-sandbox network quotas to prevent runaway egress.

Documentation

Guide Description
Quick Start Spin up a sandbox and run a command in under five minutes.
Server Setup Install and configure AerolVM on a Linux host.
SDK Setup Connect an SDK to your AerolVM server.
Sandboxes Lifecycle states, runtimes, resource limits, and configuration.
Sessions Persistent PTY sessions that survive reconnects with output replay.
Snapshots Stop a sandbox, snapshot its state, restart it later exactly where it left off.
Cluster Setup Multi-node deployment with Raft placement and SWIM gossip.
Comparison AerolVM vs e2b vs Daytona - full feature and cost analysis.
Actors and actions Who acts on a released node, and which component carries out each action.
Security assessment The most likely and most severe problems for a released node, and where the 0.6.3 review left each one.
Releasing How the maintainer publishes a release and keeps the changelog in sync.

Dependencies

A released version's dependencies are the ones recorded in the committed manifests and lockfiles. A new dependency is added only in a reviewed pull request that names the package, the version, and why it is needed. Builds obtain those dependencies with the standard tool for that language, from the lockfile, so a release does not resolve an unpinned range.

Component Recorded in Obtained with
Go daemon and Go SDK go.mod, go.sum Go modules (go build, go test)
TypeScript SDK sdk/typescript/package-lock.json npm ci
Docs site docs/package-lock.json npm ci
Release npm CLI .github/npm-cli/package-lock.json npm ci
Python SDK sdk/python/pyproject.toml, sdk/python/requirements-ci.txt pip install --require-hashes
Java SDK sdk/java/pom.xml Maven (mvn)
Rust SDK sdk/rust/Cargo.lock cargo test --locked / cargo publish

Dependabot opens a weekly pull request for Go modules, GitHub Actions, npm (the docs site and the TypeScript SDK), pip, Maven, and Cargo. Dependabot security updates are enabled on the repository. The pinned npm CLI under .github/npm-cli is outside that schedule; it changes only when its lockfile is updated in a pull request. The Go CI job also runs govulncheck against the module graph.

Access to sensitive resources

These GitHub accounts can reach the repository's sensitive resources. Registry publish tokens (npm, PyPI, Maven, crates.io) are GitHub Actions secrets. They are not in the git tree. The release workflow and the SDK publish workflow are what read them.

GitHub account Access
sumansaurabh Organization owner and repository admin. Can change branch rules, Actions secrets, security settings, and publish a release.
akanshasinha19 Write. Can push branches, open pull requests, publish a GitHub release, and dispatch the SDK publish workflow.
sumansaurabh-slice Write. Same as above.

Merges to the default branch still require a reviewed pull request. Code owners are the review list, separate from this access list. How the project keeps creating issues, accepting changes, and publishing releases if one person is unavailable, and why the bus factor is 2, is in CONTINUITY.md.

Roles and responsibilities

How these roles make decisions is in GOVERNANCE.md.

Role Members Responsibilities
Maintainer sumansaurabh Approve pull requests. Publish official releases and the SDK packages. Change branch rules, Actions secrets, and security settings. Triage reports sent to security@aerol.ai and GitHub private advisories.
Code owner sumansaurabh, akanshasinha19 Review pull requests. A code owner other than the pull request author approves changes to the default branch.
Write collaborator akanshasinha19, sumansaurabh-slice Push branches and open pull requests. Official releases stay with the maintainer.
Contributor Anyone else Open issues and pull requests. No access to Actions secrets, branch rules, or release publishing.

Contributing

AerolVM is open source under the MIT License. The contributor guide states what an acceptable change must include: a reviewed pull request, a filled pull request description, tests, and no secrets in the diff. Open an issue first for a non-trivial change. Community spaces follow the code of conduct.

make fmt      # format Go code
make test     # run tests
make build    # build sandboxd + toolboxd into bin/

License

MIT · © Aerol AI, Inc.

Directories

Path Synopsis
Terraform
validate
Package validate mirrors Terraform locals.tf node-arch derivation and the homogeneous-cluster precondition so mixed-arch tfvars fail in offline tests without a live AWS plan.
Package validate mirrors Terraform locals.tf node-arch derivation and the homogeneous-cluster precondition so mixed-arch tfvars fail in offline tests without a live AWS plan.
caddymod module
cmd
aerolvm command
Command aerolvm drives AerolVM sandboxes from a terminal, a script or an AI agent: the agent-friendly CLI and, as `aerolvm mcp`, an MCP server over stdio (plans/mcp-server-and-agent-cli.md).
Command aerolvm drives AerolVM sandboxes from a terminal, a script or an AI agent: the agent-friendly CLI and, as `aerolvm mcp`, an MCP server over stdio (plans/mcp-server-and-agent-cli.md).
sandboxd command
toolboxd command
toolboxd/loginshell
Package loginshell keeps an image's PATH in the login shells toolboxd runs.
Package loginshell keeps an image's PATH in the login shells toolboxd runs.
toolboxd/sandboxenv
Package sandboxenv holds the environment a sandbox was created with, for a guest whose agent cannot inherit it.
Package sandboxenv holds the environment a sandbox was created with, for a guest whose agent cannot inherit it.
toolboxd/sessions
Package sessions implements long-running command sessions inside a sandbox container: PTY or pipes, in-memory replay buffer, fan-out to multiple attached clients, and asciinema recording.
Package sessions implements long-running command sessions inside a sandbox container: PTY or pipes, in-memory replay buffer, fan-out to multiple attached clients, and asciinema recording.
integration-tests
agenteval
Package agenteval checks that a model can actually use the aerolvm MCP tools (plans/mcp-server-and-agent-cli.md §8, eng review D13).
Package agenteval checks that a model can actually use the aerolvm MCP tools (plans/mcp-server-and-agent-cli.md §8, eng review D13).
catalogue
Package catalogue holds shared helpers for the investor benchmark catalogue artifact: cross-process atomic JSON merge (soak loops) and Pushgateway push.
Package catalogue holds shared helpers for the investor benchmark catalogue artifact: cross-process atomic JSON merge (soak loops) and Pushgateway push.
catalogue/cmd/gen command
Command gen renders reports/<scenario>-catalogue.md from catalogue JSON.
Command gen renders reports/<scenario>-catalogue.md from catalogue JSON.
cmd/audit-receiver command
audit-receiver is the off-node sink the security scenarios export to (plans/integration-test-security.md §6.4).
audit-receiver is the off-node sink the security scenarios export to (plans/integration-test-security.md §6.4).
report command
Command gen turns `go test -json` output into the use-case coverage report: a per-scenario JSON + Markdown file and an aggregate matrix.
Command gen turns `go test -json` output into the use-case coverage report: a per-scenario JSON + Markdown file and an aggregate matrix.
suite/harness
Package harness holds the scenario/capability model, the use-case registry, and the thin SDK client wrapper shared by every integration test.
Package harness holds the scenario/capability model, the use-case registry, and the thin SDK client wrapper shared by every integration test.
internal
agentmcp
Package agentmcp is the AerolVM MCP tool registry (plans/mcp-server-and- agent-cli.md §5.3).
Package agentmcp is the AerolVM MCP tool registry (plans/mcp-server-and- agent-cli.md §5.3).
agenttools
Package agenttools is the operation layer the aerolvm CLI and the aerolvm MCP server share (plans/mcp-server-and-agent-cli.md §5.1).
Package agenttools is the operation layer the aerolvm CLI and the aerolvm MCP server share (plans/mcp-server-and-agent-cli.md §5.1).
agenttools/agenttoolstest
Package agenttoolstest is an in-memory fake of the parts of sandboxd the aerolvm CLI and MCP server use: v1 sandboxes (create, get, list by name, start, destroy, ports), the toolbox file and exec endpoints, the exec WebSocket, and sessions.
Package agenttoolstest is an in-memory fake of the parts of sandboxd the aerolvm CLI and MCP server use: v1 sandboxes (create, get, list by name, start, destroy, ports), the toolbox file and exec endpoints, the exec WebSocket, and sessions.
cluster
Package cluster implements Phase-1 cluster mode for sandboxd.
Package cluster implements Phase-1 cluster mode for sandboxd.
egress
Package egress is the per-node egress gateway core for hostname-filtered ("gateway-mode") sandboxes (plans/egress-domain-filtering.md §5.3).
Package egress is the per-node egress gateway core for hostname-filtered ("gateway-mode") sandboxes (plans/egress-domain-filtering.md §5.3).
egress/dnsfilter
Package dnsfilter is the egress gateway's filtering DNS resolver (plans/egress-domain-filtering.md §5.4).
Package dnsfilter is the egress gateway's filtering DNS resolver (plans/egress-domain-filtering.md §5.4).
egress/gatewayd
Package gatewayd is the `sandboxd egress-gateway` process (plans/ egress-domain-filtering.md §5.3, D9): it owns the nft table, the filtering DNS resolver and the SNI/Host proxy, and takes orders from sandboxd over a UDS.
Package gatewayd is the `sandboxd egress-gateway` process (plans/ egress-domain-filtering.md §5.3, D9): it owns the nft table, the filtering DNS resolver and the SNI/Host proxy, and takes orders from sandboxd over a UDS.
egress/inspect
Package inspect holds the egress gateway's per-node inspection CA (plans/egress-domain-filtering.md §5.9, P3-1).
Package inspect holds the egress gateway's per-node inspection CA (plans/egress-domain-filtering.md §5.9, P3-1).
egress/operator
Package operator loads the private-cloud egress operator file (plans/egress-domain-filtering.md §5.10, SB_EGRESS_OPERATOR_FILE).
Package operator loads the private-cloud egress operator file (plans/egress-domain-filtering.md §5.10, SB_EGRESS_OPERATOR_FILE).
egress/procid
Package procid traces a sandbox's TCP connection to the executables that hold it, for per-binary egress rules (plans/egress-domain-filtering.md §5.9, P3-3).
Package procid traces a sandbox's TCP connection to the executables that hold it, for per-binary egress rules (plans/egress-domain-filtering.md §5.9, P3-3).
egress/proxy
Package proxy is the egress gateway's transparent SNI/Host proxy (plans/egress-domain-filtering.md §5.5).
Package proxy is the egress gateway's transparent SNI/Host proxy (plans/egress-domain-filtering.md §5.5).
identity
Package identity is sandboxd's own named-credential layer (plans/identity-and-access.md §5.4, §5.5): the server-side half of identity that the CLI never imports.
Package identity is sandboxd's own named-credential layer (plans/identity-and-access.md §5.4, §5.5): the server-side half of identity that the CLI never imports.
identity/identitytest
Package identitytest is an in-process OIDC identity provider for tests: an httptest TLS server publishing a discovery document and a JWKS, and a minting helper.
Package identitytest is an in-process OIDC identity provider for tests: an httptest TLS server publishing a discovery document and a JWKS, and a minting helper.
netsplice
Package netsplice is the raw-TCP proxy core shared by sandboxd's proxies: a bidirectional splice that replays bytes already read into a bufio.Reader, and a per-key plus global connection limiter.
Package netsplice is the raw-TCP proxy core shared by sandboxd's proxies: a bidirectional splice that replays bytes already read into a bufio.Reader, and a per-key plus global connection limiter.
network/cni
Package cni wraps the bridge+host-local CNI plugin for containerd sandboxes.
Package cni wraps the bridge+host-local CNI plugin for containerd sandboxes.
network/hostport
Package hostport forwards raw-TCP host ports in the kernel (plans/ingress-proxy-routing.md §3.5, task T7, decision "kernel DNAT").
Package hostport forwards raw-TCP host ports in the kernel (plans/ingress-proxy-routing.md §3.5, task T7, decision "kernel DNAT").
network/ipv6fence
Package ipv6fence keeps IPv6 off the node's sandbox networks.
Package ipv6fence keeps IPv6 off the node's sandbox networks.
network/netns
Package netns manages the per-host pool of prepaid network namespaces for the containerd engine.
Package netns manages the per-host pool of prepaid network namespaces for the containerd engine.
network/tap
Package tap manages the per-host pool of (TAP-device, host-IP, guest-IP, /30-CIDR, vsock-CID) slots that Firecracker microVMs claim at create time.
Package tap manages the per-host pool of (TAP-device, host-IP, guest-IP, /30-CIDR, vsock-CID) slots that Firecracker microVMs claim at create time.
pool/containerdpool
Package containerdpool is the warm-container pool for containerd sandboxes.
Package containerdpool is the warm-container pool for containerd sandboxes.
pool/dockerpool
Package dockerpool is the in-memory warm-container pool for Docker sandboxes.
Package dockerpool is the in-memory warm-container pool for Docker sandboxes.
pool/isolate
Package isolate is the blank-workerd warm pool for the V8-isolate runtime (plans/isolate-runtime.md §4 Phase 3).
Package isolate is the blank-workerd warm pool for the V8-isolate runtime (plans/isolate-runtime.md §4 Phase 3).
pool/vmm
Package vmm is the policy layer of the Firecracker warm-VMM pool described in plans/snapshot-clone-fast-boot.md Phase 4.
Package vmm is the policy layer of the Firecracker warm-VMM pool described in plans/snapshot-clone-fast-boot.md Phase 4.
pool/wasm
Package wasm is the in-memory warm-worker pool for WASM sandboxes (Phase 5).
Package wasm is the in-memory warm-worker pool for WASM sandboxes (Phase 5).
routedns
Package routedns answers "where does this sandbox hostname go?" for a static Caddy config (plans/ingress-proxy-routing.md §3.2, task T3).
Package routedns answers "where does this sandbox hostname go?" for a static Caddy config (plans/ingress-proxy-routing.md §3.2, task T3).
runtime
Package runtime defines the abstraction the service layer uses to drive a sandbox container, regardless of which OCI runtime executes it.
Package runtime defines the abstraction the service layer uses to drive a sandbox container, regardless of which OCI runtime executes it.
runtime/firecracker
Package firecracker is the native Firecracker runtime driver.
Package firecracker is the native Firecracker runtime driver.
runtime/isolate
Package isolate is the V8-isolate (Workers-model) runtime driver — the fifth implementation of internal/runtime.Runtime, after pkg/docker (docker + gvisor), internal/runtime/firecracker, and internal/runtime/wasm (plans/isolate-runtime.md).
Package isolate is the V8-isolate (Workers-model) runtime driver — the fifth implementation of internal/runtime.Runtime, after pkg/docker (docker + gvisor), internal/runtime/firecracker, and internal/runtime/wasm (plans/isolate-runtime.md).
runtime/resolvconf
Package resolvconf builds the resolv.conf a sandbox gets: the host's upstream resolvers, without loopback stubs the sandbox can't reach.
Package resolvconf builds the resolv.conf a sandbox gets: the host's upstream resolvers, without loopback stubs the sandbox can't reach.
runtime/wasm
Package wasm is the WASM/WASI runtime driver — the third implementation of internal/runtime.Runtime (after pkg/docker and internal/runtime/firecracker).
Package wasm is the WASM/WASI runtime driver — the third implementation of internal/runtime.Runtime (after pkg/docker and internal/runtime/firecracker).
runtime/wasm/statekv
Package statekv implements the host KV capability for durable WASM sandboxes (plans/wasm-runtime.md §4.6).
Package statekv implements the host KV capability for durable WASM sandboxes (plans/wasm-runtime.md §4.6).
runtime/wasm/toolhost
Package toolhost implements the host-side toolbox for WASM sandboxes (plans/wasm-runtime.md §3).
Package toolhost implements the host-side toolbox for WASM sandboxes (plans/wasm-runtime.md §3).
operator module
pkg
api
Package api wires the top-level HTTP server.
Package api wires the top-level HTTP server.
api/apihttp
Package apihttp holds HTTP helpers shared by every version of the public API (pkg/api/v1, ...).
Package apihttp holds HTTP helpers shared by every version of the public API (pkg/api/v1, ...).
api/clusterlist
Package clusterlist aggregates sandbox list reads across cluster owners.
Package clusterlist aggregates sandbox list reads across cluster owners.
api/clusterroute
Package clusterroute holds the one cluster owner-forwarding wrapper every API surface shares.
Package clusterroute holds the one cluster owner-forwarding wrapper every API surface shares.
api/ingressproxy
Package ingressproxy implements the loopback HTTP listener that fronts wake-aware Caddy port routes.
Package ingressproxy implements the loopback HTTP listener that fronts wake-aware Caddy port routes.
api/remotemcp
Package remotemcp serves the AerolVM MCP tools over Streamable HTTP at /mcp on sandboxd (plans/mcp-server-and-agent-cli.md §5.7, Phase 2b).
Package remotemcp serves the AerolVM MCP tools over Streamable HTTP at /mcp on sandboxd (plans/mcp-server-and-agent-cli.md §5.7, Phase 2b).
api/runloop
Package runloop is a compatibility facade for the official Runloop SDKs (@runloop/api-client, runloop_api_client).
Package runloop is a compatibility facade for the official Runloop SDKs (@runloop/api-client, runloop_api_client).
api/v1
Package v1 implements the v1 HTTP API for the sandbox daemon.
Package v1 implements the v1 HTTP API for the sandbox daemon.
auditexport
Package auditexport ships already-redacted, hash-chained audit records off-node through pluggable backends.
Package auditexport ships already-redacted, hash-chained audit records off-node through pluggable backends.
auditwitness
Package auditwitness supplies an off-node audit witness to the open-source build: a controlplane.Witness that writes each audit hash-chain head to an S3 bucket with Object Lock, so the node that wrote a head can never change or remove it (plans/open-audit-witness.md).
Package auditwitness supplies an off-node audit witness to the open-source build: a controlplane.Witness that writes each audit hash-chain head to an S3 bucket with Object Lock, so the node that wrote a head can never change or remove it (plans/open-audit-witness.md).
auditwitness/s3fake
Package s3fake is an in-memory S3 server for tests.
Package s3fake is an in-memory S3 server for tests.
capacity
Package capacity implements admission control for sandbox creation.
Package capacity implements admission control for sandbox creation.
clonegen
Package clonegen publishes a monotonic "clone generation" token readers can poll to detect that a sandbox was resumed from a snapshot — i.e.
Package clonegen publishes a monotonic "clone generation" token readers can poll to detect that a sandbox was resumed from a snapshot — i.e.
controlplane
Package controlplane is the neutral seam between sandboxd and an optional managed control plane.
Package controlplane is the neutral seam between sandboxd and an optional managed control plane.
createtiming
Package createtiming carries a per-request create-latency recorder on the request context so runtime drivers can attribute where a sandbox create spent its time, and the API handler can surface that attribution as Server-Timing response entries.
Package createtiming carries a per-request create-latency recorder on the request context so runtime drivers can attribute where a sandbox create spent its time, and the API handler can surface that attribution as Server-Timing response entries.
daemon
Package daemon holds the full sandboxd boot sequence as a single reusable entrypoint, Run.
Package daemon holds the full sandboxd boot sequence as a single reusable entrypoint, Run.
docker/netstats
Package netstats reads per-sandbox network byte counters from /proc/<pid>/net/dev.
Package netstats reads per-sandbox network byte counters from /proc/<pid>/net/dev.
egresspolicy
Package egresspolicy is the one grammar, matcher and enforcement toolkit for sandbox egress policy (plans/egress-domain-filtering.md §5.1, §5.6).
Package egresspolicy is the one grammar, matcher and enforcement toolkit for sandbox egress policy (plans/egress-domain-filtering.md §5.1, §5.6).
firecracker
Package firecracker is a thin Go wrapper around the Firecracker VMM's HTTP-over-Unix-socket REST API.
Package firecracker is a thin Go wrapper around the Firecracker VMM's HTTP-over-Unix-socket REST API.
gvisorpids
Package gvisorpids caps how many tasks (processes and threads) a gVisor sandbox may run, inside the sandbox's own kernel (the runsc sentry).
Package gvisorpids caps how many tasks (processes and threads) a gVisor sandbox may run, inside the sandbox's own kernel (the runsc sentry).
identitywire
Package identitywire holds the identity formats that sandboxd and the aerolvm CLI must agree on byte for byte (plans/identity-and-access.md, eng review D2): the avm_ API token format with its checksum, the names and lifetimes a token request carries, the sign-in discovery document (GET /.well-known/aerolvm-auth) the CLI and the dashboard read before they hold any credential, the team-selection header, and the answer of `whoami --explain`.
Package identitywire holds the identity formats that sandboxd and the aerolvm CLI must agree on byte for byte (plans/identity-and-access.md, eng review D2): the avm_ API token format with its checksum, the names and lifetimes a token request carries, the sign-in discovery document (GET /.well-known/aerolvm-auth) the CLI and the dashboard read before they hold any credential, the team-selection header, and the answer of `whoami --explain`.
isolate
Package isolate is the workerd engine wrapper for the V8-isolate runtime (plans/isolate-runtime.md §7, the analog of pkg/wasm for WASM).
Package isolate is the workerd engine wrapper for the V8-isolate runtime (plans/isolate-runtime.md §7, the analog of pkg/wasm for WASM).
jsbundle
Package jsbundle resolves and stores the JS/TS bundles that back runtime=isolate sandboxes (plans/isolate-runtime.md §7, the analog of pkg/wasmmod for .wasm modules).
Package jsbundle resolves and stores the JS/TS bundles that back runtime=isolate sandboxes (plans/isolate-runtime.md §7, the analog of pkg/wasmmod for .wasm modules).
mounts
Package mounts owns the host-side lifecycle of per-sandbox external-storage mounts.
Package mounts owns the host-side lifecycle of per-sandbox external-storage mounts.
mounts/adapters
Package adapters describes how to invoke external mount tools on the host for each supported storage protocol.
Package adapters describes how to invoke external mount tools on the host for each supported storage protocol.
oci
Package oci builds an ext4 root filesystem image from an OCI container reference.
Package oci builds an ext4 root filesystem image from an OCI container reference.
readyproto
Package readyproto defines the newline-delimited JSON handshake toolboxd sends to sandboxd when a Docker sandbox's agent is ready to serve.
Package readyproto defines the newline-delimited JSON handshake toolboxd sends to sandboxd when a Docker sandbox's agent is ready to serve.
toolboxhttp
Package toolboxhttp is the HTTP transport sandboxd uses to reach a sandbox's toolbox over the network.
Package toolboxhttp is the HTTP transport sandboxd uses to reach a sandbox's toolbox over the network.
volumes
Package volumes translates a named, tenant-scoped platform volume into a concrete mount the existing pkg/mounts pipeline already knows how to realize.
Package volumes translates a named, tenant-scoped platform volume into a concrete mount the existing pkg/mounts pipeline already knows how to realize.
wasm
Snapshot artifact layout and validation per plans/wasm-runtime.md §4.8.1.
Snapshot artifact layout and validation per plans/wasm-runtime.md §4.8.1.
wasm/worker
Package worker implements the WASM worker-subprocess pool (plans/wasm-runtime.md §2.1).
Package worker implements the WASM worker-subprocess pool (plans/wasm-runtime.md §2.1).
wasmmod
Package wasmmod — AOCR push for §4.8.1 WASM snapshot artifacts (D2).
Package wasmmod — AOCR push for §4.8.1 WASM snapshot artifacts (D2).
scripts
load command
ingress_churn is a release-gate load harness for the AerolVM cluster data-plane ingress.
ingress_churn is a release-gate load harness for the AerolVM cluster data-plane ingress.
sdk
go/internal/apiclient/v1
Package v1 holds wire-version-1 constants for the Go SDK.
Package v1 holds wire-version-1 constants for the Go SDK.

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL