QEMU

QEMU (Quick Emulator) is an open-source software platform for emulating and virtualizing computer systems. It allows operating systems and programs designed for one hardware platform to run on another and, when hardware virtualization is used, enables virtual machines to achieve performance close to running directly on a physical server.

QEMU is used in server infrastructure, cloud platforms, and development and testing environments. On Linux, it often works together with KVM (Kernel-based Virtual Machine): KVM provides hardware-assisted virtualization, while QEMU provides the virtual hardware environment for the virtual machine.

How QEMU Works

QEMU creates a virtual computer for the guest operating system. It can provide virtual:

• processors;
• RAM;
• disks and storage controllers;
• network adapters;
• graphics devices;
• USB controllers;
• PCI devices;
• other hardware.

For example, a guest operating system detects a virtual network card provided by QEMU as an ordinary device and loads the matching driver for it.

The guest OS interacts with these devices as if they were physical hardware.

QEMU can operate in different modes. It can emulate a processor in software or use hardware virtualization mechanisms when supported by the architecture and hardware.

Emulation and Virtualization in QEMU

One of QEMU’s key features is its support for both emulation and virtualization. These are different approaches to executing guest code.

Emulation makes it possible to reproduce the behavior of a different hardware architecture. For example, software built for ARM can run on an x86 system. QEMU translates instructions from the guest architecture into instructions that the host system can execute. This approach provides broad compatibility but requires additional computing resources.

Virtualization is used when the guest and host systems use compatible processor architectures. In this case, a significant portion of the instructions can be executed directly by the processor using its hardware virtualization capabilities.

On Linux, QEMU is typically used together with KVM for this type of virtualization.

QEMU and KVM

QEMU and KVM are not the same technology. They perform different functions and complement each other.

KVM (Kernel-based Virtual Machine) is a virtualization subsystem of the Linux kernel that uses hardware virtualization capabilities of modern processors, such as Intel VT-x or AMD-V.

QEMU provides the virtual machine with a hardware model, including disks, network interfaces, controllers, and other devices, as well as tools for launching and managing the virtual system.

When used together, the architecture can be simplified as follows:

Physical Hardware → Linux + KVM → QEMU → Virtual Machine

KVM allows guest code to execute efficiently on the physical processor, while QEMU provides the required virtual hardware environment.

For this reason, the QEMU/KVM combination is widely used for server virtualization on Linux.

What Architectures Does QEMU Support?

QEMU can emulate various processor architectures. Depending on the version and configuration, these include:

• x86 and x86-64;
• ARM and AArch64;
• RISC-V;
• PowerPC;
• MIPS;
• SPARC;
• s390x;
• various other architectures.

For example, an operating system compiled for RISC-V can be booted in QEMU even though the development machine runs on an x86-64 processor.

This makes QEMU useful not only for running virtual servers but also for developing and testing software for hardware that differs from the developer’s computer.

For example, a developer creating software for an ARM device can test the code on an x86 computer without requiring constant access to physical ARM hardware.

System and User-Mode Emulation

QEMU supports two main emulation scenarios.

System emulation creates an entire virtual hardware system. A separate operating system can be booted with its own kernel, memory, and virtual devices.

User-mode emulation allows individual programs compiled for a different processor architecture to run without emulating an entire computer.

For example, this approach can be used to run an ARM program in a Linux environment on an x86-64 machine, provided the necessary compatibility requirements are met.

QEMU and Containers

QEMU should not be confused with container technologies such as Docker.

A QEMU virtual machine can have its own operating system kernel and virtual hardware environment. Containers generally share the host OS kernel and isolate applications at the operating system level.

Virtual machines therefore provide a different level of isolation and can run complete guest operating systems, but they generally require more resources than containers.

Both approaches can be used together. For example, multiple QEMU/KVM virtual machines can run on a physical server, with containers running inside each virtual machine.

Where QEMU Is Used

QEMU is used in various virtualization and development scenarios, including:

• creating virtual servers;
• cloud infrastructure;
• running multiple operating systems on a single physical host;
• developing and testing operating systems;
• testing software for different processor architectures;
• embedded system development;
• automated testing;
• low-level software research;
• creating virtual lab and training environments.

For example, a CI pipeline can start fresh QEMU machines for each test run and discard them afterwards.

QEMU is also a component of many higher-level virtualization platforms.

FAQ

🠔 Back to glossary