Firecracker is a lightweight virtual machine monitor (VMM) designed for secure, multi-tenant cloud workloads. It creates microVMs using hardware virtualization (KVM) combined with container-like speed, primarily targeting serverless and container runtime environments. The system exposes a RESTful API for VM lifecycle management, configuration, and snapshotting, with a strong emphasis on security through seccomp filtering and process isolation via a dedicated jailer binary. The architecture consists of a core VMM binary written in Rust, handling device emulation (VirtIO), memory management, and KVM integration. It supports both x86_64 and aarch64 architectures, with significant conditional compilation to manage hardware-specific differences. The project includes a comprehensive testing framework using Python for integration, functional, and security validation, alongside formal verification proofs (Kani) for critical paths like network packet parsing. While the core VMM logic is highly optimized and production-grade, the codebase exhibits medium technical drift due to tight coupling with specific Linux kernel versions and features (e.g., io_uring, userfaultfd). The Rust toolchain configuration also shows experimental flags (edition 2024), indicating ongoing adaptation to newer compiler standards. Despite this, the project remains actively maintained with a robust CI/CD pipeline and regular security updates.
Hyperlight is a production-grade library for safely executing untrusted code inside hypervisor-isolated micro virtual machines. It spins up lightweight VMs in milliseconds without requiring a guest kernel or operating system, making it suitable for sandboxing plugins, serverless functions, and other untrusted workloads. The system supports multiple hypervisor backends (KVM on Linux, MSHV on Windows, WHP on Windows, HVF on macOS) and architectures (x86_64, aarch64), with guest binaries compiled as no_std Rust or C ELF files using a custom libc (picolibc). Communication between host and guest is performed via typed function calls serialized with FlatBuffers over VM exits, and the library provides snapshot/restore capabilities using an OCI-compatible image layout for state persistence. The architecture is centered around a host-side Rust library (`hyperlight_host`) that exposes a builder pattern (`SandboxBuilder`) to configure and create sandboxes. The guest runtime (`hyperlight_guest_bin`) handles initialization, page tables, exception handling, and function dispatch. A component model integration (`hyperlight_component_util`) generates Rust bindings from WIT (WebAssembly Interface Types) for higher-level interfaces. The system also includes guest tracing with OpenTelemetry, metrics collection, crash dump generation, and GDB debugging support. External dependencies include hypervisor-specific APIs (KVM ioctls, WHP, HVF), the FlatBuffers serialization library, and the OCI image layout specification for snapshot storage. Key data flows involve the host loading a guest binary, setting up memory regions (code, heap, stack, scratch), registering host functions, and then executing guest functions via VM entries. The guest can call back into the host through registered host functions. Snapshots capture the full guest state (memory, registers, MSRs) and can be saved to disk as OCI-compatible blobs, then restored to create new sandboxes or recover from failures. The library is extensively tested with unit tests, integration tests, fuzz targets, and concurrency stress tests, and is maintained as a CNCF sandbox project with active development and frequent releases.
UTM is a full-featured virtual machine host for iOS and macOS, built on top of QEMU and Apple's Virtualization.framework. It allows users to run operating systems such as Windows, Linux, and macOS on Apple devices. The application provides a SwiftUI-based interface for creating, configuring, and managing virtual machines, with support for both emulation (QEMU) and native hypervisor (Apple Virtualization) backends. Key features include SPICE-based display and input, USB device passthrough, shared directories, clipboard synchronization, remote access via a custom TLS-secured protocol, and AppleScript automation. The architecture is modular, with separate layers for configuration models (Codable structs), platform-specific UI (iOS/macOS/visionOS), services (VM lifecycle, SPICE I/O, logging), and a remote server/client component. The build system is complex, involving cross-compilation of patched QEMU, SPICE, and dozens of other libraries via shell scripts, and the project supports multiple product variants (standard, SE with threaded interpreter, remote-only).
Solo5 is a sandboxed execution environment for unikernels, providing a minimal, legacy-free interface between unikernel applications and host systems. It supports multiple backends: hvt (hardware virtualization via KVM, FreeBSD/OpenBSD/DragonFly vmm), spt (Linux seccomp sandbox), virtio (QEMU/bhyve), Xen, and Muen. The architecture consists of guest-side bindings (implementing the solo5_* API) and host-side tenders (loaders/runtime components). Key entry points include the guest's _start() in each binding's start.c and the tender's main (e.g., hvt_main.c, spt_main.c). Data flows are synchronous: unikernels communicate via hypercalls (hvt), seccomp-allowed syscalls (spt), or Xen hypercalls, with shared-memory ring buffers for I/O. External dependencies include libseccomp (spt), KVM/BSD hypervisor APIs, and vendored Xen public headers. The project originated from IBM Research and is used by MirageOS and other unikernel frameworks.
Xen Orchestra is a comprehensive management platform for XenServer/XCP-ng virtualization environments. It provides a web UI (legacy React and modern Vue 3), a REST API, CLI tools, and a backup system. The architecture is a monorepo with multiple packages: server-side plugins (authentication, performance alerts, SDN controller, backups), frontend apps (xo-web React, @xen-orchestra/web Vue 3, @xen-orchestra/lite lightweight), and shared libraries (filesystem abstractions, VHD manipulation, cron parsing, audit logging, etc.). The backend communicates with XenServer hosts via the Xen API (XAPI), while the frontend connects via WebSocket/JSON-RPC or REST. Backup operations can be executed remotely via a proxy. Key data flows involve the web UI sending commands through WebSocket to the server, which translates them into XAPI calls. Backup jobs are scheduled via cron and executed by the backup runner system, streaming VM disks to remote storage. Audit events are logged with cryptographic chaining for tamper evidence. The system includes an MCP server for AI-assisted management. The repo demonstrates high engineering quality in many packages with clean abstractions for async operations, event-driven collections, and modular plugin systems, though it contains legacy components and some incomplete transitions to newer architectures.