Fast, isolated Linux VMs — the same smol machine on your laptop, in the cloud, or self-hosted.

about

Run any workload in a fast, hardware-isolated Linux VM. The same SDK and the same .smolmachine artifact run identically:

locally — native macOS, Linux, or Windows through the open-source runtime.
in smol cloud — deploy with one call.
self-hosted — on your own servers.

Develop locally, then deploy to the hosted cloud — or self-host with smolvm.

get started

Create an account and get 10,000.00 $SMOLVM of free usage.

Navigate to API Keys page in the console, create a key, and save the key.

export SMOL_CLOUD_TOKEN="smk_your_key_here"
export SMOL_CLOUD_URL="https://api.smolvm.work"

Create a machine:

curl -X POST $SMOL_CLOUD_URL/v1/machines \
  -H "Authorization: Bearer $SMOL_CLOUD_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "source": {"type": "image", "reference": "alpine"},
    "resources": {"cpus": 1, "memoryMb": 256},
    "name": "my-first-machine",
    "network": {"mode": "open"}
  }'

Run a command:

# the machine starts on the first exec
curl -X POST $SMOL_CLOUD_URL/v1/machines/MACHINE_ID/exec \
  -H "Authorization: Bearer $SMOL_CLOUD_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"command": "echo hello from smol cloud"}'

Start a local VM in seconds, install for:

curl -sSL https://smolvm.work/install.sh | bash

To install and discover all commands with coding agents:

curl -sSL https://smolvm.work/install.sh | bash && smolvm --help

# create a machine that keeps its filesystem between sessions
smolvm machine create -n dev --net --image alpine
smolvm machine start -n dev

# install something, then stop the machine
smolvm machine exec --name dev -- apk add sl
smolvm machine stop -n dev

# start it again - sl is still there
smolvm machine start -n dev
smolvm machine exec --name dev -- sl

Uninstall with:

curl -sSL https://smolvm.work/install.sh | bash -s -- --uninstall

how it works

Each workload receives hardware isolation, with its own kernel on MacOS Hypervisor, Linux KVM, or Windows Hypervisor Platform. Pack it into a .smolmachine and it runs anywhere with compatible host architecture.

Default provision: 4 vCPUs 8 GiB RAM
Memory is elastic via virtio balloon, the host only commits what the guest actually uses. libkrun VMM + custom libkrunfw kernel. No host daemon — the VMM is linked into the binary.

use this for

RL environments

Every rollout gets its own machine, forked from a live one rather than booted from scratch. Fork a running machine into a batch of episodes, then score them and release the pool.

sandbox untrusted code

Untrusted code runs behind a VM boundary with its own guest kernel, with network off by default. Configure each machine’s network policy and public-access.

persistent agents and workloads

Files, installed packages, and workspace persist across sessions, so a workload picks up where it left off. Memory is elastic, so a machine only holds what the guest is actually using.

consistent infrastructure

Same machine model on your laptop, in smol cloud, or on your own servers. Develop against a local microVM for free, then point the same code at managed machines through the console, REST API, or SDK.

fast time to ready

A job waits on boot + install. Pull a .smolmachine file and the VM comes up ready to work. Start from a pre-built registry environment in the cloud and skip repeated provisioning.

See more examples

comparison

	smolvm	Containers	QEMU	Firecracker
Isolation	VM per workload	Shared Kernel	Separate VM	Separate VM
Boot time	<200ms	~100ms	~15-30s	<125ms
Architecture	libkrun Library	Daemon	Process	Process
GPU	Vulkan + CUDA	Host Passthrough	VFIO	No
macOS native	Yes	Via Docker VM	Yes	No
Portable artifacts	.smolmachine	Images	No	No

$SMOLVM on solana launching on solana — soon

$SMOLVM pays for the machines you run.

Machine-hours, fork credits and registry payouts settle wallet-to-wallet in $SMOLVM on Solana. No invoice, no card, no middleman — the meter reads the token, the wallet settles it.

pay

pay per machine-hour

smol cloud meters base, vCPU, memory, disk and egress. The meter reads in $SMOLVM — you keep a wallet topped up, not an invoice on file.

earn

publish machines, get paid

Publish a machine to the smol registry and collect $SMOLVM every time someone runs it. The consumer pays the publisher directly — no platform cut in the middle.

stake

stake for warm pools

Stake $SMOLVM to hold warm machines and priority forks, so a rollout starts from a live pool instead of a cold boot.

free

local stays free

smolvm on your own laptop or server is free and open source: no wallet, no $SMOLVM, no account. The token only touches the hosted side.

contract address — solana

contract address publishes here on launch day

$SMOLVM does not exist yet. The contract address is published in this box first — nobody else speaks for it, and no address counts until it is written here.

see what it buys follow @SMOLVM for the CA

$SMOLVM is a utility token: it pays for machine usage on smol cloud and for registry payouts. It is not an investment, it carries no claim on revenue, and holding it promises nothing beyond those two uses.