Nvidia DLSS vs. Nvidia Image Scaling vs. AMD Super Resolution

DMCA / Correction Notice
- Advertisement -


Nvidia just gave its Nvidia Image Scaling (NIS) feature a big boost. It is now available as part of the GeForce Experience and as a kit that developers can add to their games. It’s a clear attempt to stab back at AMD’s FidelityFX Super Resolution (FSR) upscaling feature, which itself was an attempt to go up against Nvidia’s Deep Learning Super Sampling (DLSS).

- Advertisement -

unclear? We don’t blame you. Paytm may go back and forth between two multi-billion dollar companies, there are differences between DLSS, FSR and NIS. We took three upscaling tools for a spin on five popular games to see differences in performance and image quality.

advertisement

const mediaQuery = window.matchMedia("(max-width: 1304px)"); let cloneEl, label, labelText, cloneList, cloneBtn;

function showBtnText(item, count) { item.innerHTML = listItemsLength - count === 1 ? "Show 1 more item" : "Show " + (listItemsLength - count) + " more items"; }

function changeBtn(btn, list, count) { btn.addEventListener("click", function(e) { if (list.classList.contains(listModifier)) { list.classList.remove(listModifier); btn.classList.add(additionalBtnClass); btn.innerHTML = "Show less"; } else { showBtnText(btn, count); btn.classList.remove(additionalBtnClass); list.classList.add(listModifier); } }); }

function changeList(list, btn, count) { if (listItemsLength count) { list.classList.add(listModifier); btn.classList.add(showBtnClass); showBtnText(btn, count); } }

if (mediaQuery.matches) { cloneEl = el.cloneNode(true); cloneEl.classList.add("b-toc--mobile"); cloneEl.removeAttribute("id"); document.body.append(cloneEl); label = cloneEl.querySelector(".b-toc__label"); labelText = label.textContent; cloneList = cloneEl.querySelector(".b-toc__items"); cloneBtn = cloneEl.querySelector(".b-toc__button");

changeList(list, btn, mobileCount); changeList(cloneList, cloneBtn, mobileCount);

changeBtn(btn, list, mobileCount); changeBtn(cloneBtn, cloneList, mobileCount);

cloneEl.addEventListener("click", function(e) { if (e.target.classList.contains("b-toc__label")) { if (cloneEl.classList.contains("b-toc--sticky")) { cloneEl.classList.toggle("b-toc--opened"); }

label.innerHTML = labelText; label.classList.remove("is-active"); }

if (e.target.tagName === "A" && cloneEl.classList.contains("b-toc--opened")) { cloneEl.classList.remove("b-toc--opened"); } }); } else { changeList(list, btn, desktopCount); changeBtn(btn, list, desktopCount); }

const observer = new IntersectionObserver(entries = { entries.forEach(entry = { const id = entry.target.getAttribute("id"); const text = entry.target.parentElement.textContent; const links = document.querySelectorAll(`.b-toc__items li a[href="#${id}"]`);

if (entry.intersectionRatio 0) { links.forEach(link = { link.parentElement.classList.add("is-active"); });

if(cloneEl) { if (cloneEl.classList.contains("b-toc--opened")) { label.innerHTML = labelText; label.classList.remove("is-active"); } else { label.innerHTML = text; label.classList.add("is-active"); } } } else { links.forEach(link = { link.parentElement.classList.remove("is-active"); });

if(cloneEl) { label.innerHTML = labelText; label.classList.remove("is-active"); } } }); });

document.querySelectorAll("h2 a[id]").forEach(item = { observer.observe(item); });

if(cloneEl) { let previousY = 0; let previousRatio = 0;

const mobileObserver = new IntersectionObserver(entries = { entries.forEach(entry = { const currentY = entry.boundingClientRect.y; const currentRatio = entry.intersectionRatio;

if (currentY < previousY) { if(currentRatio < previousRatio) { cloneEl.classList.add("b-toc--sticky"); } } else if (currentY > previousY) { if (currentRatio previousRatio) { cloneEl.classList.remove("b-toc--sticky"); } }

previousY = currentY; previousRatio = currentRatio; }); });

document.querySelectorAll(".b-toc:not(.b-toc--mobile)").forEach(item = { mobileObserver.observe(item); }); }

window.addEventListener("hashchange", function () { window.scrollTo(window.scrollX, window.scrollY - 125); }); }); })();

Graphics card and game support

Before getting into our image quality comparison and performance results, it’s important to understand the differences between DLSS, FSR, and NIS. DLSS is the most complex of the three. It only works on Nvidia RTX 20- and 30-series graphics cards, and it only works in supported games. Developers have to include it, so if you don’t see the DLSS option in your favorite game, there’s no way to add it.

Explanation of Nvidia DLSS.

There’s a good reason for this. DLSS uses AI to enhance the image. RTX 20- and 30-series graphics cards have dedicated AI accelerators called Tensor cores. In each Nvidia driver release, it includes an AI model that can run on these Tensor cores to improve the image in real time. In addition to AI models, DLSS uses temporal (time-based) information during the upscaling process, which reduces flicker, ghosting, and other visual artifacts.

NIS and FSR work very differently. Both are spatial upscaling tools, not temporal ones. Instead of taking a series of frames and using the temporal information for upscaling, FSR and NIS base the upscaling on the current frame that is being rendered. It’s more ghostly and shimmery, along with other visual artifacts.

Neither feature uses AI. Instead, the FSR and NIS upscale based on the frame being rendered and then apply a sharpening filtering to make the image look like it was run at a higher resolution. On a technical level, FSR and NIS are almost identical. The only difference is that NIS does upscaling and sharpening in a single pass, while FSR breaks those steps up into two passes.

AMD's Super Resolution technology explained.

However, there are some differences in game and graphics card support. FSR is only available as a Software Development Kit (SDK). Developers can add it to their games, but unless you’re familiar with game modding, you’re limited to the list of games that support FSR. However, the advantage of this approach is that FSR works on all graphics cards from AMD and Nvidia.

NIS is the opposite of FSR when it comes to GPU and game support. It works in all games but only with Nvidia GPU. Right now, NIS is available through the Nvidia Control Panel and GeForce Experience, and you need an Nvidia graphics card to access these programs. Unlike DLSS, you are not limited to the latest Nvidia GPUs. As long as it’s an Nvidia card that uses these programs, you can use NIS.

Nvidia also has NIS available as an SDK for developers. This version is similar to FSR. Developers can incorporate it into their games if they wish, and it will work across graphics cards from AMD and Nvidia. Although right now we don’t have any games that officially support NIS.

call of duty vanguard

Upscaling Mode in Call of Duty Vanguard.

call of duty vanguard is the most recent release from the games we tested, and it uses DLSS, FSR, and NIS to great effect. Still, there are differences in image quality. The logs on the cabin look just a hair sharp with the DLSS. The green crate next to the wall also shows some aliasing around the edges with FSR and NIS, which is a problem that DLSS doesn’t have.

The biggest difference we can make out comes in the trees behind the building. DLSS cleans the leaves, FSR smudges them a bit, and NIS washes them. Background elements in general look worse with NIS. Overall, DLSS is the leader in image quality, and NIS and FSR are tightly grouped behind DLSS.

RTX 3090, Core i9-10900K
Baseline (4K Ultra) 99 frames per second
Start 193 FPS (95%)
FSR 190 fps (92%)
DLSS 163 fps (65%)

For performance, we tested a stint in multiplayer using the most aggressive upscaling mode for each tool. Although we’ve included the average frame rate for each setting, we recommend paying more attention to the percentage increase. We tested with top-of-the-line hardware, so percentage is much more important than actual frame rate.

Nothing interesting to report here, with the upscaling mode lining up with the results in our call of duty vanguard Performance Guide. FSR and NIS are doing essentially the same thing, and they produce very similar results. DLSS is well below the other two, but it’s hard to argue with the 65% increase in performance—especially how much better DLSS looks than the other two.

deathloop

Upscaling mode in Deathloop.

deathloop Shows some obvious difference in image quality…

- Advertisement -

Stay on top - Get the daily news in your inbox

Recent Articles

Related Stories