Private infrastructure. Public contract.

Virtualization infrastructure that tells the truth.

A modern control plane and host agent for operating VMs on Linux + KVM—built in Rust, driven by an enforced API, and designed to recover from the failures real systems have.

Control plane
Rust 1.97 + Tokio + Axum
Hypervisor
KVM + CH / QEMU
Operations
OpenAPI + Nushell
nextVIRT
Live
FLEET OVERVIEWGood afternoon, operator.
HOSTS ONLINE3 / 3All healthy
VMS RUNNING13 / 1776% active
ACTIVE TASKS1Creating alpine-3
HostsCapacity and health
kvm-17 VMs
62%
kvm-26 VMs
48%
kvm-34 VMs
31%
VM CREATEalpine-3
72%
RUSTTOKIOAXUMKVMCLOUD HYPERVISOR + QEMUNUSHELL

01 / THE PLATFORM

One control plane.
Every action accounted for.

nextVIRT separates intent from execution. The control plane records what should exist; host agents report what does. Reconciliation closes the gap without pretending failures never happen.

01

Declare intent

Define a VM through the same versioned API used by the web UI and CLI.

02

Persist the task

Long-running work is recorded before side effects begin, with progress and ownership.

03

Execute on-host

The host agent owns VM processes, disks, networking, and local safety.

04

Reconcile reality

Observed state wins. Inventory and events show what happened—not what was hoped for.

API

API-first, enforced.

The REST API is the product. The UI, CLI, and control plane are all clients, with build-time guardrails that catch undocumented routes and boundary violations.

  • Committed OpenAPI contract
  • Scoped keys and role-based access
  • Optimistic concurrency with ETags
REC

Designed to restart.

Both processes assume they can be interrupted at any point. State is written first, effects are idempotent, and startup reconciliation leaves a record instead of a mystery.

  • Persistent task history
  • Crash-only recovery model
  • Verified host health and fencing
OPS

Built for operators.

Every important transition becomes a task or event. Operate visually, automate through the API, or compose fleet-wide workflows with native Nushell pipelines.

  • Live task and event streams
  • Structured, typed CLI values
  • Auditable changes by default

02 / ARCHITECTURE

Small pieces.
Hard boundaries.

A single control plane owns inventory, placement, policy, tasks, and the public API. A focused agent on each host owns execution. The boundary between them is explicit, versioned, and testable.

01Control planeDesired state, scheduling, API, UI, audit trail
02Host agentVM lifecycle, storage, networking, console
03Cloud Hypervisor + QEMUDirect-kernel speed or UEFI/VNC compatibility, selected by boot mode
CLIENTS
Web UIReact
nextvirtNushell
AutomationREST API
HTTPS / JSON
CONTROL PLANE
nextvirt-apiRust
InventorySchedulerTasksEvents
SQLite
mTLS / host API
KVM HOSTS
kvm-1nextvirt-hostd
VMVMVM
kvm-2nextvirt-hostd
VMVM

03 / INSIDE THE STACK

The implementation,
without the hand-waving.

nextVIRT is a composed systems stack, not a wrapper around shell scripts. The control plane, agent, clients, contracts, and operator surfaces share typed models while keeping execution boundaries deliberately narrow.

16Rust workspace crates
103documented REST operations
20forward-only migrations
31React application screens
CONTROL-PLANE REQUEST PATH
01CaddyTLS termination
02AxumREST + WebSocket
03AuthSession · CSRF · RBAC
04CorePolicy · tasks · placement
05SQLxSQLite WAL
01

RUNTIME

Linux + KVM

host

Each VM is a detached process on a Linux host. Direct-kernel guests run on Cloud Hypervisor v48 through its HTTP-over-Unix-socket API; firmware guests run on QEMU through QMP for UEFI, graphics, and VNC. Both sit behind the same host-side hypervisor interface.

Compute
/dev/kvm · virtio · per-VM process
Kernel boot
Cloud Hypervisor · serial socket
Firmware boot
QEMU · OVMF · QMP · noVNC
Recovery
Socket probe · process re-adoption
02

CONTROL PLANE

Rust services

async

Rust 1.97, Tokio, and Axum power the API, task engine, scheduler, poller, event feed, and embedded product UI. Utoipa generates the OpenAPI document; the committed snapshot is checked against registered routes so contract drift fails the build.

Runtime
Tokio multi-thread · structured tracing
HTTP
Axum 0.8 · Tower · WebSocket
Contract
Utoipa · OpenAPI 3 · typed clients
Packaging
rust-embed · one control-plane binary
03

STATE + STORAGE

Local first, pluggable

durable

Inventory and operations live in SQLite through SQLx, with WAL mode, foreign keys, embedded migrations, and a single database-owning crate. Local, shared, and object-backed disks keep their native semantics; NuFinder provides the content-addressed volume path for backups and recoverable object storage.

Inventory
SQLite WAL · SQLx 0.8 · JSON fields
Local disk
ZFS zvol clones · sparse raw files
Shared disk
NFSv4.2 · iSCSI initiator
NuFinder
nfd · SHA-256 chunks · S3 · NBD + COW
04

NETWORKING

Kernel-native dataplane

netlink

Host-local networks use Linux bridges, deterministic tap names, and bridge VLAN filtering. Cluster overlays use OVN logical switches and routers over Geneve, with OVS port identity and distributed ACL machinery at the edge.

Host-local
rtnetlink · Linux bridge · TAP
Segmentation
802.1Q PVID · bridge filtering
Overlay
OVN · OVS · Geneve
Policy
Logical ports · port groups · ACLs
05

TRUST + SAFETY

Identity at every boundary

verified

Browser sessions use CSRF protection and capability-based authorization. Automation uses scoped API keys. Control-plane-to-agent traffic can use rustls mTLS with host UUIDs as identities, avoiding trust in addresses that can move.

Operators
Argon2id · sessions · CSRF · RBAC
Automation
SHA-256 API keys · scoped capabilities
Host identity
rustls · X.509 · UUID SAN · 90-day leaf
Concurrency
ETag / If-Match · idempotency keys
06

OPERATOR SURFACES

One API, three clients

typed

The React UI, Rust client, and embedded Nushell environment all consume the same API. The UI is baked into the control-plane binary; the shell turns API resources into native dates, durations, filesizes, records, and streams instead of flattening them to text.

Web
React 19 · TypeScript · Vite 7
Data + UI
TanStack Query · Kensho · Tailwind 4
Console
xterm.js · noVNC · WebSocket proxy
Shell
Nushell 0.115.1 · keyring · live streams

NUFINDER VOLUME ENGINE

Object storage that behaves like a volume.

nfd, the NuFinder daemon, is built into nextVIRT’s storage path. The host agent drives it as an isolated sidecar, turning VM disks and memory snapshots into immutable manifests of verified 4 MiB chunks. The result is incremental-forever backup, fleet-wide deduplication, and recovery from any host that can reach the volume.

Built + lab verified 1 GiB cold upload 4.7s 4-byte edit 1 chunk

WRITE + RECOVERY PATH

01VM diskor memory snapshot
02nextvirt-hostdstreamed, bounded memory
03nfd manifestSHA-256 · 4 MiB chunks
04VolumeLocationS3 · MinIO · local · RAID
DIRECT RECOVERY manifest → ranged reads → nextvirt-blockstore → NBD → QEMU local NVMe copy-on-write overlay
01 / CONTENT

Store changes, not copies

Only changed chunks upload. Identical blocks—even across VMs—resolve to the same immutable object.

02 / INTEGRITY

Verify every layer

SHA-256 content addressing, per-chunk verification, signed manifests, journal replay, and scheduled scrub.

03 / LIFECYCLE

Retain with intent

Versioned bindings, leases, retention, garbage collection, and S3 Object Lock separate recovery from deletion.

04 / MOBILITY

Recover without shared storage

Pin a manifest, expose it through NBD, and start the VM on another host with a local COW write layer.

The backup, retention, scrub, manifest pinning, and NBD-backed recovery paths are implemented and exercised against real MinIO and KVM hosts. Production scheduling and storage hardening remain active engineering.

THE ENGINEERING GATE

Architecture rules are executable.

Formatting, Clippy with warnings denied, the complete Rust test suite, documentation links, TypeScript, generated API types, and Vitest all run as one gate. The workspace denies unsafe Rust, and boundary scanners reject SQL, process spawning, host paths, or HTTP clients in the wrong layer.

01cargo fmt --checkPASS
02cargo clippy -D warningsPASS
03cargo test --workspace896 tests
04openapi snapshot + api typesLOCKED
05tsc + vitestPASS

04 / OPERATIONS

Infrastructure is data.
Use it like data.

The nextVIRT shell embeds Nushell, so resources are typed records—not strings to scrape. Filter them, transform them, and pipe them directly into safe mutations.

nextvirt — production
connected
# Find quiet running VMs, then stop them as one bounded operation.
production〉 show vms --power running | where cpu_percent < 5 | select name host power cpu_percent memory

name             host     power     cpu_percent   memory
alpine-1         kvm-1    running   1.4%          512 MiB
build-runner     kvm-2    running   3.1%          8.0 GiB
web-edge         kvm-2    running   0.8%          2.0 GiB

production〉 $in | vm stop --no-wait --parallel 8 | task wait
✓ 3 tasks succeeded in 4.8sec

NATIVE VALUES dates · durations · filesizes · records · tables

PIPELINE TOOLS where · sort-by · select · get · group-by · first · length · to json

EXECUTION interactive REPL · nextvirt -c · scripts on stdin

05 / ENGINEERING STATUS

Built against reality.

nextVIRT is under active engineering. Core behavior is tested through contract checks, deterministic agent simulations, and real KVM infrastructure—not only mocked happy paths.

SYSTEM SIGNAL2026.09
Control plane + host agentOperational
VM lifecycle + live consoleOperational
Task engine + event streamOperational
HA and storage hardeningActive work
Engineering preview · interfaces may evolve

THE NEXT LAYER OF VIRTUALIZATION

Operate what is.
Automate what should be.

Back to the control plane