Why you can trust Tom's Hardware Our expert reviewers spend hours testing and comparing products and services so you can choose the best for you. Find out more about how we test.
Testing the RTX 5090 in games that support DLSS 4 — either natively or via the Nvidia App override method — certainly muddies the waters. Especially when you factor in Multi Frame Generation. It's a topic that deserves additional attention, as this has been a key element in Nvidia's performance claims for the entire Blackwell family of GPUs. First, let's provide some background information via Nvidia — a bit heavy on the marketing speak, as expected.
Bryan Catanzaro is Nvidia's VP of Applied Deep Learning Research, the group that has been continually working to improve features like DLSS, Broadcast, and more. The original DLSS 1.x used spatial upscaling, and the quality and performance were, in a word, lacking. It was restrictive and there was a clear loss in image quality. But that was 2018, and things have changed a lot in the past six years.
DLSS 2.x brought temporal upscaling into the algorithm, yielding far more flexibility, better performance, and higher image quality. As long as a game isn't CPU limited, DLSS upscaling will allow it to render fewer pixels at a lower resolution and then upscale the result to a higher resolution. There are typically four modes: Quality (2.25X upscaling), Balanced (3X upscaling), Performance (4X), and Ultra Performance (9X) — with the latter originally billed as a way to make 8K gaming viable. DLSS 2 and later have been incorporated into over 500 games now, so it's easily the most widely used upscaling algorithm. Not coincidentally, it's also the best looking in our testing.
But what do you do when a game is CPU limited? Flight Simulator as an example sees effectively zero benefit in terms of performance if you're using upscaling on a card like the RTX 4090 at resolutions of 1440p and lower. And with the 5090, that extends to 4K ultra as well. The solution, with the RTX 40-series GPUs, was to add a new Optical Flow Accelerator to help calculate the optical flow between two frames, which could then be used to interpolate a high quality intermediate frame.
The catch is that the game now has to delay showing the user the latest rendered frame while it's busy with frame generation. DLSS 3 framegen could add up to two whole frames' worth of latency, which is why Nvidia requires all DLSS 3 games to implement Reflex. Reflex optimizing the rendering workflow to sample user input later in the pipeline, resulting in lower latency. The result is that framegen with Reflex generally can get pretty close to matching the latency of the non-framegen, non-reflex rendering — but non-framegen with Reflex is still more responsive.
DLSS 3.5 was a separate branch, which dealt with ray reconstruction. In short, it's an AI-trained denoising algorithm that often does a better job than hand-built and custom denoising algorithms. It's not perfect, and it's only useful with ray tracing games, but it also runs on any RTX card and often looks better than the standard denoising algorithms.
Now, with Blackwell, Nvidia has introduced DLSS 4. There are two major updates, one of which applies to all RTX GPUs, while the other requires (as far as we know) an RTX 50-series card. (The above two videos are mostly for reference, not because they're related to the DLSS 4 discussion.)
DLSS Transformers is a retraining of the upscaling algorithm using a transformers network rather than a CNN (convolutional neural network). It requires 4X more compute, but seems to run nearly as fast as the old DLSS while providing higher image fidelity. (Note that running DLSS Transformers on older RTX 30- and 20-series GPUs may show a far larger hit to performance.) Related, there's a ray reconstruction transformers model as well.
The other new feature with DLSS 4 is Multi Frame Generation (MFG). As the name implies, it generates multiple frames rather than interpolating just one. It can run in three modes: 2X (generate a single frame), 3X (generate two frames), and 4X (generate three frames). Otherwise, in principle it's a lot like the original framegen in that it takes two input images plus motion vectors and depth buffers and works to generate high quality intermediate frames.
In practice, there are some big changes compared to DLSS 3 on the RTX 40-series. MFG runs off the Blackwell tensor cores. We don't know if that means it can leverage the FP4 number format, but that would make sense. The OFA in the 40-series was a fixed function unit, and Nvidia eventually reached the point where it could do better framegen via a software algorithm running a new AI model than by the OFA. It also runs faster than the OFA variant, though that might simply be a case of having more compute available.
Could Nvidia also make MFG work on non-Blackwell GPUs? Logic would suggest yes, though the full answer is a lot more nuanced. Whether it can make it run acceptably fast on something like an RTX 2070 is a different matter. We don't have any official statement yet on whether MFG will ever be enabled for the RTX 40-series and earlier, so until it's announced we'd classify this as more of a "maybe" than something that we'll actually see.
There are over 75 games and applications that are currently DLSS 4 enabled, either with native support or via Nvidia App overrides. You can also use the new DLSS Transformers model to get improved image quality, with a slight hit to performance relative to the previously existing DLSS CNN (Convolutional Neural Network) models but with higher image quality. How much higher? That's more difficult to assess and something we haven't had time to really dig into.
But MFG is a bit easier to deal with. It's natively supported in the latest 2.2.1 Cyberpunk 2077 patch, and we ran some tests. We'll start by reporting on the RTX 5090 experience, but the results should apply in various ways to other RTX 50-series GPUs. We focused on 4K using RT-Overdrive (path tracing) for these tests.
First, Here's the chart of performance. Note that we've used the new Transformer DLSS/DLAA models in all cases, except for the "DLSS Q CNN" result that uses the old CNN model. At least with the RTX 5090, the difference in performance between CNN and transformers ends up being negligible, but that's probably because we're running a test with full ray tracing. In rasterization games, or with less demanding RT settings, we expect the transformers model to run a few percent slower — again, at least on the 5090.
We haven't done the testing ourselves, but it sounds like the performance hit of the transformers model on the RTX 40-series is relatively minor, but that it becomes much more significant on the 30-series and 20-series cards. Still, even DLSS Ultra Performance mode at 4K looked far better than we'd expect from 9X upscaling.
If you only look at the given performance numbers, the RTX 5090 with MFG looks quite impressive. You can run DLAA at 4K, with ray reconstruction, and still get 110 FPS! Except, that's only part of the story.
On the labels for each line, we've listed the input latency, as reported by FrameView. Note that here, the MFG4X result has 21ms more latency than the standard DLAA result. What's more, compared to any of the DLSS results, the latency is particularly bad — about double what you get with Quality mode upscaling.
Now, before going further, please note that we tested with DLAA for a reason. We specifically wanted a lower base framerate, because this is what people looking at the mid-tier cards like an RTX 5070 are likely to get. If you start with DLSS Quality mode, MFG doesn't feel nearly so sluggish — and you can end up with about 200 FPS.
While the framerates are what you'll see on your monitor (with an appropriately high refresh rate display), what you'll feel is a different matter. All the non-MFG results are basically what we're used to feeling. With MFG, the added latency makes things feel mushy.
Subjectively, in this one particularly game, I'd say that all the MFG results feel more like a game running at 35~45 FPS. It's playable, in other words, but also a bit sluggish feeling. Note that user input gets sampled at 1/2, 1/3, or 1/4 the listed framerates for MFG, so the base DLAA result samples input every 32.3 ms. Compare that with sampling every 35.0 ms with MFG2X, 35.5 ms with MFG3X, and 36.3 ms with MFG4X.
In my experience with this testing, Cyberpunk would look like it was running at 57, 85, or 110 FPS — and admittedly, anything above 100 really starts to be less noticeable — but it basically felt like a game running at closer to 40 FPS. Which is better than the actual 28.6, 28.2, and 27.6 FPS before MFG kicks in, but not as good as what you'd get if these were actually rendered frames with new user input.
Contrasting the experience of MFG with the higher DLSS upscaling factors and it's a different story. Quality mode feels noticeably more responsive, Balanced and Performance modes feel better still, and Ultra Performance was great.
Again, you can absolutely run Cyberpunk 2077 with DLSS Quality mode, or even DLSS Performance mode, and then enable MFG4X to get a completely different experience. But there's a limit to how fast we need games to go, at least for something like Cyberpunk 2077. Competitive shooters might benefit from native 200 FPS performance, and MFG could then push that up to more than any currently existing monitor. That's not really a meaningful comparison in my book.
It's the experience of taking modest performance (30~40 FPS) and then using framegen or MFG to get a better result that matters. Because rest assured, we'll see RTX 5060 numbers from Nvidia at some point showing MFG4X delivering 120 FPS, give or take. And at that level of performance? It's fine, better than native 30 FPS perhaps... but definitely not the same as a non-framegen 120 FPS result.
