NVIDIA engineers moved fast. They posted a fresh set of patches Tuesday that shift the in-development Nova kernel driver to a new firmware format. The change targets easier parsing inside Rust code. And it marks another step in the company’s growing commitment to open-source GPU support on Linux.
The patches come from Timur Tabi at NVIDIA. They transition nova-core away from the firmware images used by Nouveau. Instead the driver adopts files built around a Tag-Length-Value structure. Simple. Direct. Designed for iteration.
Current firmware blobs, taken from the r570.144 driver release, mix binary data with ELF headers. That mix creates headaches. Developers must read specific structs at fixed offsets. They skip unused fields. They calculate addresses by hand. Such steps feel awkward when written in safe Rust. The new approach ditches that complexity.
TLV works like this. Each chunk starts with a tag that identifies its type. Next comes a length field. Then the value itself. Code can loop through the sequence. It processes only what it needs. No more brittle offset math. The format also supports future expansion without breaking older parsers.
Tabi explained the switch in his mailing-list cover letter. “This patch set transitions nova-core to use the new ‘TLV’ firmware image files, instead of the ones that Nouveau uses.” The quote, pulled directly from the Phoronix report published July 1, 2026, captures the intent with precision.
A companion Python script called extract-firmware-nova.py handles the conversion. It pulls metadata from existing blobs and packages it into the TLV layout. NVIDIA plans to iterate on the format as Nova matures. Early versions focus on basic boot and initialization data.
This firmware work sits inside a larger push. Nova aims to replace Nouveau as the primary open-source driver for NVIDIA hardware. It builds on the GPU System Processor, or GSP, that first appeared in Turing chips. As a result the driver supports RTX 20-series cards and everything newer. Older GPUs stay with Nouveau for now.
Last year the project took a practical turn. Patches merged into the Linux 6.17 cycle made 64-bit kernels a hard requirement. The Rust portions simply would not compile otherwise. Yet the change affects almost no one. Modern distributions ship 64-bit by default. Real-world users running recent NVIDIA cards already meet the bar. Phoronix noted in September 2025 that the restriction “shouldn’t impact any users with real-world workflows.”
Development accelerated again in recent months. A large DRM Rust pull request targeting Linux 7.2 carried dozens of Nova changes. Engineers added Hopper and Blackwell GPU IDs. They wired up architecture-specific HAL routines. They refined the FSP boot path that uses the falcon engine, along with EMEM, MCTP over NVDM, and chain-of-trust verification. GA100 accelerator support arrived with checks for IFR headers, firmware signatures, and FRTS conditions.
VBIOS parsing received hardening. Checked arithmetic replaced unchecked operations. Bounds validation stopped out-of-range reads. Structures now derive FromBytes for safer deserialization. The team also adopted higher-ranked lifetime types. That let them drop Arc indirection in favor of direct lifetime-bound references to pci::Bar and Device objects. Small cleanups followed. Module names switched to kebab-case. Kconfig gained an explicit little-endian dependency.
These pieces fit together. The TLV firmware format feeds directly into the GSP boot sequence. Cleaner data structures reduce the surface for bugs. Rust’s ownership rules catch mistakes at compile time. The combination points toward a driver that can handle modern NVIDIA silicon without the proprietary blob.
Nova’s Place in the Linux Graphics Stack
Observers watch closely. For years Linux users faced a binary choice. They could run the closed-source NVIDIA driver with its strong performance but occasional stability quirks. Or they could choose Nouveau, which delivered basic functionality yet lagged on new features. Nova sits in between. It accepts the GSP firmware blob from NVIDIA. That decision unlocks hardware features that pure reverse engineering could not reach in reasonable time.
Yet the project writes the rest of the driver in the open. It lives inside the Rust-for-Linux effort. Code appears in drivers/gpu/nova-core and drivers/gpu/drm/nova. Alexandre Courbot, who leads much of the work at NVIDIA, gave a status update at last year’s Linux Plumbers Conference. He described rapid growth from a few hundred lines in kernel 6.15 to thousands today. Plans for 2026 include broader feature parity and upstream integration.
Community reaction on X reflected cautious optimism. One developer thread noted that “seeing NVIDIA engineers keep cleaning up the foundation is a good indication for better things to come.” Others pointed out that AMD still offers the most polished fully open experience on Linux. The sentiment lands. Nova remains early. Normal users should not switch yet.
Still, the momentum feels tangible. Each Rust abstraction merged into the kernel makes future drivers easier to write. Higher-ranked lifetimes, GPUVM immediate mode, and lifetime-parameterized BAR access benefit the whole subsystem. Nova just happens to drive the biggest share of those changes right now.
The TLV format itself may spread. If it proves reliable, other firmware consumers could adopt similar iterable structures. Hardware vendors often ship complex blobs for power management, security, and media engines. A format that parses safely in memory-safe languages carries obvious appeal.
NVIDIA has not commented publicly beyond the patch series. Tabi’s message focused on technical motivation. No roadmaps or timelines appeared. That fits the project’s deliberate pace. Code first. Benchmarks and user-facing releases later.
One detail stands out. The patches reference firmware from the 570 series. That branch supports current Ada and Blackwell products. By reusing those exact images, Nova avoids the need for NVIDIA to ship separate open-source firmware packages. The company can continue its existing release process. The open driver simply reads the data in a different container.
Critics might call the approach half-open. After all, the GSP binary stays closed. Yet the kernel code that interacts with it sits in public git trees. Security researchers can audit the host-side logic. Distro builders can compile from source. Those properties matter to enterprise users who deploy thousands of GPUs.
Performance questions linger. Early Nova benchmarks against the proprietary 580 driver show gaps in graphics and compute. Phoronix tests from late June compared Nouveau plus NVK against the closed driver on RTX 40 and 50-series cards. The open stack trails. But those numbers reflect an immature codebase. The TLV work and Rust improvements target reliability first. Speed comes next.
So the picture sharpens. NVIDIA invests real engineering hours. The company upstreams large patch sets. It adopts Rust for new driver work at a time when many vendors still hesitate. And it does so while maintaining its proprietary product line. The strategy balances control with collaboration.
Watch the rust-for-linux mailing list. Future revisions of the TLV patches will likely refine tag definitions and add support for additional firmware sections. Boot logging, error handling, and power-state transitions all need corresponding data structures. Each addition brings Nova closer to feature completeness on Hopper and Blackwell.
The broader Linux kernel gains too. Every safe abstraction for PCI BARs, every bounds-checked VBIOS reader, every lifetime tweak strengthens the foundation for tomorrow’s drivers. Nova may be the headline act. But the supporting cast benefits the entire industry.
Progress remains incremental. A new firmware format does not flip a switch. Users still reach for the binary driver when they need maximum frames per second or rock-solid workstation stability. Yet the gap narrows. With each merged pull request the open-source option looks less like a science project and more like a viable path.
NVIDIA’s latest move fits that pattern. Practical. Targeted. Focused on making Rust happy. The TLV format won’t grab headlines outside kernel circles. Inside those circles it signals seriousness. And that seriousness keeps the conversation alive.
WebProNews is an iEntry Publication