When Nintendo's Ocarina of Time remake was about to launch on Switch 2, one of the loudest arguments online had nothing to do with Link or Hyrule. It was about a technology called DLSS. Fans noticed that the game's own legal notices list AMD's FSR 1.0 and SMAA, not Nvidia's DLSS, and Digital Foundry's analysis of the footage shown so far found no sign of DLSS either. Nintendo hasn't made an official statement about it, so treat the details as reported rather than confirmed. Still, the debate was a good reminder of something: a lot of people care a great deal about a technology most of them couldn't explain.

So let's explain it. This guide covers what DLSS is, how the neural network inside it works, what frame generation adds, and how it compares to the non-AI alternatives.

The problem DLSS is trying to solve

Rendering a modern game is expensive. Every frame, the graphics card has to work out the color of every pixel on your screen. At 1080p that's about two million pixels. At 4K it's more than eight million, four times as many. Add lighting effects like ray tracing, and the cost per pixel goes up too.

You can't just ask the hardware to work four times harder. So developers have always looked for shortcuts. The simplest one is to render the game at a lower resolution and stretch the picture to fit your screen. The problem is that plain stretching looks soft and blurry. Edges get jagged, fine detail disappears, and the whole image looks muddy.

DLSS, which stands for Deep Learning Super Sampling, is a smarter way of stretching. Instead of using a fixed formula to guess the missing pixels, it uses a trained neural network.

What "super sampling" with deep learning means

Think of it like restoring a low-quality photo. If you ask a person who has studied thousands of sharp photographs to touch up a blurry one, they can often fill in believable details: the grain of wood, the edge of a leaf, the lettering on a sign. They aren't remembering this exact photo. They've learned what the world tends to look like.

A neural network does something similar. During training, Nvidia shows the network pairs of images: a low-resolution version of a game frame and a very high-quality reference version of the same frame. The network tries to turn the first into the second, gets scored on how close it came, and adjusts its internal weights. After millions of examples, it gets good at reconstructing detail that a simple stretch would lose.

At runtime, the game renders a smaller image, hands it to the network, and gets back something that looks much closer to native resolution. The heavy math runs on dedicated hardware on Nvidia's RTX cards called tensor cores, which are built for exactly the matrix operations neural networks need.

It's not only looking at one frame

Here's the part that makes modern DLSS work well. The network doesn't just see a single blurry frame. It also gets extra information from the game engine:

Motion vectors, which describe how every object moved between frames.
Depth information, which tells it what's near and what's far.
Previous frames, so it can reuse detail it already figured out.
Subpixel jitter, where the game nudges the camera by a tiny, known amount each frame so that each frame samples slightly different spots.

Combine those, and the network can piece together detail across time. A thin wire that's invisible in one low-resolution frame might be partly captured in the next, and the network stitches those fragments into a clean line. This is called temporal upscaling, and it's the reason DLSS can sometimes look as good as native resolution, or even cleaner in places, since it also smooths out aliasing.

A short history of DLSS

The first version, launched in 2018, had a heavy requirement. Nvidia had to train a separate network for each individual game. Results were mixed, and plenty of players found the image soft.

DLSS 2 arrived in 2020 and changed the approach. It used one general network that works across games, and it leaned heavily on temporal data. Quality jumped, and this is the version that earned the technology its reputation.

Later releases added more. Frame generation came with DLSS 3. Ray reconstruction, which uses AI to clean up noisy ray-traced lighting, followed. DLSS 4 moved to a transformer-based model, the same broad family of architecture behind modern language models, which is better at judging which parts of an image matter. Newer versions have continued to push the idea further, including some that lean harder on AI to alter how scenes look, which is part of why people started using "DLSS 5" as shorthand for an overly smooth, hyper-real image in online arguments. Check Nvidia's own documentation for what each version currently does, since the feature set keeps changing.

Frame generation: inventing frames that were never rendered

Upscaling makes each frame cheaper. Frame generation goes after a different goal: more frames per second.

The idea is simple to state. The GPU renders two real frames, then a neural network creates an extra frame that sits between them. Instead of 60 frames per second you see something closer to 120. The AI estimates how things moved using motion vectors and a map of pixel movement called optical flow, then fills in what the in-between moment would plausibly look like.

Newer versions can generate more than one extra frame between each pair of real ones.

This sounds like free performance, and in some ways it is, but there are trade-offs worth knowing:

Latency doesn't improve. The generated frames aren't based on your input. Pressing a button still takes just as long to show up on screen as before, and in some cases a bit longer, since the system has to wait for the next real frame before it can build the one in between. For a slow adventure game that's fine. For a competitive shooter it matters.

It works best from a decent baseline. If the game is already running at 20 fps, generating frames from that gives you a smoother-looking but still sluggish experience. Most advice is to have a stable 40 to 60 fps before turning it on.

Artifacts can appear. Fast, unpredictable motion, such as particles, quickly spinning objects or UI elements, can cause smearing or ghosting.

How DLSS compares to FSR

The other name in this story is AMD's FidelityFX Super Resolution, or FSR. The key difference is how each version works under the hood.

FSR 1.0, the version reportedly used in the Zelda remake, is a spatial upscaler. It looks at one frame at a time and applies a hand-written algorithm to sharpen and enlarge it. It doesn't use a neural network, doesn't use motion vectors, and doesn't remember earlier frames. That makes it simple, fast, and able to run on almost any hardware, including older GPUs and consoles. The downside is quality. Because it can't draw on extra information, it can't recover detail that wasn't in the original image, and the results are usually softer than temporal methods.

Later versions of FSR switched to temporal techniques, and the newest ones use machine learning, so the gap has narrowed. But the basic split remains useful:

Spatial, formula-based upscaling: cheap, universal, limited quality.
Temporal, AI-based upscaling: higher quality, needs more data from the game and often specialized hardware.

SMAA, the other technology mentioned in that Switch 2 listing, is just an anti-aliasing method. It smooths jagged edges but doesn't increase resolution at all.

Neither choice is automatically "right." A developer might pick a lighter technique to keep a game running at a locked frame rate, to save battery on a handheld, or simply because it's easier to integrate. Whether it was the best call for a particular game is a fair thing to argue about, and that's exactly what players have been doing.

Why people dislike AI upscaling, and why some love it

Reactions to DLSS fall into a few camps.

Fans love that it lets cheaper hardware show nicer images. On a handheld or a mid-range PC, it can be the difference between a choppy game and a smooth one.

Critics point out a few real issues. Upscaled images can look slightly over-sharpened or oddly clean. Generated frames aren't "real" performance, and some developers lean on them to hide poor optimization. And because the network is filling in detail from learned patterns, it can occasionally produce things that were never in the original art.

That last point is the heart of the philosophical debate. Is an AI-reconstructed image faithful to what the artists made, or is it a plausible guess dressed up as the original? In most games, DLSS is close enough that it doesn't matter. But the question gets more interesting as the technology moves from reconstructing detail to altering style.

What this tells you about deep learning in general

DLSS is a nice teaching example because it shows several core ideas from deep learning in one place:

Learning from paired examples. The network is trained to map a bad input to a good target.
Specialized hardware. Tensor cores exist because neural networks are mostly big matrix multiplications.
Using extra context. Feeding in motion and depth data makes the network far more accurate than looking at pixels alone.
Trade-offs. Quality, speed, latency and trust all pull against each other, and no setting wins on every axis.

You don't need to be a graphics programmer to see the pattern. It's the same one behind many AI products: train a model on lots of examples, run it fast on suitable hardware, and accept that it will be right most of the time and occasionally wrong in interesting ways.

The short version

DLSS renders a game at lower resolution and uses a trained neural network, helped by motion and depth data, to rebuild a sharper image. Frame generation uses another network to create extra frames in between real ones for smoother motion, at the cost of some latency. Simpler techniques like FSR 1.0 do the stretching with fixed formulas instead of learning, which is cheaper and works almost everywhere, but can't recover as much detail.

Next time a game launches and someone asks "does it support DLSS?", you'll know what's actually being asked, and why the answer can start such a big argument.