Skip to content
Build and run portable, self-contained virtual machines.
Pack your software with a Linux VM.
No dependency management. Sub-second cold start. Isolation by default.

install + usage

bash
# install (macOS + Linux)
# option 1: download from GitHub releases
# https://github.com/smol-machines/smolvm/releases

# option 2: install script
curl -sSL https://smolmachines.com/install.sh | bash
bash
# run a command in an ephemeral VM (cleaned up after exit)
smolvm machine run --image alpine -- echo "hello from a microVM"

# interactive shell
smolvm machine run -it --image alpine

# persistent machine (survives stop/start)
smolvm machine create --net myvm
smolvm machine start --name myvm
smolvm machine exec --name myvm -- apk add sl
smolvm machine exec --name myvm -it -- /bin/sh
# try: sl, ls, uname -a — type 'exit' to leave
smolvm machine stop --name myvm

# mount host directories (explicit — host is protected by default)
smolvm machine create --net -v ./src:/workspace myvm

# pack - portable, executable virtual machine
smolvm pack create --image python:3.12-alpine -o ./my-pythonvm
./my-pythonvm python3 -c "print('hello from a packed VM')"

# uninstall
curl -sSL https://smolmachines.com/install.sh | bash -s -- --uninstall

features

isolate code — run untrusted programs in a hardware-isolated VM. Your host is protected by default.

bash
smolvm machine run --image alpine -- sh -c "pip install sketchy-package"
# runs in its own kernel — can't touch your host filesystem or network

smolfile — declare a VM environment in a simple config file. Reproducible across machines.

bash
# my-app.smolfile
# cpus = 2
# memory = 1024
# net = true
# ports = ["8080:8080"]
# init = ["apk add python3"]

smolvm machine create myvm -s my-app.smolfile
smolvm machine start --name myvm

pack — turn any workload into a portable, self-contained executable. Doom in a browser, packaged as a microVM:

bash
smolvm pack create --image python:3.12-alpine -o ./my-app
./my-app python3 -c "print('runs anywhere — no dependencies')"

More examples: python · node · doom

about

smolvm runs Linux microVMs on your machine. No daemon, no Docker, no cloud account.

A microVM is a lightweight virtual machine — hardware-level isolation with <200ms boot time. Your host filesystem, network, and credentials are completely separated from the workload unless you explicitly share them in.

Install a single binary, run a command, get an isolated Linux environment.

use this for

  • sandbox untrusted code (pip install, npm install, AI agents) with hardware isolation
  • run Linux microVMs on macOS and Linux — no Docker daemon needed
  • declare workloads with a Smolfile and run, pack, or deploy them
  • mount host directories for shared file access, with the host protected by a hypervisor boundary
  • pack and distribute self-contained sandboxed applications as portable .smolmachine executables

comparison

smolvmContainersColimaQEMUFirecrackerKata
IsolationVM per workloadNamespace (shared kernel)Namespace (1 VM)Separate VMSeparate VMVM per container
Boot time<200ms~100ms~seconds~15-30s<125ms~500ms
ArchitectureLibrary (libkrun)DaemonDaemon (in VM)ProcessProcessRuntime stack
Per-workload VMsYesNoNo (shared)YesYesYes
macOS nativeYesVia Docker VMYes (krunkit)YesNoNo
Embeddable SDKYesNoNoNoNoNo
Portable artifacts.smolmachineImages (need daemon)NoNoNoNo

Sources: container isolation · containerd benchmark · QEMU boot time · Firecracker · Kata Containers · Kata boot time · Firecracker requires KVM · Kata macOS support

how it works

libkrun VMM + Hypervisor.framework (macOS) / KVM (Linux) + crun container runtime. No daemon process — the VMM is a library linked into the smolvm binary.

platform support

hostguestrequirements
macOS Apple Siliconarm64 LinuxmacOS 11+
macOS Intelx86_64 LinuxmacOS 11+ (untested)
Linux x86_64x86_64 LinuxKVM (/dev/kvm)
Linux aarch64aarch64 LinuxKVM (/dev/kvm)

made by @binsquare · twitter · github

Apache-2.0