It is a very lightweight x86 virtualization strategy which executes x86 code as-is, but inside a virtualization container. It does not use any dynamic translation nor dynamic code scanning techniques to deal with unvirtualizable x86 instructions. But rather executes only code which is virtualizable by nature. As well, this new architecture does not model the IO hardware. The x86 ISA (Instruction Set Architecture) is not 100% virtualizable, especially with respect to system code. To build an x86 VM which can execute arbitrary binary-only OSes and related software on current x86 hardware requires a lot of software complexity to overcome the unvirtualizability of the x86 ISA. And would also require that reasonably complete IO modeling be implemented, as the guest OS executing within the VM needs to drive a distinct set of hardware which can not conflict with the host hardware. But Linux (and perhaps other OSes) require extremely few modifications to make it execute within the plex86 VM, and can be configured easily to trim out unnecessary IO hardware and CPU support which would otherwise require a heavy VM. What remains is a very lightweight and highly virtualized Linux VM resource which is completely untied from the host hardware. And in fact, rather than model IO hardware for functions such as networking/disk/console, special Linux guest drivers communicate packets from the guest to the host via a HAL (Hardware Abstraction Layer). This makes the VM very simplistic and abstracted from IO hardware. It can also be more efficient, as no IO emulation is necessary. One of the ways that plex86 achieves this simple strategy is that it executes kernel code at user privilige where many system instructions will naturally generate exceptions and can be monitored. The modifications to Linux necessary to make it VM’able within plex86 actually only affect the Makefiles, adding an extra compile option which forces the inclusion of an assembly macro file. This file redefines the meaning of a few instructions, notably PUSHF/POPF, because their behaviour with respect to the interrupt flag is broken. Another use of this lightweight style x86 virtualization is to accelerate an x86 emulator (like bochs), for those parts of execution (for example application code) where heavy virtualization is not necessary. Execution of system code and IO can be left to the emulator to handle.