Build Your Own Virtual Machine and a Tiny Hypervisor
Build a tiny computer, then boss it around with a hypervisor: fetch, decode, execute, giggle.
Build Your Own Virtual Machine and a Tiny Hypervisor
Designing a virtual machine is one of the cleanest paths to understanding how computers work. You get to pick an instruction set, define memory behavior, and implement the fetch, decode, execute loop. Add a small hypervisor to multiplex a few instances, and you have a personal lab for computer architecture, runtimes, and systems design.
In this article I distill this seemingly complex topic into a single guided narrative. We start from the clarity of LC-3 style teaching machines, borrow lessons from a metacircular JVM, sketch a pragmatic system-VM roadmap, then finish with a compact architecture and a working Scala 3 hypervisor you can paste into a single file and run. The goal is readability first, speed and features later.
From LC-3 to a learnable machine
The LC-3 tradition proves that a small, regular instruction set teaches more with less ceremony. A 16 bit word size, a flat memory with 65,536 words, 8 general registers, and a tiny set of opcodes are enough to exercise control flow, arithmetic, and I/O. System services arrive through TRAP vectors that behave like a minimal ABI. You can single-step instructions, inspect registers, and observe how condition codes guide branching. The design rewards a clean interpreter with tight control over state.
The key habits to keep from LC-3 are a fixed instruction width, simple encodings that fit in one word, PC-relative addressing that keeps binaries relocatable, and memory-mapped or TRAP based I/O so the VM can present a stable contract to the outside world.
What Metascala teaches about runtimes
A metacircular interpreter like Metascala shows how far you can go by keeping the core small, explicit, and testable. It parses class files into immutable structures, executes bytecodes with a compact loop, allocates on a private heap, and stops the world for garbage collection. Host effects are channeled through explicit bindings, which turns the runtime into a capability system you can reason about. You do not need HotSpot level complexity to learn how stack frames, object layouts, and dispatch tables work. You do need crisp boundaries among loader, interpreter, heap, and host calls.
The broader lesson is to choose clarity over raw speed. Make state visible, keep components swappable, and structure tests so you can compare behavior against known results.
