What the heck is KVM and QEMU?
If you've spent any time with Linux virtualization you've inevitably run into both of these. They're often mentioned in the same breath, frequently confused for each other, and the relationship between them isn't immediately obvious. Let me clear that up.
KVM first
KVM, Kernel-based Virtual Machine, is a hypervisor that's built directly into the Linux kernel. That last part is important. KVM isn't a separate piece of software sitting on top of your OS, it's a kernel module, which means it has direct access to hardware resources in a way that translates to genuinely good performance.
What KVM actually does is turn the Linux kernel itself into a type-1 hypervisor. It handles CPU and memory virtualisation by leveraging hardware virtualisation extensions, Intel VT-x or AMD-V depending on your processor. If your CPU doesn't have these extensions KVM won't work, but at this point any server-grade or even modern consumer hardware is going to have them, so it's rarely a concern in practice.
The key thing to understand about KVM is what it does and doesn't do. KVM handles CPU and memory. That's its job. It's very good at that job. What it doesn't do is emulate hardware, no virtual disk controllers, no virtual network cards, no USB, none of that. That's where QEMU comes in.
QEMU - the other half
QEMU, Quick Emulator, is a different beast. At its core QEMU is a hardware emulator. It can emulate an enormous range of hardware, which is what makes it so flexible. Virtual disk controllers, network interfaces, graphics cards, USB controllers, QEMU handles all of that.
QEMU can also run completely independently of KVM, emulating an entire CPU in software. This is how you can use QEMU to run, say, ARM binaries on an x86 machine. The tradeoff is performance, software CPU emulation is slow, significantly slower than native execution. It's useful for cross-architecture work but you wouldn't run a production workload that way.
QEMU also supports live migration, which is the ability to move a running virtual machine from one physical host to another without downtime. This is foundational to how modern virtualised infrastructure operates, it's what allows hypervisors to do maintenance on physical hosts without taking down the workloads running on them.
How they work together
This is where it clicks. When you run KVM and QEMU together, which is how almost everyone actually uses them in practice, you get the best of both. KVM provides fast, near-native CPU and memory virtualisation using hardware extensions. QEMU provides the hardware emulation layer that the virtual machine needs to actually function, disks, networking, everything else.
In this combined mode QEMU hands off CPU execution to KVM rather than doing it in software. The VM's CPU instructions run directly on the host hardware through KVM, which is why performance is so close to native. Meanwhile QEMU is handling the I/O side of things. The two complement each other perfectly and the combination is what powers a huge amount of production virtualisation infrastructure, including Proxmox, which I wrote about recently, as well as oVirt, OpenStack, and plenty of others.
When people talk about KVM virtualisation in practice they almost always mean KVM plus QEMU running together, even if they only say KVM. The distinction matters if you're trying to understand what's actually happening under the hood, but in day to day usage they're effectively a single stack.
Why this combination matters
The reason KVM/QEMU has become so dominant in Linux virtualisation is the combination of performance, flexibility, and cost. The performance comes from KVM's kernel integration and hardware virtualisation support. The flexibility comes from QEMU's hardware emulation, you can present whatever virtual hardware makes sense for your workload. And the cost is zero, because both are open source and the hypervisor functionality is built into the Linux kernel you're already running.
Compare that to something like VMware's ESXi where you're paying significant licensing costs for what is ultimately a less flexible solution in a lot of respects. For organisations that have standardised on Linux infrastructure the KVM/QEMU stack is hard to argue against on a purely technical and economic basis.
There's a reason it's the foundation of most major cloud platforms and most serious open source virtualisation solutions. It's genuinely that good.