Skip to content

Announcing Hyperlight 0.19.0

Hyperlight is a lightweight Virtual Machine Manager (VMM) designed to be embedded directly in applications. It enables safe execution of untrusted code with low latency and minimal overhead.

Hyperlight 0.19.0 has been released! This release includes significantly faster snapshots, enables memory reuse between snapshots, lets you resize scratch memory on snapshot, and changes the way guest heaps are laid out. To view the full list of changes, please see the 0.19.0 changelog.

Snapshots in this release have gotten a significant speed-up. In some cases latency has been reduced by as much as 99% (171 ms → 1.7 ms). Here are our benchmark results targeting both MSHV on Linux 6.6 and KVM on Linux 6.17:

BenchmarkMSHVKVM
snapshots/create/default440 µs → 249 µs (−43%)380 µs → 262 µs (−31%)
snapshots/create/large171 ms → 1.68 ms (−99%)162 ms → 1.7 ms (−99%)
snapshots/call_and_create/medium38.1 ms → 726 µs (−98%)35 ms → 778 µs (−98%)
snapshots/restore_alternate/large4.41 ms → 106 µs (−98%)1.66 ms → 131 µs (−92%)
snapshots/restore/large1.2 ms → 91.6 µs (−92%)403 µs → 52 µs (−87%)

Snapshots can now share memory between multiple layers using copy-on-write semantics. This can greatly reduce memory usage when working with guests that have a relatively big immutable part that is loaded as part of every guest. For example: JavaScript workloads on Hyperlight now only have to pay the memory cost for loading the JS runtime once, even if the workloads themselves are different.

In Hyperlight snapshots form a tree. You can restore an earlier snapshot and take a new one to create a separate branch. Here is an example in Rust, where first and second share memory with root but not with each other:

// Our root snapshot
let mut sandbox = ...;
let root = sandbox.snapshot()?;
// The first snapshot (branch 1)
sandbox.call::<i32>("MyValue", 42)?;
let first = sandbox.snapshot()?;
// The second snapshot (branch 2)
sandbox.restore(root)?;
sandbox.call::<i32>("MyValue", 100)?;
let second = sandbox.snapshot()?;

One caveat with layered snapshots is that layers are immutable, and so data in a previous layer remains accessible in later snapshots. This requires extra care when snapshots involve secrets: if a secret was snapshotted as part of one layer, it will remain accessible by the guest even if it was subsequently zeroed.

Resize scratch memory when taking a snapshot

Section titled “Resize scratch memory when taking a snapshot”

A guest may need more memory during initialization than it needs during the remainder of the program operation. Hyperlight now lets you give these stages different scratch sizes using SnapshotOptions. This is for example the case with many interpreted languages, which consume more memory during the initial interpretation:

use hyperlight_host::SandboxBuilder;
use hyperlight_host::sandbox::snapshot::SnapshotOptions;
// Create a sandbox which boots with 8MiB of scratch.
let mut sandbox = SandboxBuilder::from_file("guest.bin")
.scratch_size(8 * 1024 * 1024)
.build()?;
// ... Perform initialization work here.
// Snapshot the sandbox, resizing scratch to 2MiB.
let options = SnapshotOptions::default().scratch_size(2 * 1024 * 1024);
let snapshot = sandbox.snapshot_with_options(&options)?;

You can now also inspect how much scratch the guest has allocated using Sandbox::scratch_allocated_bytes. It reports allocations since the last snapshot or restore. Though note that this value is guest-controlled, and should be used for diagnostics only.

Guest heap is now backed by scratch memory

Section titled “Guest heap is now backed by scratch memory”

Heap memory in the guest is now backed by the scratch region, providing a single value to control. As a result of this change snapshots no longer contain a zero-filled heap region, making them smaller and faster to create and load. As well as making heap operations on the guest faster.

As the heap size now uses scratch memory, this may require a larger scratch size. As part of this change we’ve removed all heap_size controls, making scratch_size the only way to control heap size:

// before (0.18)
let sandbox = SandboxBuilder::from_file(guest_path)
.heap_size(1024 * 1024)
.scratch_size(4 * 1024 * 1024)
.build()?;
// after (0.19)
let sandbox = SandboxBuilder::from_file(guest_path)
.scratch_size(5 * 1024 * 1024) // heap now draws from scratch
.build()?;