A warm Hyperlight micro-VM started our Python script in a median 81.5 ms. The same script in a Docker container took 484.3 ms under runc and 480.7 ms under gVisor. Each idle micro-VM also cost the host 3.3 MiB of available memory once its snapshot was shared, against 11.9 MiB for a runc container. Native Python still won at 14.7 ms, so the micro-VM costs startup time over a bare process, yet it beats the container sandboxes people already use for untrusted code.
We took those figures with hluk, the CLI of hyperlight-unikraft, which runs ordinary Linux programs inside Hyperlight micro-VMs on a Unikraft kernel. Cold boot, snapshot restore, per-VM memory and the errors on the way were all measured on one host. The vendor post gives Azure timings only and we found no independent measurement, so these are the first such numbers we know of (hluk 0.21.0, benchmarked November 2026 on Ubuntu 24.04 running nested under KVM on Proxmox).
Hyperlight vs gVisor vs runc: measured results
Every row ran the same main.py, which prints two lines and exits. Times are the median of 20 runs after 3 warm-up runs, measured by hyperfine as the full wall clock of the command, so process start, VM or container creation and teardown are all inside the number. Memory is the drop in host MemAvailable with 10 idle sandboxes running, divided by 10. Lower is better in every column.
| Sandbox | Start, median | Start, p95 | Host memory per idle sandbox | Isolation boundary |
|---|---|---|---|---|
Native python3 | 14.7 ms | 15.5 ms | n/a | none |
| hluk, warm snapshot | 81.5 ms | 89.7 ms | 3.3 MiB | hardware VM (KVM) |
| hluk, cold boot | 339.6 ms | 362.3 ms | not measured | hardware VM (KVM) |
| Docker, runc | 484.3 ms | 535.0 ms | 11.9 MiB | namespaces and cgroups |
| Docker, gVisor runsc | 480.7 ms | 746.2 ms | 19.9 MiB | user-space kernel |
Three results decide most choices. A warm hluk start is about six times faster than either container runtime, and even a cold boot from the rootfs beats docker run by roughly 140 ms. The hluk memory cost is small because every micro-VM restored from one snapshot maps the same file, so the page cache holds it once. The gVisor p95 of 746.2 ms is the number to watch: its median matched runc, but seven of its 20 runs took over 600 ms, against a slowest runc run of 544 ms, which makes it the least predictable path here.


Our hluk figures sit well above the vendor numbers. The CNCF post reports 22 ms for a Python hello world from a snapshot on an 8-vCPU Azure VM, and our warm start was 81.5 ms. Our host is a 4-vCPU guest on a laptop-class Intel i7-1165G7 under Proxmox, with KVM nested inside it, so treat the hluk rows as a ranking against the containers on the same box, not as bare-metal values. The profile further down shows where the extra time goes.
What Hyperlight and hluk are, and what they are not
Hyperlight is a small virtual machine manager that you embed as a library in your own program, a CNCF sandbox project that came out of Microsoft. Its core guests have no operating system at all. The hyperlight-unikraft project adds a Unikraft unikernel as the guest kernel, so ordinary Python, Node.js, .NET, Java, Go and shell programs run inside the micro-VM. Its CLI, hluk, boots that kernel, maps a rootfs image pulled from GHCR, runs your script and can snapshot the warmed guest.
Against the usual sandboxes, the difference comes down to where the boundary sits and what each one boots:
- Hyperlight (hluk): a hardware VM per sandbox, created by the calling process itself through KVM, MSHV, WHP or Hypervisor.framework. No guest Linux kernel, no device emulation, and nothing reaches the host unless granted.
- Firecracker: also a hardware VM, but driven by a separate VMM process per microVM that boots a full Linux guest kernel with virtio devices. Our Firecracker microVM guide covers that setup. We did not benchmark it here.
- gVisor: no VM by default. Its Sentry reimplements the Linux syscall surface in user space, so a container never talks to the host kernel directly.
- runc: the plain container. Namespaces and cgroups on the shared host kernel, which is the fastest boundary and the weakest one.
hluk is not a container runtime. It pulls rootfs images rather than OCI container images, only hluk build reads a Dockerfile, and a guest gets no network and no host files until you pass --net-allow or --mount. If you want an OCI runtime for Kubernetes pods, the measured trade-offs live in our gVisor vs Kata Containers vs runc benchmark. hluk fits the narrower job of running one untrusted script, fast and with nothing exposed.
How the benchmark was run
All numbers come from one VM, which we sized like a small CI runner. The container side reuses the method from our earlier isolation benchmark, so the runc and gVisor rows can be read next to that article, although the hosts differ. Here is how each figure was taken:
- Start time:
hyperfine -N --warmup 3 --runs 20over five commands, each running the same two-linemain.py. The Docker imagepython:3.12-slimwas already pulled, and the hluk warm snapshot already existed. - Restore and boot split: the built-in
hluk benchmodes, 20 samples each, which time load, restore and execution inside one process. - Memory: page cache dropped, 10 idle sandboxes started (each runs a script that sleeps for 120 s), then the drop in
MemAvailableafter 30 s, divided by 10. For hluk we also read/proc/<pid>/smaps_rollupto split private from shared pages. - Throughput:
hluk bench parallelwith 4 and 8 micro-VMs restored from one snapshot, 50 calls each.
Our test box is listed below. The Proxmox VM used CPU type host, which passes VT-x through so the guest gets its own /dev/kvm. Without that, nothing in this article runs.
| Component | Version on the test box |
|---|---|
| Host OS and kernel | Ubuntu 24.04.4 LTS, 6.8.0-106-generic, 4 vCPU, 8 GiB |
| CPU and hypervisor | Intel Core i7-1165G7, nested KVM on Proxmox VE |
| hluk (hyperlight-unikraft) | 0.21.0, static musl release binary |
| Guest images | python, agent, node, bash, dotnet-jit at initrd-v0.21.0 |
| Docker and runtimes | Docker 29.1.3 (Ubuntu package), runsc release-20261102.0 from the gVisor apt repository |
| Native baseline | Python 3.12.3, numpy 1.26.4, pandas 2.1.4, scikit-learn 1.4.1 from Ubuntu packages |
On the native side, the data-science stack is older than the one inside the agent image, because we took the Ubuntu packages rather than pip wheels. That makes the native import row slightly flattering to hluk, and we say so again where it matters.
Step 1: Check /dev/kvm and the kvm group
hluk needs a hardware hypervisor it can open as your user, and on Linux that means /dev/kvm. On bare metal, VT-x or AMD-V must be on in the firmware. In a VM, nested virtualization must be passed through, which on Proxmox is CPU type host. Confirm the CPU flag and the device first, because a missing device and a permission problem fail with the same message later:
lscpu | grep -E "Model name|Virtualization|Hypervisor vendor"
ls -l /dev/kvm
On our nested guest, lscpu reports VT-x while also naming KVM as the hypervisor underneath, and the device belongs to the kvm group with mode 660:
Model name: 11th Gen Intel(R) Core(TM) i7-1165G7 @ 2.80GHz
Virtualization: VT-x
Hypervisor vendor: KVM
Virtualization type: full
crw-rw---- 1 root kvm 10, 232 Nov 9 19:14 /dev/kvm
If Virtualization: is missing or /dev/kvm does not exist, fix the firmware or hypervisor setting before going further. Our guide to installing KVM on Ubuntu covers the module checks. Then add your user to the kvm group, because a default Ubuntu account cannot open the device:
sudo usermod -aG kvm $USER
Group changes only apply to new login sessions, so log out and back in, then check that kvm is listed:
id | tr , "\n" | grep kvm
A line such as 993(kvm) means the session can open the device. We skipped this step on purpose on the first run, and the exact failure is in the troubleshooting section at the end.
Step 2: Install hluk from the GitHub release
Releases ship one static musl binary per platform with the Unikraft kernel embedded, so there is nothing to compile and no glibc dependency. The project’s own install.sh does the steps below in one pipe. We prefer running them by hand on a server, because the checksum check is then visible and the version is pinned. Pin it rather than reading the GitHub releases/latest endpoint, because the same repository also publishes releases for its Python integrations (the MCP server among them), and a saved snapshot only loads under the hluk release that wrote it. Check the releases page for a newer tag before you copy this:
HLUK_VERSION="v0.21.0" # pin: snapshots are tied to the hluk release #https://github.com/hyperlight-dev/hyperlight-unikraft/releases
Download the x86_64 archive and the release’s checksum file, then verify the archive against it. On an arm64 host, swap x86_64 for aarch64 in each command below and in the unpack step:
curl -fsSLO https://github.com/hyperlight-dev/hyperlight-unikraft/releases/download/${HLUK_VERSION}/hluk-${HLUK_VERSION}-x86_64-unknown-linux-musl.tar.gz
curl -fsSLO https://github.com/hyperlight-dev/hyperlight-unikraft/releases/download/${HLUK_VERSION}/SHA256SUMS
grep x86_64-unknown-linux-musl SHA256SUMS
sha256sum --ignore-missing -c SHA256SUMS
Each release lists one SHA-256 per archive, and for the x86_64 Linux build it was this line. sha256sum should then print the archive name followed by OK; anything else means a damaged or wrong download:
4b0536a948a9c380cbc7c47e1b04d28c66b2a3d5f25292ae1d90311b181ee722 hluk-v0.21.0-x86_64-unknown-linux-musl.tar.gz
Unpack the archive and install the binary into ~/.local/bin. No root is needed for hluk itself. The default Ubuntu ~/.profile only adds that directory to the PATH if it already existed at login, so on a fresh account export it for the current shell; the next login picks it up on its own:
tar -xzf hluk-${HLUK_VERSION}-x86_64-unknown-linux-musl.tar.gz
mkdir -p ~/.local/bin
install -m 755 hluk ~/.local/bin/hluk
export PATH="$HOME/.local/bin:$PATH"
hluk --version
hluk reports its own version, which is also the tag of the guest images it pulls:
hluk 0.21.0
Record that version somewhere you will see it again. Every release from 0.19 onward has refused the snapshots of the release before it, so upgrading hluk means re-saving any snapshot you keep on disk.
Step 3: Run a Python app in a micro-VM
A project is a directory with a hluk.toml manifest and your script. hluk init writes both from a template and pulls the matching rootfs image, which for Python was 14.0 MiB compressed and 40.6 MiB unpacked in the cache:
mkdir -p ~/lab && cd ~/lab
hluk init hello --template python
On our link the pull took 1.9 s, and the output points at the next two commands:

The generated manifest pins the rootfs to the release that wrote it and turns warm snapshots on. With the comments stripped, these are the keys that matter:
manifest_version = 1
[app]
name = "hello"
[rootfs]
image = "ghcr.io/hyperlight-dev/hyperlight-unikraft/python:initrd-v0.21.0"
[run]
script = "main.py"
warm = true
Commented lines in the same file cover host mounts, environment variables and a network table, the manifest forms of the flags in Step 9. Run the project twice and time both runs:
cd hello
time hluk run
time hluk run
hluk cache ls
The first run took 0.702 s because it booted the guest and then saved a warm snapshot. The second took 0.075 s because it restored that snapshot instead of booting. hluk cache ls shows the price of that speed: a 78.1 MiB snapshot next to the rootfs, keyed to this image and its 256 MiB of guest memory.

Inside the micro-VM, the guest reports itself as Unikraft (x86_64), not Linux, which is the quickest proof that the script ran in the micro-VM and not on the host. Snapshots live under ~/.cache/hluk/snapshots, and hluk cache has a subcommand to remove them when a rootfs changes.
Step 4: Time a cold boot against a snapshot restore
Those time figures include process start and the hluk binary loading itself, so we used the built-in benchmark modes to split the cost. They need a snapshot directory saved by hand, and the parent directory must exist first:
mkdir -p ~/snaps
hluk snapshot save --runtime python -o ~/snaps/py
hluk bench cold-snap ~/snaps/py main.py --samples 20
hluk bench warm-restore ~/snaps/py main.py --samples 20
hluk bench warm-stateful ~/snaps/py main.py --samples 20
hluk bench cold --initrd ~/.cache/hluk/rootfs/ghcr.io/hyperlight-dev/hyperlight-unikraft/python/initrd-v0.21.0.cpio main.py --samples 20
Each mode prints a median, p95, min and max per phase. Saving took 1,901 ms and wrote 79 MiB to disk:

Read phase by phase, the medians show where the time goes:
| hluk bench mode (20 samples) | Load or boot | Restore | Script run | Total |
|---|---|---|---|---|
| cold (boot from rootfs) | 326.8 ms | n/a | 5.7 ms | 332.5 ms |
| cold-snap (snapshot from disk) | 0.2 ms | 4.1 ms | 62.5 ms | 66.7 ms |
| warm-restore (snapshot in memory) | n/a | 2.3 ms | 27.8 ms | about 30 ms |
| warm-stateful (no restore between calls) | n/a | n/a | 0.25 ms | 0.25 ms |
Restore on its own is as fast as the vendor says: 2.3 to 4.1 ms, in line with the roughly 3 ms in the CNCF post. The cost moved into the script run. A freshly booted guest ran main.py in 5.7 ms, while a restored one needed 62.5 ms the first time and 27.8 ms when the snapshot was already in memory. hluk run --profile put 63.8 ms of a warm run inside the guest with only 4 VM exits, so the guest was busy, not the host functions. Our reading is that restored memory is faulted in page by page on first touch, and on a nested host every such fault is expensive. We did not have bare metal to confirm it, so treat that as the likely cause, not a measured one.
That split also explains the parallel result. With 4 micro-VMs restored from one snapshot, the box served 102.4 calls per second at a 27.7 ms median per call. With 8 it served 100.2 calls per second while the median rose to 65.3 ms, because 4 vCPUs were already saturated. The vendor reports about 850 calls per second for 8 VMs on 8 vCPUs, so on our host the ceiling is set by CPU count and nesting, not by hluk. Size for one busy vCPU per concurrent micro-VM and you will not be surprised.
Step 5: Compare hluk start time with runc and gVisor
The comparison needs hyperfine, Docker and gVisor on the same host, plus the Ubuntu data-science packages for the native baseline in Step 6. hyperfine and Docker come from the Ubuntu archive (our Docker on Ubuntu guide covers the upstream Docker CE packages instead). runsc comes from the apt repository on the gVisor install page. These are the commands we ran:
sudo apt-get update
sudo apt-get install -y hyperfine docker.io python3-pandas python3-sklearn
curl -fsSL https://gvisor.dev/archive.key | sudo gpg --dearmor -o /usr/share/keyrings/gvisor-archive-keyring.gpg
echo "deb [arch=$(dpkg --print-architecture) signed-by=/usr/share/keyrings/gvisor-archive-keyring.gpg] https://storage.googleapis.com/gvisor/releases release main" | sudo tee /etc/apt/sources.list.d/gvisor.list
sudo apt-get update && sudo apt-get install -y runsc
sudo runsc install
sudo systemctl restart docker
sudo usermod -aG docker $USER
gVisor documents the apt package as registering itself with Docker, so runsc install may be a no-op on your box; on ours it printed Runtime runsc not found: adding and wrote the runtime into /etc/docker/daemon.json. The docker group, like kvm earlier, needs a fresh login before plain docker run works. Pull the image once so its download is not timed:
docker pull python:3.12-slim
runsc --version
Our box reported runsc version release-20261102.0. The benchmark script runs all five commands under one hyperfine call, so each row saw the same machine state. Create it in your home directory:
vim ~/bench-start.sh
This is the exact script we ran:
#!/bin/bash
# start-time comparison, hello.py, 20 runs after 3 warm-ups
export PATH=$HOME/.local/bin:$PATH
cd ~/lab/hello
hyperfine -N --warmup 3 --runs 20 --export-json ~/caps/start-hello.json --export-markdown ~/caps/start-hello.md \
-n native 'python3 main.py' \
-n hluk-cold 'hluk run --cold' \
-n hluk-warm 'hluk run' \
-n runc "docker run --rm -v $HOME/lab/hello:/app:ro python:3.12-slim python /app/main.py" \
-n runsc "docker run --rm --runtime=runsc -v $HOME/lab/hello:/app:ro python:3.12-slim python /app/main.py"
hyperfine writes its JSON and Markdown exports to ~/caps, so create that directory, then run it. The whole run takes about a minute:
mkdir -p ~/caps
bash ~/bench-start.sh
hyperfine prints mean and range per command, and the medians in the results table come from its JSON export:

Look at the User and System columns too. The Docker client spends under 9 ms of user CPU, because the daemon, containerd and the shim do the work in processes hyperfine cannot see. hluk does its work in its own process, 50.4 ms of user CPU on a warm run, so its numbers are the honest total. The runc and runsc rows are close because both pay the same Docker API, image layer and network namespace setup; gVisor only adds its Sentry start on top.
Step 6: Run the agent template with numpy and pandas
Hyperlight is aimed at the code executor of an AI agent, where every call imports a heavy data stack. The agent template ships numpy, pandas, scipy and scikit-learn in a 134.3 MiB image (405.6 MiB unpacked) and imports them before the snapshot is taken. That snapshot is far larger than the Python one: hluk cache ls listed it at 843.7 MiB, because the agent image runs with 1,536 MiB of guest memory instead of 256 MiB:
cd ~/lab
hluk init ds --template agent
cd ds
time hluk run
time hluk run
time python3 main.py
Our first run took 9.47 s, almost all of it booting the guest and importing the libraries once for the snapshot. The second took 0.199 s, with the imports reported at 0.3 ms because they were already in memory. The native run on the host spent 627.6 ms on the same imports:

On the host, the native line also prints “already loaded in the warm snapshot”, because that text is hard-coded in the main.py of the template; on the host it is simply wrong. For steadier numbers we ran each variant 10 times from the ds directory:
hyperfine -N --warmup 2 --runs 10 -n native "python3 main.py" -n hluk-warm "hluk run" -n hluk-cold "hluk run --cold"
The means and ranges it reported:
| Agent script, 10 runs | Mean | Range |
|---|---|---|
| hluk, warm snapshot | 204.0 ms | 195.3 to 221.1 ms |
Native python3 (Ubuntu packages) | 467.6 ms | 443.5 to 493.8 ms |
| hluk, cold boot | 6,628.2 ms | 6,481.0 to 7,047.9 ms |
Here is the one workload where the micro-VM beats a bare process: 2.3 times faster than native, because the snapshot skips the imports. The vendor saw a wider gap (45 ms against 1,119 ms) on its own host and library set. Without a snapshot the picture flips, and a cold agent boot at 6.6 s is unusable per call. The working pattern is one snapshot per dependency set, restored for every call.
Step 7: Try Node.js, Bash and C# templates
hluk templates lists the project’s supported runtimes across its three support tiers, from fully supported to reference-only (the project’s guest support tiers doc). We ran one from each of the common runtimes to see whether anything outside Python breaks on the same host:
cd ~/lab
hluk init t-node --template node
hluk init t-bash --template bash
hluk init t-dotnet --template dotnet
cd t-node && hluk run && time hluk run && cd ..
We repeated the last line in t-bash and t-dotnet. All three ran on the first try, and the warm timings came out at 0.064 s for Node.js, 0.031 s for the BusyBox shell and 0.263 s for C#:

Image sizes differ a lot: 1.1 MiB for the shell, 47.2 MiB for Node.js and 50.6 MiB for .NET. The C# template compiles your source inside the guest with Roslyn, which is why it is the slowest warm start of the three. The bash template is BusyBox hush, not GNU Bash, so POSIX scripts and pipes work while Bash arrays and [[ ]] do not.
Step 8: Measure memory per micro-VM
Memory per sandbox decides how many fit on a node, and no published Hyperlight figure covers it. We started 10 idle guests of each kind, each running a script that sleeps for 120 s, and read the host before and after:
| 10 idle sandboxes | MemAvailable drop per sandbox | Per-process view |
|---|---|---|
| hluk, warm snapshot | 3.3 MiB (3,408 KiB) | RSS 18.9 MiB, PSS 3.9 MiB per hluk process |
| Docker, runc | 11.9 MiB (12,194 KiB) | docker stats 4.2 MiB per container |
| Docker, gVisor runsc | 19.9 MiB (20,338 KiB) | docker stats 14.8 MiB; sandbox, gofer and shim PSS 194.5 MiB for 10 |
A single idle hluk process breaks down like this in smaps_rollup: 19.5 MiB resident, made of 11.9 MiB mapped from the snapshot blob, 4.9 MiB for the hluk binary and 2.2 MiB of private anonymous memory. The first two are file pages shared by every process that maps them, which is why PSS fell to 3.9 MiB with 10 running. A second run of 10 guests confirmed it in /proc/meminfo: anonymous pages rose by 2.2 MiB per micro-VM, while the page cache grew by 23.1 MiB once for all 10. So the marginal cost of one more warm Python micro-VM is about 2 to 4 MiB, plus whatever the script allocates.
That figure only holds while the guest stays idle. A guest that writes to its memory gets private copies of those pages, up to the 256 MiB the manifest gives it, so a pandas job holding a large DataFrame costs what the DataFrame costs. The containers differ in the same way: the runc figure of 11.9 MiB is the 4.2 MiB the container itself reports plus its shim and Docker’s bookkeeping, and the 19.9 MiB gVisor figure adds the Sentry and gofer. On a host packing 100 idle executors, that is about 0.3 GiB for hluk against 1.2 GiB for runc and 1.9 GiB for gVisor.
Step 9: Grant network and file access
A guest starts with no network and no host files, and each capability is a flag on hluk run or a key in hluk.toml. We tested the boundary with a probe script that opens a TCP connection, reads /etc/hostname and tries to write into a mount. Create it in the hello project:
vim ~/lab/hello/probe.py
Paste the probe:
import os, socket
try:
socket.create_connection(("1.1.1.1", 443), timeout=3)
print("net: connected to 1.1.1.1:443")
except OSError as e:
print(f"net: {e}")
try:
print("host file:", open("/etc/hostname").read().strip())
except OSError as e:
print(f"host file: {e}")
print("guest /:", sorted(os.listdir("/"))[:10])
if os.path.isdir("/mnt/data"):
print("mounted:", os.listdir("/mnt/data"))
try:
open("/mnt/data/out.txt", "w").write("x")
print("write: ok")
except OSError as e:
print(f"write: {e}")
Run it three ways: with no grants, with a read-only mount, and with a writable mount plus one allowed network destination:
mkdir -p ~/data && echo "id,value" > ~/data/input.csv
cd ~/lab/hello
hluk run --runtime python probe.py
hluk run --runtime python --mount ~/data:/mnt/data:ro probe.py
hluk run --runtime python --net-allow 1.1.1.1 --mount ~/data:/mnt/data probe.py
ls ~/data
Without grants, the connection fails with [Errno 13] Permission denied, and /etc/hostname in the guest is the empty file from its own rootfs, not the host’s bench01:

The :ro mount exposed input.csv and refused the write with [Errno 30] Read-only file system. The third run connected to 1.1.1.1 and wrote out.txt, which then appeared on the host. Two details matter for an agent sandbox. --net-allow is a destination filter, so allow only the hosts the code needs (for pip, pypi.org and files.pythonhosted.org). Mounts are not stored in snapshots, so grant them on every run. The guest root is an in-memory filesystem that is thrown away on exit, so anything you want to keep must go through a mount.
Errors we hit with hluk
Four errors came up during the lab. The first two will reach most readers, and the other two cost a minute each.
Error: “Create VM error: No hypervisor was found”
We got this on the very first hluk run, with /dev/kvm present and the CPU flag visible. The message is misleading: a hypervisor existed, but the user was not in the kvm group, so the device could not be opened. The id output in the capture shows only sudo in the groups:

Add the user to kvm as in Step 1 and start a new login session. If the error stays after that, /dev/kvm is missing or unusable, which inside a VM means nested virtualization is off on the parent hypervisor.
Error: “the snapshot … was saved by hyperlight-unikraft 0.20.1”
Snapshots are tied to the exact kernel and host contract of the build that saved them. We saved one with the previous release and loaded it with the current one to see the failure:

hluk refuses on purpose, and the message names both snapshot keys. hluk snapshot key prints the key of the installed build (kfb05f5f9150b9c48-c8 for ours), so a deploy script can compare it with a stored snapshot before relying on it. Re-save the snapshot after every hluk upgrade. Warm snapshots in the cache are created again on the next hluk run, but snapshots you saved with -o are not.
Error: “save: parent directory … not accessible”
hluk snapshot save -o ~/snaps/py failed with No such file or directory (os error 2) because ~/snaps did not exist. hluk creates the snapshot directory but not its parent, so run mkdir -p on the parent first, as in Step 4.
Error: “unrecognized subcommand ‘list'”
For the cache, the subcommand is hluk cache ls, not list, and hluk suggests the right spelling in its reply. It is a small thing, but scripts written against other CLIs trip on it.
When to choose Hyperlight over a container sandbox
On this host, hluk was the fastest and smallest isolated sandbox we measured, as long as a snapshot exists and the workload fits the guest images. That gives a short decision list:
- Short untrusted scripts, such as the code tool of an AI agent: hluk with one warm snapshot per dependency set. 81.5 ms per Python call, 0.2 s with pandas loaded, and about 2 to 4 MiB per idle micro-VM. An MCP server from the same project wraps the same engine for coding agents, and our Claude Code cheat sheet covers how MCP servers are added.
- Long-running services or anything that needs the Linux syscall surface in full: gVisor or a VM-based runtime, because hluk runs a unikernel and its own driver per runtime, not a general Linux userland.
- Trusted code where only startup matters: a plain process. Native Python started in 14.7 ms, five times faster than a warm micro-VM.
- Kubernetes pods: stay with runc, gVisor or Kata through a RuntimeClass. hluk can be wired into containerd through urunc, but that path is a demo in the repository, not something we tested.
Two cautions before production. The project moved from 0.19 to 0.21 in under a month and each release refused snapshots from the one before, so pin the binary and rebuild snapshots in your deploy, never on first request. And benchmark on your own hardware: our nested host added tens of milliseconds to every restored call, which the CNCF numbers from the Azure host did not show. The metric to watch is per-call exec time after restore, not the restore itself.