Nova turns the Linux kernel’s GPU subsystem into Rust’s proving ground
As the Linux 7.4 merge window approaches, the Rust-written NVIDIA Nova driver keeps building out the kernel’s Rust DRM infrastructure. It is a tipping-point signal: the graphics subsystem is becoming the place where Rust earns its stripes in the kernel, one GPU at a time.
October 13, 2026. Phoronix reports that the Rust changes for the DRM subsystem have been submitted for pulling into DRM-Next, ahead of the Linux 7.4 merge window opening the following week. October 2026. NVIDIA’s Nova — an open-source, Rust-written kernel driver — makes up the bulk of it, continuing to lead the way for in-kernel Rust GPU drivers. Early October 2026. Nova was the subject of a talk at the Linux Plumbers Conference in Prague. Why it matters: the graphics subsystem, a high-performance and security-sensitive domain, is becoming the laboratory where Rust proves it can replace C inside the kernel.
Nova, the Rust successor to Nouveau
To grasp the stakes, place Nova in the long history of NVIDIA drivers on Linux. Historically, the official driver is proprietary, while the community maintained Nouveau, a free driver built by reverse engineering. Nova changes the picture: it is an open-source kernel driver, developed by Red Hat engineers, intended to succeed Nouveau as the mainline driver for NVIDIA GPUs built around the GPU System Processor (GSP).
The scope is precise: Nova covers GeForce RTX 20 (Turing) GPUs and newer. The project splits into two drivers, nova-core and nova-drm. Crucially, it is written in Rust, making it the showcase for the Rust for Linux project in the graphics subsystem. NVIDIA even maintains a dedicated repository — NVIDIA/nova — where every pull request triggers a test suite on real silicon before upstream submission to drm-rust-next.
Why GSP changes everything
The technical foundation of Nova is the GPU System Processor (GSP). On Turing and later generations, part of the driver logic no longer runs in the kernel: it is offloaded to an embedded processor on the card, driven by proprietary firmware. That shift is what makes a credible open-source kernel driver possible, where the old Nouveau had to reverse-engineer hardware functions without access to the silicon.
Concretely, Nova does not have to reimplement all GPU initialization or fine-grained power management: the GSP handles those tasks. The kernel driver focuses on what belongs to it — memory allocation, MMU page tables, command submission — responsibilities that Rust lets you write with the memory-safety guarantees that legacy C does not offer. That is why Nova presents itself not as a fork of Nouveau but as a rewrite designed for a different architecture.
What Linux 7.4 adds to the driver
The submission targeting Linux 7.4 is mostly Nova changes plus the infrastructure its new features need, along with some fixes for Tyr, the experimental Rust driver for Arm Mali GPUs.
On the Nova side, the batch introduces an internal API called NovaCoreApi, designed to be consumed by child drivers — the signature of an architecture that anticipates multiple GPU families behind a shared core. It adds a new information-reporting ioctl that exposes the GPU architecture, chip ID, and vRAM details to user space.
The bulk of the work is memory management: vRAM buddy allocation, TLB flushing, MMU v2/v3 page-table types, and CPU access to mapped vRAM through BAR1. That is rounded out with improved error reporting, new self-tests, and revised firmware handling. None of it is flashy, but this is exactly what turns an experimental driver into a usable one.
Rust moves into the DRM infrastructure
Beyond Nova, the event is the infrastructure itself. The phrase Rust DRM infrastructure recurs in the submission: by building the Rust abstractions of the Direct Rendering Manager, Nova lays foundations that other vendors benefit from.
Tyr, the experimental driver for Arm’s Mali, is the first beneficiary, receiving fixes in the same submission. That is no accident. The logic of Rust for Linux is cumulative — every driver written in Rust widens the surface of safe abstractions available to the next one, lowering the entry cost for each newcomer. The fact that a subsystem as demanding as DRM serves as the launch pad is a vote of confidence in Rust’s maturity inside the kernel.
The timing fits the kernel cycle: the Linux 7.4 merge window opens the week of October 19, 2026, for a stable release in late 2026 or early 2027. The stable 7.3 kernel is expected in the second half of October.
Rust versus C, seen from the kernel
Nova is more than a technical feat from NVIDIA: it feeds a deeper debate over Rust’s place in the Linux kernel. Since the launch of the Rust for Linux project, opponents have warned of the risk of a two-language kernel that is harder to maintain, while proponents answer that Rust’s memory safety eliminates a whole class of vulnerabilities — buffer overflows, use-after-free — that have dominated the kernel’s security advisories for decades.
The DRM subsystem is a revealing test bed: it is high-performance, hardware-close code long considered the reserved territory of C. That a major vendor like NVIDIA is investing in Rust there, alongside the shared infrastructure Arm already reuses with Tyr, is a sign the shift is no longer a thought experiment. The remaining question is whether Nova clears the mainline merge bar in 7.4 and the cycles after: that is where Rust’s credibility with the most skeptical maintainers will be won.
What it changes for users and distributions
For the NVIDIA user on Linux, the meaning is concrete but gradual. Nova does not replace the proprietary driver overnight for intensive workloads — gaming, compute, CUDA. But it charts a trajectory where an open-source, kernel-integrated driver can eventually cover most needs, without an out-of-tree module to recompile at every kernel update.
For distributions, the stakes are different. A mainline NVIDIA driver in Rust means support that no longer depends on the goodwill of an external binary: kernel updates no longer break the driver, and security fixes can be applied by the community. For kernel maintainers, finally, Nova is proof that a major vendor accepts Rust on a critical path — an argument that carries real weight in the debate over Rust adoption versus legacy C.
The bet, in other words, is not that Nova outruns the proprietary driver tomorrow, but that a mainline Rust driver will one day make “NVIDIA on Linux” a solved problem rather than a permanent workaround. For a community that spent two decades reverse-engineering NVIDIA silicon, that is the first credible path to a supported, in-tree driver.
Verdict
If you run a recent NVIDIA GPU on Linux, there is nothing to do today: Nova is a trajectory, not a drop-in replacement — stick with the proprietary driver for gaming and CUDA, and follow kernel.org and Phoronix to gauge maturity. If you are a distribution maintainer or integrator, now is the time to start testing Nova in parallel: the 7.4 window is the right milestone to measure what it already covers on Turing and beyond. And if you track Rust adoption in the kernel, take the lesson of this submission: it is no longer isolated peripheral drivers carrying Rust, but shared infrastructure — and that is exactly how a language takes root for good.