Two halves: the lineage of the virtual machine (first hypervisor 1967 → healed in hardware 2005), and the embedding stack — how many machines-inside-machines your code actually sits within — with an honest accounting of where WSL2 and Docker really land (they're not the same kind of thing).
The first OS to implement complete virtualization — each user got a full virtual S/360. Ran 14 simultaneous VMs; privileged instructions trapped to the control program, which simulated them. Trap-and-simulate is the seed of everything.
CP-40 ported to the S/360-67 — the first widely available VM architecture, given to key time-sharing customers.
The first VM operating system IBM shipped as an official product — and the first hardware-assisted virtualization (System/370). The production hypervisor mainframes ran for decades.
The doctrinal test: an architecture is efficiently virtualizable iff its sensitive instructions are a subset of its privileged instructions — every instruction that could expose machine state must trap to the supervisor. The rule every CPU is measured against for 30 years.
Virtualization vanished from PCs: x86 broke the Popek-Goldberg rule — 17 sensitive instructions failed silently in user mode instead of trapping. The measure-level crack: a specific count of instructions that wouldn't behave.
Healed x86 by rewriting kernel code on the fly to force the missing traps — making x86 virtualization commercially viable for the first time. The old rule satisfied by translation.
The hardware finally added the traps x86 lacked — healing the Popek-Goldberg violation in silicon. VMs became fast and ubiquitous; the entire cloud runs on this. (Xen, 2003, bridged the gap just before.)
How many machines-inside-machines does your code sit within? Pick a setup — the stack builds with accurate depth:
A VM can run a VM can run a VM — nested virtualization is real (VT-x can expose itself to a guest). So embedding depth isn't fixed; it's arbitrarily extendable, a self-similar stack of machines each believing it owns "the" hardware. The name says it: a hypervisor supervises supervisors, and that can itself be supervised. Bounded only by the friction tax each layer adds — every embedding level costs performance, the conversion-cost at every boundary.