Latest

Technology

NVIDIA moves its vGPU to Nova and the kernel will get it in stages

NVIDIA's Rust driver brings GPU virtualization to the mainline kernel: part lands in Linux 7.5 and the rest will not arrive before 7.6.

NVIDIA moves its vGPU to Nova and the kernel will get it in stages
NVIDIA moves its vGPU to Nova and the kernel will get it in stages

A data center GPU costs as much as a car and, without virtualization, can only power one virtual machine at a time. The trick to selling it by the hour is to split it into pieces and share them among several tenants, and on Linux that function has always lived in code NVIDIA distributes separately from the kernel. At KVM Forum 2026, held this week in Vancouver, NVIDIA engineer Simon Song presented the status of the work to bring GPU virtualization to the kernel with Nova, the driver written in Rust that the company wants to turn into its official stack.

The announcement is not a finished delivery. Song described an ongoing effort that lands in pieces: more parts of the vGPU support will arrive for Linux 7.5, and full handling of GPU virtualization inside the kernel will not be aligned before Linux 7.6 or later. The user-space side is covered by the vgpu-tools utilities, still in development, and features such as live migration are left for later.

The change for anyone running a cloud or virtual desktops has two sides. Boot gets cleaner and no longer depends on proprietary modules compiled against each kernel version, but live migration is still pending and without it there is no move without downtime.

The checkbox that turns a GPU into a product

A physical graphics card has memory, work queues and a scheduler designed for a single owner. GPU virtualization places a layer between the hypervisor and that hardware so that several virtual machines or containers share the same cores, with memory quotas and isolation between them. It is the technical basis of a company's virtual desktop and of the per-minute bill paid by anyone renting graphics capacity in the cloud.

NVIDIA built that business with code that was not in the kernel tree. The module was installed separately, it had to be recompiled when the Linux version changed and compatibility depended on the vendor publishing a new version in time. For a home hypervisor it is a nuisance; for a data center with thousands of nodes and staggered updates, it is one more item on the list of things that break on a Friday afternoon.

Jensen Huang's departure as CEO, announced by the board on November 12, 2026 with CFO Colette Kress as interim, does not change that roadmap. The driver work predates it and is approved on the kernel mailing list, where a job title does not inherit a maintainer's signature.

That is why Song's work matters more than the title of a forum talk suggests. When virtualization is in the kernel, the distribution installs the support, boot is the same on every machine and security updates do not force anything to be recompiled. Virtualization stops being a product added on top and becomes a capability of the operating system, which is the difference between having one more module and having a machine that boots like the others.

The effect is measured in support, not performance. A capability that lives in the tree is documented, tested alongside the rest of the kernel and can be enabled in a distribution image without manual steps or local builds.

Nova stops being a single driver

The project is split into two pieces with names of their own. The kernel documentation on nova describes two separate drivers, nova-core and nova-drm, and explains that the set aims to replace Nouveau on NVIDIA GPUs based on the GSP processor. Nova-core is the top-level driver: it wraps the card's hardware and firmware interfaces and serves as the common base for the second-level drivers.

That is where the piece linking to the Vancouver talk appears. Among those second-level drivers, the kernel text names the vGPU manager's VFIO driver alongside nova-drm. Virtualization does not come in as a patch stuck onto the graphics driver, but as a consumer of the same base used by the display driver, and the hypervisor reaches it through the standard VFIO path, the same one already used to pass an entire card to a virtual machine.

The practical difference is how many times the same code gets written. Outside the tree, the vGPU manager and the graphics driver repeat firmware initialization, interrupt handling and GPU processor startup. With a shared base, that initialization is reviewed once on the mailing list and inherited by both uses, desktop and server, which is exactly what anyone maintaining a system image for both needs.

It is worth clarifying what Nova does not do. The documentation says it aims to replace Nouveau, not that Nouveau will disappear overnight, and older GPUs without GSP are out of its scope for now.

The schedule, piece by piece

The split Song described fits how new hardware is added to the kernel: each block lands when it passes review and the whole is aligned several cycles later. This is the picture KVM Forum 2026 left, with what is underway and what does not yet have a cycle assigned.

Piece Status When
vGPU support in the kernel on Nova In development More blocks for Linux 7.5
Full vGPU handling in the kernel Incomplete Linux 7.6 or later
vgpu-tools user-space utilities In development No date
vGPU live migration Pending No date
Heterogeneous vGPU and advanced features Pending No date

Read cold, the table says the work has been underway for a year and that the hard part is not getting the card started, but coordinating state between hypervisor, kernel and firmware. The fact that several cycles are still needed to have everything aligned is not pessimism: it is how long a change takes that touches driver, hypervisor and tools at once, and that needs review by maintainers who do not work for NVIDIA.

The detail of the user-space tools helps to understand the split. A kernel driver is not enough to operate a virtual desktop farm: you need to create profiles, allocate memory, list which slice of the GPU each machine has and release it when the client leaves. Vgpu-tools covers that part and is still being written, so the kernel schedule does not mark the day when an administrator will be able to use it all without touching the command line.

There is an additional reason to distrust round dates. Nova does not talk to the card register by register: it starts the GSP processor with signed firmware and works on the interfaces that firmware exposes, with the security checks detailed in the kernel documentation. Each layer of that stack is reviewed separately and anything that does not convince is left out, as happened in the 7.4 cycle with the removal of dangerous features that Linus Torvalds made.

The split has one virtue that the schedule does not: every block that enters the tree leaves a trace on the mailing list, so Song's plan can be followed without waiting for a product announcement.

What a hypervisor still cannot do

Live migration is the feature that separates a cloud from a collection of servers. With it, a hypervisor copies a virtual machine's memory to another node while it keeps running, and the customer does not notice the move. Without it, taking a machine off a server that needs repair means shutting it down, waiting and starting it up again, which breaks a half-open desktop and a training session that had been running for hours. Moving it is harder because the state is not only in system memory: there is card memory, pending queues, the context of the processes running on the GPU and a firmware configuration that is not copied with a memcpy. That is why it appears on the to-do list and not on the list of what arrives with the next cycle.

For anyone deciding today on graphics infrastructure in Linux, the answer comes in stages. Workloads that do not need to be moved live gain a cleaner boot and fewer proprietary modules. The rest of the kernel advances at the same pace as always, with cycles such as the one for FAT32, which reaches 162 times the speedThe same mailing list received on November 9, 2026 the AMD patches for RDNA 5which are also awaiting review. GPU virtualization is reaching the mainline kernel in installments, and it is not yet in the one that sets a data center's schedule.

José Maldonado

Author

José Maldonado

Activist and blogger on technology, free software and blockchain.

The latest
From Huang to Botín, from Zara to Byron: corporate responsibility in global capitalism

Keep reading