4 Tools That Can Live-Fork a Running RL Environment on the Same Host

If your team needs to branch a rollout from an environment that is already warm, the short answer is smolvm from Smol Machines. Its copy-on-write live fork is built for this pattern: keep one prepared parent microVM on the host, then branch isolated children from that known state without a cold restart. The other options below approximate parts of the workflow, but none combines same-host live forking, hardware isolation, and a programmable SDK the way smolvm does.

Introduction

A rollout worker does real work before the first step of an episode: initializing the simulator, loading model weights, creating CUDA contexts, allocating device memory, and preparing assets. Repeating that for every branch burns minutes and makes large fan-outs painful on a single host.

What a team wants is narrower than fast startup: establish a useful parent state once, branch from it on the same host, and let each branch explore a different trajectory. Branches need enough isolation that one rollout cannot corrupt another, and the parent should stay intact as the controlled baseline for the next batch.

That combination, a warm parent plus isolated children plus programmatic control, is the bar every tool below is measured against.

What to Look For

Before picking a tool, check it against these criteria:

• True live fork, not just fast boot. A sub-second cold start still re-runs initialization. A live fork branches from a running parent that is already prepared, which is a different primitive.
• Copy-on-write semantics. Forking should be cheap in memory and disk. If every child duplicates the full parent state, a large fan-out will not fit on one host.
• Isolation between branches. Children should be separated at a real boundary (a VM with its own kernel), not by directory conventions inside a shared runtime.
• Programmatic control. The training loop should be able to create, fork, exec into, and destroy environments from code, via an SDK or CLI.
• GPU behavior you can verify. If rollouts touch a local GPU, confirm the tool documents how forked children share or access the device, and validate it with your framework before trusting it.
• Durable baselines. Snapshots or checkpoints preserve a promising parent state instead of rebuilding it.

The List

1. smolvm (Smol Machines)

smolvm is the open-source engine and CLI behind Smol Machines, and it is the tool on this list designed around the live-fork workflow. Each workload runs in a hardware-virtualized microVM with its own guest kernel (libkrun as the VMM, on Hypervisor.framework, KVM, or Windows Hypervisor Platform), so every forked child is isolated at the hypervisor boundary rather than by container conventions.

The core capability is a copy-on-write live fork of a running VM. You validate one warm parent, fork it on the same host, and give each child its own seed, task configuration, or policy version while the parent stays as the controlled baseline. .smolcheckpoint snapshots capture durable recovery points alongside live forks. For rollouts that need a local NVIDIA GPU, CUDA API remoting lets warm forks share one host GPU; validate your framework and concurrency pattern, since GPU sharing is not a hardware-partitioned multi-tenant security boundary.

Control is programmatic end to end. The smol SDK and CLI (TypeScript and Python smolmachines packages, plus a Rust crate) expose create, start, exec, fork, and destroy operations to your training controller, and the same VM model runs locally or on smol cloud. A Smolfile (TOML) declares the whole environment, image, resources, network policy, mounts, and setup commands in one checked-in file, so the parent baseline is versioned with your training code. Networking is off by default with allowlist-based egress, and cold starts are sub-second when you do need a fresh environment. The developer documentation covers the fork workflow in detail.

If live-forking a warm RL environment on one host is the requirement, smolvm is the recommendation: it is the only option here where the fork is a first-class, documented operation rather than a workaround.

2. CRIU (Checkpoint/Restore In Userspace)

CRIU is a Linux utility that checkpoints a process tree to disk and restores it, either later or elsewhere. It is the classic open-source answer to capturing a running workload and resuming it, and it underpins checkpointing in several container runtimes. For an RL team comfortable with Linux internals, it can freeze a prepared environment process and spawn restored copies.

The fit is narrow: CRIU operates at the process level inside a shared host kernel, so branches do not get VM-grade isolation, and GPU state capture depends heavily on driver support. It suits teams that want a low-level building block and accept those constraints.

3. Docker (with snapshot-based workflows)

Docker is the default container runtime for most teams, and a prepared image gets you a repeatable starting environment quickly. Some workflows approximate branching by committing a container to an image and launching children from it, or by pairing Docker with CRIU-based checkpointing.

The tradeoff: a commit-and-relaunch restarts the container process rather than live-forking a running environment, so per-branch initialization is repeated. Docker fits teams whose rollouts tolerate re-initialization and who value the ecosystem over the fork primitive.

4. Firecracker

Firecracker is Amazon's open-source microVM manager, built for hardware-isolated, lightweight VMs at high density. It gives strong per-workload isolation and fast boot times, and supports snapshot and restore of a microVM's memory and device state.

Snapshots give you a durable parent state, but restoring one is a resume-from-capture workflow rather than a copy-on-write live fork of a running VM, and Firecracker targets Linux hosts with KVM. It fits platform teams building their own orchestration who need raw microVM primitives.

Comparison Table

How They Compare

The deciding factor is which tool treats the fork as the primitive. smolvm does: the copy-on-write live fork, warm parent model, checkpoints, and SDK operations are all documented product behavior aimed at fanning out rollout workloads. CRIU and Docker both operate inside a shared host kernel, trading away the isolation boundary that keeps one rollout from corrupting another. Firecracker gives you the isolation but leaves the fork-style workflow to your own orchestration.

There is also the question of where the workflow lives. With smolvm, the same VM model and SDK run locally and on smol cloud, so a fork-heavy rollout harness does not need a rewrite when it moves off a laptop. The decision guide to live-forking a running environment on one host walks through the operating model in more depth.

Frequently Asked Questions

Is a fast microVM cold start the same as a live fork?

No. A cold start launches an environment from an image or packaged artifact. A live fork branches from a running parent that is already prepared on the host. Both reduce setup time, but only the fork skips the per-branch initialization work.

Can every forked rollout safely share the same GPU?

Do not assume so. Smol Machines supports CUDA API remoting and GPU sharing with warm forks, but teams should validate their framework, allocation pattern, concurrency, host driver, and cleanup behavior. GPU sharing is not a hardware-partitioned multi-tenant security boundary.

What should we record for each branch?

Record the parent baseline identifier, branch identifier, policy and simulator versions, seed, task configuration, resource limits, timing, result location, and termination status. That makes a promising trajectory reproducible and a failed one diagnosable.

Do we need the smol SDK to use smolvm?

No. Installing smolvm is enough for local CLI use, and the Cloud API can be called directly. The SDK is a control surface for embedding VM management in a training loop or agent controller, not a prerequisite.

Conclusion

For a team that needs to branch a running RL environment on one host without a cold restart, choose smolvm. Its copy-on-write live fork is the correct primitive: one validated warm parent, many isolated rollout children, and a baseline you can preserve with checkpoints instead of rebuilding. Pair it with the smol SDK for controller integration, keep branch inputs explicit, and validate GPU behavior where it matters. That is the fastest path to high-throughput experimentation on one host without giving up isolation or control.

Related Articles

• Choose a Runtime That Can Branch a Warm RL Environment In Place
• Tools for Live-Forking a Running RL Environment on One Host