For years, PC gaming performance had one obvious villain: the graphics card.
Game runs badly? Lower the resolution. Turn down shadows. Disable anti-aliasing. Sacrifice reflections. Buy a faster GPU. If all else fails, stare at the Ultra preset and ask yourself whether individual blades of grass really deserve this much electricity.
Then we got better at solving the problem.
Modern GPUs became enormously faster. DLSS, FSR, and XeSS allowed games to render fewer pixels and reconstruct the rest. Dynamic resolution became commonplace. Frame Generation went one step further and started creating entirely new frames between traditionally rendered ones.
And strangely enough, solving the GPU problem may have exposed another one: The CPU. This doesn’t mean modern games have suddenly stopped being GPU-intensive. Far from it. Nor does it mean DLSS somehow makes your processor slower.
Instead, PC gaming has become increasingly good at removing GPU bottlenecks, while CPU bottlenecks remain much harder to escape. And once the GPU stops being the slowest part of the machine, something else has to take its place.
Your Bottleneck Was Always Hiding Something
Imagine your CPU can prepare 90 frames every second, while your GPU can only render 55. Your result is roughly 55 FPS. The GPU is clearly the bottleneck.
Now enable DLSS. By rendering the game at a lower internal resolution and reconstructing the final image, the GPU can suddenly handle 80 FPS. Great.
Switch to a more aggressive upscaling mode and perhaps the GPU could theoretically handle 120 FPS. Except you don’t get 120 FPS. You get around 90. Your GPU bottleneck is gone, but you haven’t eliminated the bottleneck itself. You have simply discovered the next one.
Epic Games describes essentially this behavior in its Unreal Engine performance documentation. Games have multiple major contributors to frame time, including the game thread, render thread, and GPU. Whichever takes the longest determines performance, and optimizing one can expose another bottleneck that was previously hidden.
This isn’t unique to upscaling, either.
Put a much faster graphics card into the same PC and the same thing can happen. CPU benchmarkers deliberately pair processors with extremely powerful GPUs and test at lower resolutions for precisely this reason: they want to remove the GPU as the limiting factor so differences between CPUs become visible.
The faster GPUs become, the easier it becomes to find the CPU waiting behind them.
Might be related: Tech Explained: Laptop vs Desktop on Power Consumption
DLSS Doesn’t Make Your CPU Faster
This is where modern GPU technologies create an interesting imbalance. DLSS, FSR, and XeSS Super Resolution primarily attack the cost of rendering graphics.
Instead of rendering a full 3840 × 2160 image—more than eight million pixels—the game can render substantially fewer pixels and reconstruct a higher-resolution output. That can dramatically reduce GPU workload. But reducing rendering resolution doesn’t necessarily make the CPU’s other jobs cheaper.
The CPU may still need to handle:
- game logic and scripting
- NPC behavior and AI
- physics
- animation systems
- draw-call preparation
- object management and culling
- world simulation
- asset streaming and related processing
If your GPU needs 14 milliseconds to render a frame while your CPU needs eight, reducing GPU time to six milliseconds is fantastic. It also means your eight-millisecond CPU workload is now the bottleneck.
Lower the resolution again and you might accomplish something truly remarkable: making the game look worse without making it run faster. Anyone who has desperately switched from DLSS Quality to Performance only to watch the FPS counter barely move has probably met this particular wall.
Some Modern Games Really Are Hammering CPUs
There’s another side to the story, because we’re not merely exposing the same CPU workloads that games had 15 years ago. Some modern games really are doing increasingly complicated things on the CPU.
Large worlds need to be streamed and managed. Crowded environments can contain huge numbers of NPCs. Physics, animation, game logic, traversal, AI, and increasingly complicated rendering systems all need processing somewhere.
Baldur’s Gate 3 provides a famous example. Performance can become considerably more CPU-limited in the dense city areas of Act 3, where the game suddenly has far more characters and systems to manage.
Starfield has demonstrated substantial CPU scaling even when reducing graphics settings. Microsoft Flight Simulator is practically a CPU-bottleneck laboratory disguised as an airplane game.
Then there’s Warhammer 40,000: Space Marine 2, where enormous Tyranid hordes aren’t simply decorative pixels. The game needs to manage all those enemies, helping produce significant differences between processors even when paired with powerful GPUs.
This doesn’t prove that all games are becoming CPU-bound. That’s an important distinction. There are still plenty of games that will happily consume every bit of GPU performance you give them, especially at high resolutions with ray tracing enabled.
But modern games have developed some exceptionally demanding CPU workloads at the same time that GPUs have become better at escaping theirs. Those two trends eventually collide.
We Have Become Very Good at Cheating Graphics
The fundamental problem is that graphics are surprisingly easy to cheat. Not easy in the engineering sense. Technologies like DLSS are enormously sophisticated. But graphics contain information that can be approximated.
You don’t necessarily have to calculate every pixel at full resolution if previous frames, motion vectors, depth information, and sophisticated reconstruction algorithms can help predict what the final image should look like. Render less. Reconstruct more.
The player gets something reasonably close to the expensive version for substantially less GPU work.
Now try applying the same philosophy to game simulation.
Suppose an NPC sees you, alerts three nearby enemies, calculates a path around a table, fires a weapon, hits an explosive barrel, and sends six physics objects flying across the room. Which half of that should the CPU simply not calculate?
We can lower an NPC’s update frequency. Developers can simplify distant simulations. AI can use different levels of detail. Engines can distribute workloads across more CPU threads. But those are engineering decisions that developers have to build into the game.
There is no universal: NPC Quality: DLSS Performance where the CPU simulates 300 people and machine learning hallucinates the other 700. Although that would explain a surprising amount of open-world NPC behavior.
Definitely related: Why Modern PC Games Depend on DLSS and Keep Getting More Demanding
Frame Generation Sort of Solves This—But Also Doesn’t
Frame Generation complicates the argument. Unlike Super Resolution, Frame Generation actually can increase displayed FPS in a CPU-limited game.
NVIDIA has specifically demonstrated DLSS Frame Generation in CPU-heavy games such as Microsoft Flight Simulator. Because generated frames are created without requiring the CPU to produce another complete game frame, Frame Generation can push displayed frame rates beyond the CPU’s normal rendering ceiling.
Suppose your processor can only supply 55 real frames per second. With Frame Generation, you might see something closer to 100 FPS on your monitor.
Problem solved? Visually, partially. Computationally, no.
The CPU hasn’t suddenly started processing game logic at 100 FPS. The game is still producing its underlying simulation and traditionally rendered frames at roughly the original rate, while additional visual frames are inserted between them.
This means modern gaming increasingly has three different concepts hiding underneath one innocent-looking number: simulation rate, rendered frame rate, and displayed frame rate.
Frame Generation can make a CPU-limited game look dramatically smoother, but it cannot magically double the speed at which the CPU processes the game itself. In other words, we finally found a way to cheat CPU-limited FPS. We just cheated the FPS rather than the CPU.
Why Isn’t There a DLSS for CPUs?
There are technologies designed to reduce specific CPU workloads.
Microsoft’s DirectStorage, for example, attempts to modernize asset-loading pipelines and reduce CPU overhead associated with storage and decompression. Better APIs can reduce draw-call overhead. Engines continue getting better at multithreading, scheduling, culling, and distributing work across increasingly complicated processors.
But notice how specific these solutions are.
GPU reconstruction attacks an unusually universal problem: rendering pixels is expensive. CPU workloads are far messier.
One game might be limited by NPC simulation. Another might struggle with draw calls. Another has expensive physics. Another suffers from poor thread synchronization. Another simply has one enormous game thread that refuses to share its toys with the other 15 CPU cores.
Solving those problems usually requires changing how the game or engine works. That’s much harder than giving players a menu option.
This Might Explain the Rise of X3D CPUs
This also helps explain why gaming CPUs have become such an important part of enthusiast PC discussions. AMD’s X3D processors have demonstrated enormous advantages in certain games, sometimes even when running at resolutions we traditionally considered “GPU-bound.”
That’s not because resolution suddenly stopped mattering. It’s because modern high-end GPUs can be fast enough to reach CPU limits even at 1440p—and occasionally 4K.
The RTX 4090 already made this increasingly visible. The RTX 5090 pushes it further. Future GPUs presumably aren’t planning to become slower out of politeness toward your processor. And upscaling effectively gives that GPU another performance multiplier.
A CPU that could comfortably feed yesterday’s graphics card may therefore become the limiting component long before it feels “old” in conventional computing terms. That’s a very different upgrade dynamic from the old assumption that you could keep the same processor through several generations of increasingly powerful GPUs without worrying much about it.
CPU Bottlenecks Are Also More Annoying
Perhaps this is why CPU bottlenecks increasingly feel worse. GPU bottlenecks give you options.
Running at 45 FPS? Drop from Ultra to High. Lower ray tracing. Use DLSS Quality. Try Balanced. Reduce resolution. Enable Frame Generation. The image gets progressively worse, but performance usually moves in the correct direction.
CPU-bound? You can hunt through settings for whichever ones happen to affect CPU workload. Crowd density might help. Simulation quality might help. View distance sometimes helps.
But lowering texture quality probably won’t. Lowering resolution definitely won’t solve most CPU workloads. And DLSS Performance might simply give your GPU more time to sit around wondering what the CPU is doing.
Eventually you reach a point where there isn’t another graphics option to sacrifice. The game simply cannot produce real frames any faster.
The GPU Problem Didn’t Disappear. We Just Got Better at Escaping It
None of this means the CPU has replaced the GPU as the most important gaming component. Turn on path tracing at 4K and your graphics card will quickly remind you that it remains perfectly capable of suffering.
Instead, something more interesting has happened. For decades, increasing graphical complexity was one of the dominant limits on PC gaming performance. Our solution was faster GPUs.
Then we added increasingly clever ways of avoiding some of that work entirely. Dynamic resolution. Temporal reconstruction. DLSS. FSR. XeSS. Frame Generation. Multi Frame Generation. Each technology pushes the graphics bottleneck a little further away. But the rest of the game still has to happen.
Enemies need to think. Physics needs to run. Worlds need to stream. Objects need to be managed. Commands need to reach the GPU. The next real frame still needs to exist before we can reconstruct or interpolate anything from it.
So perhaps games aren’t simply “becoming CPU-bound.” We’re getting better at reaching the CPU bottleneck.
And after spending years inventing increasingly ingenious ways to make GPUs do less work, PC gaming may be discovering that the hardest performance problem is the one we can’t solve by rendering it at a lower resolution.
