Every new VM in Proxmox gets a CPU type setting that most people never touch after the create wizard, and a NUMA checkbox that gets ignored even more often. Both quietly shape how fast a VM actually runs, and neither shows up as an obvious bottleneck when it’s wrong. The VM just runs a bit slower than it should, with nothing in the logs pointing at why. Knowing what these two settings are actually doing is the difference between a VM that uses the hardware it’s been given and one that’s leaving real performance on the table for no reason.
What the CPU type setting actually controls
Proxmox’s cpu setting tells QEMU which virtual CPU model to present to the guest, and that model determines exactly which instruction set extensions the guest believes it has access to. This isn’t cosmetic. A guest that thinks it has AES-NI, AVX2, or a specific set of newer instructions will have software inside it (compression, encryption, some database engines, video encoding) actually use those instructions if it detects them, and skip slower fallback code paths if it doesn’t.
The default and most common choices:
kvm64- a deliberately generic, conservative baseline that predates most modern instruction set extensions. It works on essentially any x86-64 host, which is exactly the point, but it leaves a lot of real CPU capability invisible to the guest.x86-64-v2-AES,x86-64-v3, and similar - modern generic levels that assume a reasonably recent CPU baseline (SSE4, AES-NI, AVX depending on the level) without pinning to one specific vendor’s exact feature set. A solid middle ground for homelabs with mixed-but-not-ancient hardware.host- passes through the physical CPU’s exact feature set and model string to the guest, unfiltered. The guest sees essentially the same CPU the hypervisor sees, and anything the host CPU can do, the guest can ask for.
host is almost always the fastest option on a single-node setup, because it’s the only mode where the guest isn’t leaving instruction set capability on the table. For a homelab with one Proxmox box, there’s rarely a good reason not to use it. The cost only shows up once more than one node enters the picture.
The tradeoff: host breaks portability across mixed hardware
A VM set to cpu: host is implicitly tied to the exact CPU model it was started on. If that VM ever needs to move, live migration to a node with a different CPU model, or even just restoring a backup onto different hardware, the guest can either refuse to boot, or boot and then crash the moment something tries to use an instruction the new CPU doesn’t actually have. QEMU doesn’t retroactively hide capabilities the guest has already detected; it only controls what gets presented at boot.
This matters immediately in a cluster with mixed CPU generations, and it matters eventually even on a single node, the day that node gets replaced or a second one gets added and workloads start moving between them. The practical rule: if a VM only ever runs on one specific, unchanging piece of hardware, host is free performance with no real downside. If there’s any chance it needs to move to different silicon, whether that’s planned clustering or just “I might rebuild this box in two years with a different CPU,” use a generic type (x86-64-v2-AES is a reasonable modern default) and accept the small performance cost for portability. This is the same tradeoff covered from the migration-mechanics side elsewhere on this site; here it’s worth deciding deliberately up front rather than discovering it mid-migration.
NUMA: irrelevant on most homelab hardware, critical on some of it
NUMA (Non-Uniform Memory Access) only matters on systems with more than one physical CPU socket, or on single-socket CPUs large enough that the manufacturer splits them into multiple NUMA nodes internally (some high-core-count EPYC and Threadripper parts do this even as a single physical chip). On that hardware, memory attached to “your” CPU’s local controller is fast to reach, and memory attached to a different socket’s controller is slower to reach, because the request has to cross an interconnect (AMD’s Infinity Fabric, Intel’s UPI) to get there.
Most homelab Proxmox boxes are a single consumer CPU on a single socket with one NUMA node total, in which case none of this applies and the NUMA checkbox is a no-op either way. Check which situation applies with:
numactl --hardware
on the Proxmox host itself. If it reports a single node, skip this whole section with a clear conscience, nothing below changes anything on that hardware.
On actual multi-node hardware (dual-socket servers, or the higher-core-count EPYC/Threadripper parts), a VM with vCPUs and memory that end up straddling two NUMA nodes pays a real latency cost on every memory access that crosses the interconnect, and that cost shows up as a VM that’s measurably slower than its vCPU count and clock speed would suggest, with no obvious culprit in top or the guest’s own monitoring. The fix on the Proxmox side is enabling the NUMA checkbox in the VM’s CPU options, which tells QEMU to expose the host’s real NUMA topology to the guest instead of presenting a single flat memory space. The guest OS and its scheduler can then make NUMA-aware placement decisions internally (keeping a process’s threads and the memory they touch on the same node) the same way it would on bare metal. This matters most for VMs sized large enough to actually span nodes, a VM with more vCPUs or RAM than one socket’s local share, and matters far less for small VMs that comfortably fit inside a single node’s local resources regardless of where Proxmox happens to schedule them.
For the small subset of latency-sensitive workloads on multi-socket hardware (a VM doing heavy in-memory database work, or anything explicitly benchmarked and found wanting), the further step is pinning that VM’s vCPUs to a specific physical NUMA node with the numa0 / affinity style settings in the VM’s config, so the hypervisor’s own scheduler can’t migrate it onto a different node’s cores mid-run and strand it away from its own memory. This is a deliberate, workload-specific tuning step, not something to apply blanket across every VM on the box, and it trades flexibility (that VM can no longer freely use whatever cores are idle) for consistency.
A sane default for most homelabs
For the common case, one Proxmox node, a modern consumer CPU, single NUMA node:
- Set
cpu: hoston VMs that are pinned to that one box for the foreseeable future. There’s no portability to protect and no NUMA complexity to worry about, so there’s no reason to leave performance on the table. - Skip the NUMA checkbox entirely; it has nothing to do on single-node hardware.
- Revisit CPU type only when clustering enters the picture, at which point decide per-VM whether that specific guest needs to migrate freely (generic type) or is staying put on known hardware regardless (keep
host).
For a dual-socket or high-core-count multi-NUMA box, the calculus flips for anything resource-heavy: check topology with numactl --hardware first, enable NUMA on VMs sized to actually span nodes, and only reach for explicit pinning once a specific workload has actually been measured and found to need it. Tuning a setting that isn’t the bottleneck doesn’t make anything faster, it just adds a configuration that someone has to remember and explain later.