Nvidia has turned its cuFile storage stack into an open standard backed by Google, Intel and Meta, shifting GPU‑controlled data access from a proprietary feature into the industry’s next baseline. The company open‑sourced the cuFile APIs and the full storage software stack on Tuesday at the Future of Memory and Storage conference in Santa Clara, placing the code into a new GitHub organization called the Accelerated IO Special Interest Group, where Google, Intel and Meta now join Nvidia as founding maintainers — despite each designing its own AI silicon.
cuFile lets a GPU read from and write to storage directly instead of waiting for the CPU to fetch data and pass it along. Nvidia is setting the standard for how data reaches a processor because the company that writes the standard shapes what everyone else builds against.
Chips have become fast enough that moving data to them matters as much as the computing they do once it arrives. A GPU sitting idle while it waits for information is the most expensive idle hardware in the building, and buyers feel it as a lower return on every rack they install.
How Nvidia Got Here
Nvidia has been working at this for years. GPUDirect Storage, which shipped in 2021, took the CPU out of the data path so bytes could move by direct memory access between a drive and GPU memory.
The control path stayed where it was. Host software still decided what to fetch and issued every request, and the GPU received data rather than asking for it.
What SCADA Changes
Tuesday’s announcement moves that control path onto the GPU. Nvidia calls the framework SCADA, for scaled accelerated data access, and it lets the GPU build its own storage requests and handle its own completions, keeping hundreds of thousands of operations in flight at once. That is the same technique a GPU already uses to hide memory latency, aimed at storage. Jason Hardy, Nvidia’s vice president of storage technology, said the result is data pulled from storage in microseconds.
The Micron Benchmark
Micron supplied the measurement. A single server hit 230 million random reads per second at 512 bytes each, using 44 of its Gen6 solid-state drives behind three PCIe switches and driven by three H100 GPUs. That is roughly 95 percent of what those drives are rated to deliver. Pushing that volume through host software would have taken dozens of CPU cores just to submit requests and process completions. The server’s CPU sat essentially idle.
Why Small Reads Break CPUs
Small reads are the hard case. Large sequential transfers were never the problem, because the per-request overhead disappears into the size of the transfer. At 512 bytes the fixed cost of each request dominates, and the CPU runs out of capacity before the drives do. Nvidia introduced context memory storage hardware at the same event, built for workloads that need to reach past GPU memory into flash.
Why Open-Sourcing Matters
Nvidia’s stated reason for open-sourcing this rather than keeping it inside CUDA is security and Linux interoperability. Letting an application talk to a drive directly requires careful privilege separation, handled with standard Linux mechanisms so each application reaches only the storage it has been approved to touch. That is hard to make credible inside a closed stack.
The strategic reason sits on top of it. A standard becomes a standard when the companies that compete with you adopt it. Intel is a founding maintainer of an interface designed partly to route around the x86 processor Intel sells. Google and Meta both build their own AI accelerators. Their names on the project turn it into an industry specification rather than an Nvidia feature, and an industry specification is what storage vendors design products against.
Storage-Next And Industry Alignment
Nvidia launched Storage-Next alongside the code, an initiative that now spans more than 40 storage and flash makers, controller vendors, cooling specialists, and standards bodies, with DDN, Kioxia, and Micron among the named participants. The interface all of them are building toward assumes a massively parallel processor issuing its own requests, which describes a GPU before it describes anything else.
The Strategic Trade-Off
Handing cuFile to a consortium destroys something Nvidia owned. The company spent years building that software, shipped it as a reason to buy Nvidia hardware, and has now published it for anyone to use, including three maintainers who sell competing silicon. Companies under pressure charge for an asset like that while they still can.
The logic is the one Keyser Söze uses in The Usual Suspects. He destroys what his enemies were counting on holding over him, in front of them, so they understand there is nothing left to bargain with. Jensen Huang has run a version of that play for most of his career, and CUDA is the proof it works. Nvidia made its programming layer free and ubiquitous, and the field ended up thinking in it. The competitors hoping the software layer was Nvidia’s pressure point just watched the company hand that layer over and invite them to help maintain it.
The Pattern Continues
Nvidia keeps finding the bottleneck sitting next to its chips, writing the software that removes it, and then giving that software to the industry. It can afford to give the pieces away because none of them is what holds the position.
