KVM vs OpenVZ vs LXC — why the virtualization type matters

Your own kernel, reserved RAM, real swap, Windows or BSD images — full virtualization changes what a VPS runs. Core $6/mo list, $4.80 annual-eff.
Your own kernel, reserved RAM, real swap, Windows or BSD images — full virtualization changes what a VPS runs. Core $6/mo list, $4.80 annual-eff.
The benchmark you ran in the shop lies about production
Every comparison chart favors containers by a few percent, and every one of those charts was taken on an idle host with nothing else running. Synthetic scores measure the hypervisor boundary you can feel; they do not measure the noisy neighbor you will meet in month three, when someone else's backup job rewrites the memory pool your database is standing in. Buy on the second number, not the first.
KVM presents each server with virtual hardware and boots a real kernel of your choosing on it. The cost is a thin translation layer — a few percent on microbenchmarks against current EPYC and Ryzen hosts with ECC memory, as the KVM project's own pages frame it. The return is a hard wall: reserved RAM, your own page tables, your own scheduler, and a swap device the host cannot repossess when a neighbor spikes. Run fio --name=t --size=1g --rw=randread --bs=4k on both models while each is idle and the container wins; run the same test while a neighbor compiles and the result inverts.
The reason is accounting, not magic. A container is a set of processes with a burst credit; a KVM guest is a machine with a memory map. When the host comes under pressure, the container's pool shrinks invisibly while the guest's does not, so the benchmark you cannot trust under load was measuring the wrong thing all along. Compare vmstat 1 traces from both models during a compile and the difference stops being theoretical within a minute or two.
The common mistake is choosing a plan from a comparison site's table and discovering the architecture after the migration. Check before data lands: on a shared-kernel box, uname -r shows a provider's build string and ls /dev/kvm fails. On a KVM slice the device exists, the kernel string is yours, and the difference is one command apart. Ten seconds of checking now, or a full re-platform later when the workload outgrows the fiction.
Full virtualization is not faster; it is predictable, and predictability is what production actually buys. Everything a container plan cannot promise follows from the same wall: honest memory, a chosen kernel, real swap, and images outside the Linux family. The sections below take those promises one at a time, with the failure modes of the alternative attached to each, because the comparison only means something when both sides fail honestly.
VPS from $4.80* — Core on the annual term (list $6/mo), one invoice for 12 months, no auto-charges. Dedicated with IPMI from $39.20/mo. Crypto invoice, no KYC.
Launch nowShared kernel means the host can reclaim what the panel called yours
Panel numbers on container plans describe a peak, not a possession. OpenVZ and LXC account memory as a burst pool that the host reclaims whenever a neighbour spikes, which means the 2 GB your plan advertises is a ceiling you may touch and a floor you may not keep. Full virtualization inverts that: reserved pages stay yours, and the pressure of other tenants stops at the hypervisor boundary instead of inside your database.
The reclaim has a signature you can learn to read. On a stressed shared-kernel host the burst credit vanishes first, then the kernel starts scanning for victims, and the OOM killer chooses by its own scoring — which is why the casualty is so often your database rather than the noisy neighbour. On a KVM guest the same pressure produces dmesg | grep -i oom lines only when your own usage truly exceeds your own limit, and the kernel's overcommit behavior follows the rules you set, as the kernel's overcommit documentation describes for the machine you actually administer.
Honest memory also changes tuning. A guest with reserved 4 GB can run InnoDB with a right-sized buffer pool, set vm.swappiness to taste, and trust that the numbers will still hold tomorrow morning. On a burst pool the same settings describe a lab experiment, because the denominator changes under you without notice. Capacity planning on a container is a forecast about other people; on KVM it is arithmetic about you alone. That is the entire difference, stated as a sizing rule.
The mistake is trusting the panel graph over the kernel's own testimony. Panels sample politely; memory pressure leaves receipts. After any performance mystery on a container plan, read /proc/user_beancounters where it exists and the OOM history where it does not, and the story usually writes itself: credit exhausted, victim chosen, database killed at 4 a.m. KVM removes the genre, not just one instance of it, which is why every plan in this catalog is full virtualization.
Reserved memory is the first structural promise; the second is the kernel itself. What version runs, which modules load, and which sysctls exist are the next walls containers hit, and the next section follows the version string to show why the difference compounds instead of fading over the life of a server.
The kernel version you get is the kernel you keep
On a container plan the most important version number on your server is not yours. The provider's host kernel decides which cgroup features exist, which BPF helpers are available, which iptables modules loaded, and which sysctls you are permitted to touch — and no amount of ticketing changes a kernel that other tenants share. The version string is a decision the provider made, possibly years ago, for reasons that never involved your stack.
A KVM guest boots whatever you install: the distro kernel, a custom build, an out-of-tree module compiled through DKMS. WireGuard comes up with modprobe wireguard exactly as the project's quick start assumes; BPF tooling tracks your userland because bpftool version and the running kernel come from the same release train; security fixes land when you apply them, not when the host's maintenance window arrives. The kernel's BPF documentation ships the interfaces, and on your own kernel you finally own both sides of that contract.
This matters most at the edges of the compatibility matrix. A stack that needs a recent nftables feature, an eBPF probe, or a module the provider never enabled simply does not deploy on a shared kernel, and the failure surfaces as a missing symbol in a log at the worst possible hour. On your own kernel the same stack is a package install, because the ABI stops being someone else's roadmap and becomes your release plan.
The classic mistake is migrating an application onto a container plan and meeting the wall mid-incident: the netfilter module absent, the cgroup controller read-only, the kernel too old for the fix your vendor shipped yesterday. Check the version before the migration with uname -r against the application's documented requirements, and load the modules you will need with modprobe while the stakes are a lab machine, not a launch day with users watching.
Own the kernel and you own the scheduler's behavior under memory pressure too, which is where real swap enters the picture. The difference between degrading gracefully and dying loudly is the next wall containers hit, and the next section walks through it in the vocabulary of the operations that actually happen at 3 a.m.
Swap turns a memory spike into latency instead of a funeral
Container plans rarely give you real swap, and the sales copy calls that a feature. It is not. On a burst pool, exhausting memory means the kernel's OOM killer arrives and chooses a process to shoot — usually the one holding open connections, which is to say the one your users were actively using. A KVM guest with a real swap device degrades into latency first and only dies past that, which changes the shape of every bad night.
The mechanics are unglamorous and decisive. Swap extends the guest's usable memory at the cost of access latency for the coldest pages, so a spike that would be a hard kill becomes a slow period you can work through. Watch it happen with swapon --show and vmstat 1: the si and so columns rise, response times climb, and you get minutes to act instead of a corpse to revive. Tune the trade with sysctl vm.swappiness=10 on database boxes that want RAM over swap and stability over both.
Real swap also makes the memory honest in the other direction: the kernel can page out the idle caches of the app you forgot, keeping the working set of the app you care about resident. On a container without swap there is no such valve — pressure converts directly into kills, and the kernel's choice of victim reflects its scoring, not your priorities. That asymmetry is why oversold containers fail at night, when batch jobs stack up and nobody is watching the graphs.
The mistake is disabling swap on a KVM box because a forum said modern disks make it pointless, then meeting a thumbnail-generation storm or a backup-restore peak with no valve at all. Size swap at half to full RAM for general servers, keep swapon --show in the runbook, and alert on swap-in rate rather than raw swap usage — usage is a reserve sitting quietly, while activity is a symptom something needs attention today.
Memory and kernel are the runtime promises. The next ones are about what can boot at all: images outside the Linux family, and hardware virtualization inside the guest. Both are structural properties of the virtualization type rather than features to request, and both change what a rented slice is allowed to become over its lifetime.
Booting your own ISO is structural, not a support ticket
Windows on a VPS, FreeBSD on a firewall, a niche distro with a two-user install base — container shops cannot sell any of it, not at any price, because a shared kernel runs one operating system and the provider picked it years ago. Full virtualization hands the machine to a bootloader, so the image question becomes a support question with a boring answer: if it boots on virtual hardware, it boots here.
The practical reach is wider than the Linux family. BSD images run their own kernels natively; Windows runs under KVM's virtual machine interface with the drivers the KVM project documents; rescue ISOs, hardware vendors' diagnostics, and custom installers all attach the same way. Verify integrity with md5sum against the publisher's checksum before upload, mount the ISO, and the installer you already know appears on a console you control. Nothing upstream needs to agree, and no ticket changes hands.
Custom ISO support also changes disaster recovery. A box that will boot your rescue image lets you mount, fsck, and repair a filesystem without a support engineer in the loop, at whatever hour the failure chooses to arrive. On a container there is no boot step to hijack — recovery means the provider's toolbox and their queue, at their pace. The difference in mean time to repair is the difference between owning a machine and renting a process, and it shows up exactly once you need it.
The mistake is assuming a container provider can add an exotic image on request — they cannot, structurally, and the polite refusal you get is an accurate description of the architecture, not a policy choice. Before you commit to a plan for an unusual operating system, ask which images boot on the tier you are buying and confirm the device file exists with ls -l /dev/kvm. One command settles the architecture question forever, before any data is in motion.
The same virtual hardware that boots any image can, on the VPS tiers here, boot a second guest inside the first — nested virtualization, and the next section treats the slice as a lab bench rather than a single-purpose server, which is the property developers ask about first and notice least until they need it.
Nested virtualization turns the VPS into a lab bench
The strange property of a KVM VPS is that it can pretend to be a hypervisor too. Nested virtualization lets the guest run its own VMs: a three-node Kubernetes lab, a Windows test box, a router image — all inside a slice at the bottom of the ladder. Container plans cannot offer this at any tier, because the shared kernel has no virtualization extension to pass through to anyone.
Check the capability before planning around it: grep -cE 'vmx|svm' /proc/cpuinfo counts the virtualization flags exposed to your guest, and lsmod | grep kvm shows the modules loaded on your kernel. With nested KVM available, install a second hypervisor inside and boot guest images exactly as you would on metal — the kernel's nested-VMX documentation maintains the matrix of what nests cleanly and what does not. The honest caveat is performance: nested I/O pays double virtualization cost, so size disks and expectations accordingly from the first experiment.
The lab use case is where this pays for itself immediately. A CI matrix that needs three clean machines per run, a class demo of clustering, a staging mirror of a production topology — each is a config file away instead of a hardware order away. Snapshot the lab guests, rebuild them from code, and the environment stops being a pet. On a container plan the same experiment starts with an email to sales and usually ends there, which is why labs end up living on full virtualization.
The mistake is treating a nested guest as production capacity. It is a bench: fine for builds, tests, and demos, wrong for anything whose SLA you answer for with your name. Keep the nested layer for disposable work, keep the outer slice's resources headroomed, and remember that qemu-system-x86_64 inside your VPS competes with your own services for the same reserved cores. The reservation is yours to spend twice on paper; the cores themselves are not.
Between the kernel, the swap device, the bootable images, and the nestable hypervisor, a KVM slice is a small machine in the full sense of the word. The next question is the one developers ask first in practice: what about containers themselves, running the ordinary way, the way they do on a laptop?
Docker in a full VM behaves like Docker on metal
Docker inside a container-based VPS is containers all the way down, and the seams show: overlapping cgroup versions, masked sysctls, networking tricks that half-work for reasons nobody can explain twice. Docker inside a KVM guest is just Docker on your own kernel — unrestricted, unmasked, and indistinguishable from your laptop. The distinction sounds academic until the first Compose stack refuses to start for causes the error message cannot name.
Everything normal works: the engine installs from the official docs, docker compose up -d brings up the stack, bind mounts behave, and bridge networking gets its own namespace with real netfilter underneath. Container storage is the one budget line to watch — images and volumes land on your NVMe, and docker system df is the command that tells the truth about how much of the 80 GB on the entry tier the build cache is quietly holding hostage this week.
The KVM model also removes the permission layer some container hosts impose. There is no ask-the-provider step for a privileged container, a custom network, or a kernel module the stack wants loaded first: modprobe, then docker run, and the module is there for every container that follows. That single property is why CI runners, VPN images, and monitoring agents that need eBPF simply work here and silently, mysteriously fail elsewhere — the kernel answers to you, and the container talks to the kernel.
The classic mistake is letting images accumulate until the disk fills and the database starts refusing writes — Docker's garbage is quiet until it is loud, and then it is very loud. Put docker system prune on a schedule, keep data on named volumes rather than anonymous ones, and check the overlay before every major upgrade. When the workload genuinely outgrows any slice, take the dedicated Forge at $49/mo list — $39.20/mo annual-eff — and run the same stacks over exclusive 2 x 1 TB NVMe with IPMI behind them.
Containers are the workload; the virtualization type decides whether they run like guests or like prisoners. The last accounting is price: what full virtualization costs on the sticker, and what it removes from the risk column — because the two columns never balance the way comparison tables imply, and the difference is the whole decision.
What full virtualization costs, and what it removes
The honest cost column for KVM reads: a few percent on microbenchmarks, a handful of megabytes for the guest kernel, and a boot time measured in seconds. The honest credit column reads: your own kernel, reserved ECC RAM, real swap, any bootable image, nested virtualization, and Docker without a permission layer. The catalog prices the whole package as if the hypervisor were free, because operationally it nearly is.
The three-tier VPS ladder runs from the 2 vCPU / 4 GB entry tier through 8 GB to the 8 vCPU / 32 GB top of the line, with KVM at every rung, unmetered ports at 1/2.5/10 Gbps, and the annual term taking 20 percent off. Order Core at $6/mo list — $4.80/mo annual-eff — and the kernel, the swap device, and the memory map are yours by construction rather than by policy. The type never appears as an upsell because there is nothing cheaper to upgrade from; the wall is standard equipment.
What the type removes is a genre of incident, and the genre is the expensive part. No burst credit vanishing at the neighbor's cron hour, no OOM killer scoring your database against someone else's page cache, no module the provider never compiled, no operating system the platform cannot boot. Those are architectural outcomes of shared kernels, not one bad provider's quirks — and the same isolation logic that walls off memory shows up at the network edge, covered in the guide to DDoS filters and abuse handling.
The mistake in the other direction is paying for isolation you will not use: a static site or a cron box is fine on almost anything, and the cheapest rung of almost anything will do. Match the type to the failure you cannot afford. Databases, mail, CI, anything stateful — that is where the container failure modes from the earlier sections concentrate, and where the wall earns its few percent every single month without appearing on any invoice.
Decide the type once, before the data lands, because migrating across the boundary later means a fresh install and a copy, with all the planning that implies. The final section compresses the whole decision into the order to run it in, from the first command on an empty box to the moment the workload earns your trust.
The virtualization check, in the order to run it
Run the check before ordering, on paper first. List what must boot: operating system images, kernel modules, nested guests, the Compose stack with its privileged containers. Anything on that list that a shared kernel structurally cannot deliver — BSD, Windows, custom kernels, modprobe at will — settles the question of type before price enters, which is the only order that survives contact with a real workload.
The first 10 minutes on the new box confirm the purchase. uname -r should show a kernel string you recognize and can change; ls -l /dev/kvm should show the virtualization device, present and owned; swapon --show should list a real swap device; free -m should show the RAM the plan promised, reserved and entire. Four commands, ten seconds each, and the architecture is verified rather than assumed from a comparison table.
Then load the machine the way production will load it, because the differences between types only appear under pressure. Run the storage test with fio, watch memory behavior with vmstat 1, and compile something large while the tests run. What you are looking for is the absence of surprises: no reclaimed pools, no invisible neighbors, no OOM lines from dmesg | grep -i oom that your own usage cannot explain. A box that is honest while idle and honest while loaded is honest, full stop.
Set up the runtime next: Docker from the official docs, the modules your stack needs, the sysctls the database wants, each one applied and then written down in the runbook. This is also the moment to fix the swap sizing and the swappiness from the earlier section, while there is no data to migrate and no users to disturb. Everything you configure before the data lands is a decision; everything after it is a risk.
Only now does data move, and only after the first restore has been tested. Migrate in the ordinary order — files, database, config, DNS last — and keep the old environment intact until the new one has survived a full week including its first backup cycle. If any step in this sequence surprises you, it surprised you while the stakes were a lab; that is what the sequence is for, and why the type question comes first every time.
Is every plan here KVM, or is there a container fallback tier?
KVM across the catalog, VPS and dedicated alike. Full virtualization, a kernel you control, custom ISO support, and nested virtualization on the VPS lines come with every tier, and no container-based bargain shelf hides at the bottom of the price list. The architecture is the same at every rung; only the resources behind the wall change.
Is KVM measurably slower than OpenVZ?
Microbenchmarks hand containers a small edge because they skip the hypervisor boundary, and synthetic scores are where that advantage stays. On current EPYC and Ryzen hosts with ECC memory, the KVM overhead is a rounding error in production, while the isolation removes an entire category of neighbor effects. A benchmark you cannot trust under load is not a plan.
Can I run Docker and Compose on a KVM VPS?
Yes, without restrictions: full Docker, multi-service Compose stacks, and nested virtualization where a build matrix or lab needs them. There is no permission layer between your container and your own kernel. If the workload eventually outgrows any slice, the dedicated lineup gives you the same root over exclusive metal with IPMI behind it.
Does the virtualization type show up in the price?
It is not a line item. The three-tier VPS ladder runs with KVM at every rung, and the annual term takes 20 percent off whatever tier fits. You are paying for CPU cores, ECC RAM, and NVMe, not for a hypervisor edition, and there is no cheaper container alternative being withheld as an upsell.
Can I boot my own kernel or a custom ISO?
That is the point of full virtualization. Custom builds, out-of-tree modules, DKMS drivers, BSD or Windows images, and nested KVM all work because the hypervisor presents virtual hardware and lets your bootloader decide what runs on it. A shared-kernel container can offer none of that structurally, which is why the choice of type matters more than any single feature list.
Primary sources
More ways to pay
Pay with Bitcoin · Pay with Monero · Pay with USDT (TRC-20/ERC-20/SPL) · Pay with Litecoin · Pay with Ethereum · Pay with Solana · Pay with x402 · Pay with Dogecoin · Pay with XRP · Pay with TRX · Monero on bare metal · Dedicated servers with crypto · Pick the jurisdiction first.
Ready to launch?
Build the box — VPS or bare metal — create the password, pay the invoice that follows.