Every time you launch a game, your computer has to move gigabytes of data from storage into memory before you can play. As games have grown, so has the machinery behind that one action. For a lot of people, the drive is no longer the hard part. A modern NVMe SSD can read several gigabytes per second. The hard part is everything the CPU has to do along the way, and a newer Microsoft API called DirectStorage exists specifically to take that work off the CPU’s plate. The difference shows up in a real way: shorter waits on the loading screen, and fewer hitches when a big open world streams new terrain as you move through it.
Why loading was slow before DirectStorage
The traditional way a Windows game reads a file goes through an interface Microsoft calls ReadFile. It works, but it was never built for a fast NVMe drive being hit by thousands of small requests at once. Microsoft’s own documentation spells out the cost: although it is possible to saturate a drive with traditional ReadFile-based IO, the CPU overhead increases non-linearly as the size of individual reads decreases. A game that streams one texture here and a chunk of audio there is issuing exactly the kind of small, frequent requests that push that overhead up the fastest.
Every one of those small requests carries fixed overhead. Each read has to cross from the game into the operating system, get translated into a storage command, and come back with a result, and that per-request cost does not shrink just because the request itself is tiny. When a game issues tens of thousands of small reads per second, the overhead of managing them can consume more processor time than actually moving the data.
There is a second cost stacked on top. Most games keep their assets compressed on disk to shrink the install, then decompress them on the fly while loading. That decompression has historically run on the CPU, and it only gets more expensive as storage bandwidth climbs. Put the two together and the CPU becomes the real bottleneck: a drive that could deliver more data is held back because the processor is too busy unpacking the last batch and paying the per-request overhead of the next one.
Microsoft’s console documentation frames the old limit in concrete terms: the existing Win32 APIs could require an entire CPU core just to keep the drive fed. One core spent moving files is one core not spent on simulation, physics, or anything the game actually needs to run well.
How consoles solved it first
The Xbox Series X|S attacked this problem in hardware. Instead of making the CPU do everything, the console routes IO through an NVMe hardware queue and hands decompression to a dedicated hardware block. Each read can be routed directly from the NVMe drive to that decompression block, so the CPU is left out of the path entirely. Microsoft’s DirectStorage overview for Xbox states the design goal directly: sustain up to 50,000 IO requests per second while using at most 5 to 10 percent of a single CPU core.
DirectStorage started on Xbox and was then brought to Windows. Microsoft deliberately kept the two APIs as similar as possible so that a game optimized for the console’s storage pipeline can be ported to PC without rebuilding its loading code from scratch. That shared design is why the storage technology running inside the console is the same one you hear about on PC.
What DirectStorage changes on PC
DirectStorage is designed to remove most of the operating system’s overhead by talking to the NVMe hardware more directly. Instead of paying a per-request transition cost for every read, the game enqueues many requests into a queue and flushes them to the next pipeline stage in batches. Batching is the core trick: one transition handles many reads, so the CPU cost per read collapses. The queues themselves use lock-free algorithms to minimize contention, and the game controls exactly when each flush happens.
The API also adds two abilities that matter a great deal for streaming. A game can prioritize disk requests, so the assets the player is about to need jump ahead of the assets they might not. It can also cancel requests, which lets a speculative read system ask for data ahead of time and then drop it cleanly if the player turns a different way. Under the old model a canceled read still had to be paid for; here it is simply dropped from the queue. Both of those were hard or impossible under the older interfaces.
There is one important boundary to keep in mind: DirectStorage only supports read operations. It is a loading technology, not a general-purpose file system replacement.
GPU decompression: the biggest single win
Faster reads are only half the story. If data arrives at the GPU faster than it can be decompressed, the CPU still becomes the choke point. The answer DirectStorage uses is GDeflate, a lossless compression format that NVIDIA released as open source. Instead of the CPU unpacking each asset, the GPU does the decompression directly, which frees the processor for gameplay, simulation, and everything else.
NVIDIA’s RTX IO documentation states the difference in measurable terms. Using ZLib to decompress on the CPU cannot saturate modern NVMe bandwidth; GDeflate running on the GPU keeps the drive saturated, with room to spare. Compressed data is delivered straight to GPU memory with minimal staging in system memory, which shortens the entire path from bytes on disk to a usable texture or model.
Put the pieces together and the loading path looks different from the old one. The drive reads compressed data through the NVMe queue. DirectStorage carries that data toward GPU memory with minimal staging in system memory. The GPU decompresses it with GDeflate as it arrives. What reaches the renderer is a ready-to-use asset, and the CPU has spent only a small fraction of the effort the old path would have required.
Lossless compression carries a second benefit that shows up long before you press play. Because assets are stored compressed and unpacked on the fly, a game can ship a smaller install and a smaller download. The drive holds more games, and the initial download finishes sooner, at no cost to image quality because the compression is lossless.
The decompression path arrived in stages. DirectStorage SDK version 1.1.0 added GDeflate GPU decompression. The newer 1.4 preview builds on that with Zstd compression and decompression, a Game Asset Conditioning Library, and better GPU command-queue parallelization. DirectStorage itself is part of the DirectX family of APIs.
What DirectStorage does not do
The marketing around fast storage can blur what DirectStorage actually does. It is read-only, so it does nothing for saving a game or writing data back to disk. It does not raise frame rates by itself. What it changes is how fast assets arrive, which shows up as shorter load times and less of the stutter and pop-in that happen when a streaming system cannot pull textures in fast enough.
It is also not a universal upgrade. The whole point of DirectStorage is to remove overhead that only becomes the bottleneck on a very fast drive. On a slow SATA SSD or a spinning hard drive, the drive itself is the limit long before CPU overhead matters, so DirectStorage has little to offer. The technology is built around NVMe, and the decompression work is handed to the GPU, so the gains depend on the GPU being able to do that work well.
What it means for a PC builder
If you are planning a build or an upgrade, the practical takeaway is straightforward. The single biggest lever for load times is an NVMe SSD, because everything DirectStorage does assumes a drive fast enough to feed the pipeline. Pairing that NVMe drive with a modern GPU is what unlocks the GPU-decompression path. The games that benefit most are the ones built around dense streaming: large open worlds that pull new assets constantly as you move. Games that load everything into memory once and never stream again will see little difference. One quick check before you buy: confirm the drive you are eyeing is NVMe and not SATA. The two look nearly identical in many listings, but only NVMe feeds the pipeline DirectStorage is built for.
This also explains a quiet shift in how PC games are built. When consoles moved to NVMe storage and hardware decompression, the games that took full advantage of it started assuming fast storage rather than working around slow drives. DirectStorage is the Windows answer to that same shift: a way for a PC game to get console-style loading behavior without inventing its own storage stack. Because Microsoft kept the Xbox and Windows APIs nearly identical, a loading pipeline tuned for one platform carries over to the other with far less friction.
The bottom line
DirectStorage is a loading technology, not a magic switch. It attacks a real and specific bottleneck: the CPU overhead of feeding a very fast SSD, plus the CPU cost of decompressing what comes off it. By batching requests, cutting per-request overhead, and moving decompression to the GPU, it lets a modern NVMe system deliver assets much faster than the old path could. The result is shorter load times, fewer pop-in hitches, and smaller installs. If your next machine has an NVMe SSD and a modern GPU, DirectStorage is already part of how it will load your games.
