A Deep‑Dive, Step‑by‑Step Masterclass on NVIDIA DLSS & AMD’s Upscaling Counterpart

1. Why Upscaling Exists – The Core Problem

Let’s start with the uncomfortable truth.

Modern AAA games don’t want to run at 1080p anymore. They want 4K, 60+ FPS, ray tracing everywhere, ultra-sharp textures, dense worlds, cinematic lighting, and zero compromises. In other words, they want your GPU to do everything — all at once.

But GPUs, even very powerful ones, still have limits.

When your graphics card renders a single frame, it doesn’t just “draw a picture.” It goes through a pipeline — a sequence of expensive steps that all compete for GPU time. On a typical modern system running a 4K game (think RTX 3080-class hardware), that workload roughly looks like this:

Now look closely at that last line.

The Real Bottleneck: Pixels

A 4K screen is 3840 × 2160 pixels — that’s over 8.3 million pixels per frame.
At 60 FPS, your GPU has to fully shade almost 500 million pixels every second.

That final output stage doesn’t care how good your lighting model is or how smart your shaders are. It’s pure brute force. Every pixel must be calculated, shaded, blended, and written to memory.

And here’s the key insight:

Even if your GPU is amazing at ray tracing, AI, or shaders — pixels are still expensive.

The Obvious Question

So what if we didn’t have to shade all those pixels?

What if the game internally rendered at a lower resolution — say 2560×1440 or even 1920×1080 — and then somehow reconstructed the missing detail so the final image still looks like 4K?

If we could do that:

• That 30% pixel cost would shrink dramatically
• Those saved resources could be used for:
  • Better ray tracing
  • Higher frame rates
  • More detailed textures
  • More complex scenes

This idea isn’t new. Upscaling has existed for years.
What is new is doing it well enough that you don’t notice.

And that’s where AI-driven upscaling — and DLSS — enters the story.

2. The Two Main Players

Once the industry accepted that brute-forcing native 4K forever was a losing battle, two camps emerged. They agree on the problem — too many pixels, not enough time — but completely disagree on how to solve it.

Think of this less like two features and more like two philosophies.

NVIDIA: “Let the AI handle it”

NVIDIA looked at the rendering pipeline and said:

What if we stop thinking like graphics programmers and start thinking like machine-learning engineers?

DLSS (Deep Learning Super Sampling) is built around a trained neural network. NVIDIA feeds the network millions of high-resolution reference frames on supercomputers, then ships the trained model to your GPU. At runtime, your RTX card uses dedicated Tensor Cores to reconstruct a high-resolution image from a lower-resolution render, using motion vectors and data from previous frames.

The key idea is specialization:

• Dedicated hardware
• Proprietary models
• Tight integration with the driver and the game

The result is often excellent image quality — especially at higher resolutions — but it comes at the cost of hardware lock-in.

AMD: “Make it work everywhere”

AMD took a very different route.

Instead of AI models and special cores, FidelityFX Super Resolution focuses on clever math and temporal reconstruction implemented in standard shaders. If a GPU can run modern shaders, it can run FSR. No training data, no proprietary hardware, no vendor lock.

FSR started as a purely spatial upscaler (FSR 1.0), then evolved into a temporal solution (FSR 2.x) that competes much more closely with DLSS in motion stability and detail. With FSR 3, AMD also entered the frame-generation space — but still with a strong focus on openness and cross-platform support.

The philosophy here is accessibility:

• Works on AMD, NVIDIA, Intel, and even integrated GPUs
• Open-source implementation
• Easy for developers to adopt across platforms

The trade-off? Results depend heavily on implementation quality, and image reconstruction can be less consistent than DLSS in difficult scenes.

Side-by-Side: DLSS vs FSR

Same Goal, Very Different Roads

Both DLSS and FSR are trying to cheat physics in your favor — render fewer pixels, show more detail. The difference is how they cheat:

• DLSS bets on AI, custom silicon, and closed ecosystems
• FSR bets on portability, openness, and broad hardware support

Neither approach is universally “better.” The right answer depends on your GPU, your game, and what compromises you’re willing to make — which is exactly what the rest of this guide is about 😉

3. How DLSS Works – From Tensor Cores to the AI Model

DLSS is often described as “AI magic,” but there’s nothing mystical about it. It’s a very deliberate trade: render fewer pixels, then use math and machine learning to rebuild what you didn’t draw.

To understand how that works, you have to split DLSS into two very different phases: training and inference.

Phase 1: Training (Offline, on NVIDIA’s Side)

This part never happens on your PC.

NVIDIA trains DLSS on massive super-computers using real games. The idea is simple: show a neural network what perfect images look like, then teach it how to recreate them from incomplete information.

Here’s how that process works:

1. Capture the ground truth
   NVIDIA runs a game at extremely high quality — often 8K or higher, with maximum settings and heavy supersampling. These frames become the “gold standard”: what the image should look like.
2. Create the low-resolution inputs
   The same scenes are rendered again at much lower resolutions (for example, 1080p). Along with the raw image, NVIDIA collects extra data the engine already produces:
   • Motion vectors
   • Depth buffers
   • Exposure and color information
3. Optimize the model for real hardware
   Once training is complete, the model is compressed and quantized to FP16 or INT8, so it can run extremely fast on RTX Tensor Cores. This trained model is then shipped to your GPU via driver updates and game integrations.

Train the neural network
A deep convolutional neural network (CNN — typically a ResNet-style architecture) is trained to answer one question:

“Given this low-resolution frame and all this motion and depth data, what would the high-resolution image look like?”

Over millions of frames, the network learns how edges behave, how fine detail moves, and how to avoid common upscaling artifacts like shimmer and ghosting.

At this point, the learning is done. Your GPU never “trains” DLSS — it only uses the trained model.

Phase 2: Inference (Real-Time, on Your GPU)

This is the part that happens every frame while you play.

Instead of rendering at native 4K, the game intentionally renders at a lower internal resolution — and lets DLSS handle the rest.

A typical DLSS frame looks like this:

1. Lower-resolution render
   The game renders the scene at a reduced resolution (for example, 1440p for a 4K output target). This alone saves a massive amount of GPU work.
2. Frame data is collected
   The GPU sends the following buffers to the DLSS engine:
   • Color buffer
   • Motion vectors
   • Depth information
   • Exposure data
3. AI reconstruction on Tensor Cores
   The DLSS neural network runs once per frame on the Tensor Cores. Using the current frame plus history from previous frames, it reconstructs a high-resolution image that closely matches native 4K.
4. Sharpening and cleanup
   A final sharpening pass (strength depends on the selected quality mode) restores edge contrast and fine detail.
5. Final image output
   The reconstructed frame is sent to the display as if it were rendered natively.

From the game’s point of view, the frame is “done.” The GPU just saved a huge amount of rasterization work.

Temporal Feedback: Why DLSS Needs Multiple Frames

DLSS doesn’t treat each frame in isolation.

Instead, it keeps a short history — usually 4 to 6 previous frames — and uses motion vectors to understand how pixels move across time. This temporal feedback is what allows DLSS to:

• Reduce flickering
• Preserve thin details (like wires or fences)
• Maintain stability during camera movement

In simple terms:
One low-resolution frame is blurry. Six frames contain enough information to reconstruct detail.

This is also why DLSS can sometimes struggle with bad motion vectors or incorrect depth data — it relies heavily on the game engine feeding it clean inputs.

DLSS 3: Frame Generation Enters the Picture

DLSS 3 adds a second neural network on top of upscaling: Frame Generation.

Instead of just improving image quality, this network creates entirely new frames between rendered ones. It does this using:

• Optical Flow data (tracking how pixels move between frames)
• Motion vectors from the engine

The result is a frame sequence like this:

Rendered → Generated → Rendered → Generated

So a game running at 60 FPS can appear as 120 FPS, even though the rasterizer is still only working at the original rate. To counter the added latency from generated frames, NVIDIA pairs DLSS 3 with NVIDIA Reflex, which shortens the input pipeline.

Important detail:
Frame Generation boosts smoothness, not raw simulation speed. The game logic still runs at the base frame rate.

Key Takeaway: DLSS trades raw rasterization power for AI inference. Tensor Cores are purpose‑built for this, delivering > 10 TFLOPs of mixed‑precision throughput, which is why DLSS can be cheaper than traditional supersampling.

4. How FSR Works – Spatial vs. Temporal Upscaling

While DLSS leans heavily on AI models and dedicated hardware, AMD’s FidelityFX Super Resolution takes a more down-to-earth approach. The goal is the same — render fewer pixels and reconstruct the image — but the tools are very different.

FSR is built around a simple idea:

If the GPU already knows where pixels came from and where they’re going, maybe we don’t need a neural network to guess the rest.

Over time, this idea evolved into three distinct generations of FSR, each solving a different part of the upscaling problem.

FSR 1.0 – Pure Spatial Upscaling

FSR 1.0 is the simplest version — and that simplicity is both its strength and its weakness.

At its core, FSR 1.0 is a single-frame upscaler. It looks at one low-resolution image and tries to make it bigger and sharper without any knowledge of past frames.

Technically, it works like this:

• The image is upscaled using a Lanczos-3 reconstruction filter, a high-quality mathematical resampling method commonly used in image processing.
• A sharpening pass is applied on top to counteract blur introduced by scaling.

That’s it. No motion vectors. No history buffers. No temporal logic.

What this means in practice

Because FSR 1.0 only touches the current frame:

• There is no added latency
• No risk of temporal artifacts like ghosting
• No dependency on engine data

But there’s a trade-off:

• Aliasing and shimmering remain visible
• Fine detail can break apart during motion
• Image stability is worse than temporal solutions

The upside is compatibility. Since FSR 1.0 is implemented entirely as a shader, it runs on:

• AMD GPUs
• NVIDIA GPUs
• Intel GPUs
• Integrated graphics

If it can run a modern shader, it can run FSR 1.0.

FSR 2.x – Temporal Upscaling (The “DLSS-Like” Version)

FSR 2 is where AMD closed most of the quality gap with DLSS.

Instead of treating each frame in isolation, FSR 2 embraces the same core insight as DLSS:
one frame is noisy, many frames contain detail.

Step 1: Reconstruction pass

Each frame starts as a lower-resolution render. The FSR 2 pipeline then gathers:

• The low-resolution color buffer
• Motion vectors
• Depth information
• Exposure data

Using this information, FSR reconstructs where pixels should land in the final high-resolution frame.

Step 2: Temporal accumulation

This is the heart of FSR 2.

FSR blends data from the current frame with several previous frames using a variance-aware weighting scheme. Pixels that are stable over time are trusted more; pixels that change rapidly are weighted less to avoid smearing and ghosting.

This temporal logic:

• Improves fine detail
• Reduces flicker
• Stabilizes edges during motion

It’s conceptually similar to DLSS — but implemented with deterministic math instead of a trained model.

Step 3: Contrast-Adaptive Sharpening (CAS)

After reconstruction and accumulation, FSR applies CAS, a sharpening algorithm designed to restore edge contrast without oversharpening flat areas.

The result is an image that often looks impressively close to native resolution — especially in Quality and Balanced modes.

Why it runs everywhere

FSR 2 is written entirely in HLSL / GLSL and runs on the standard pixel and compute pipelines. No Tensor Cores. No AI accelerators. No vendor-specific hardware.

That’s why the same code path works across:

• Windows and Linux
• Consoles
• GPUs from multiple vendors

FSR 3 – Frame Generation (The Experimental Step)

With FSR 3, AMD entered the frame generation race.

The idea mirrors DLSS 3:

• Render real frames at a base frame rate
• Generate intermediate frames to increase smoothness

FSR 3 relies on optical flow and motion data, and on newer AMD GPUs it can take advantage of Radeon AI hardware (tensor-like units present in RDNA 3 and CDNA 2 architectures).

However, FSR 3 is still early:

• Image consistency varies between games
• Tooling and engine integration are less mature
• Linux support exists but remains limited and evolving

In short, it works — but it’s not yet as polished as DLSS frame generation.

The Bottom Line

FSR’s strength has always been universality.

• FSR 1.0 proved that upscaling doesn’t require special hardware
• FSR 2.x showed that temporal techniques can rival AI-based solutions
• FSR 3 aims to close the smoothness gap with frame generation

Historically, DLSS held a clear advantage in aggressive performance modes and edge reconstruction. With FSR 2.2, that gap narrowed dramatically — especially for players who value compatibility over vendor lock-in.

FSR may not always win the pixel-peeping contests, but it wins where it matters most:

It works almost everywhere.

5. Hardware & Driver Prerequisites on Ubuntu

Upscaling on Linux isn’t about flipping a single toggle — it’s about lining up hardware, drivers, kernel, and runtime so they all agree on what’s possible.

The good news: on modern Ubuntu releases, both NVIDIA and AMD are fully capable of DLSS/FSR workflows.
The bad news: the details matter.

Let’s break it down.

The Hardware Line in the Sand

Before drivers or kernels enter the picture, the GPU itself sets the rules.

NVIDIA GPUs

For DLSS, the requirement is non-negotiable: Tensor Cores.

That means:

• RTX 20 series (Turing) or newer
• RTX 30 / 40 series work best
• Quadro RTX cards are also supported

Older GTX cards can run games just fine — but DLSS will simply never appear as an option.

AMD GPUs

FSR is much more forgiving.

While FSR 1.x can run on almost anything, for FSR 2.x and 3 you realistically want:

• Radeon RX 5000 series (RDNA 1) or newer
• RX 6000 and RX 7000 work best and receive the most driver attention

No special AI hardware is required for FSR upscaling itself.

Drivers: Where Most Linux Issues Come From

On Ubuntu, drivers matter more than almost anything else.

NVIDIA: Proprietary, but Predictable

NVIDIA’s Linux stack is closed-source, but extremely consistent once installed correctly.

You’ll want:

• nvidia-driver-525 or newer

This single package provides:

• The nvidia kernel module
• CUDA libraries
• OpenGL 4.6 support
• Vulkan 1.3 support (required for modern Proton and DXVK)

In practice, newer drivers usually mean:

• Better DLSS stability
• Fewer Vulkan crashes
• Better Proton compatibility

AMD: Open Source, Kernel-Driven

AMD’s approach is the opposite.

Most of what you need already ships with Ubuntu:

• The AMDGPU kernel driver
• Mesa for OpenGL and Vulkan

For best results:

• Use the latest Mesa version available for your Ubuntu release
• amdvlk is optional; most users stick with Mesa’s Vulkan driver (RADV), which works very well with Proton and FSR

Kernel Version: Don’t Go Too Old

Both vendors benefit from newer kernels.

• Linux kernel 5.15+ is the practical baseline
• Ubuntu 22.04 LTS ships with 5.15 by default
• Newer HWE kernels improve:
  • GPU scheduling
  • Vulkan stability
  • Power management

If you’re on an older LTS kernel, upgrading can solve issues that look like “driver bugs.”

Steam, Proton, and the Runtime Layer

On Linux, games don’t talk to the GPU directly — they go through Proton, DXVK, and VKD3D.

For DLSS and FSR to behave correctly:

• Use Proton GE 9.0 or newer
• GE builds tend to ship newer DXVK and VKD3D versions
• DLSS and FSR toggles usually appear inside the game settings, not in Steam itself

For AMD users, FSR can also be enabled globally via Steam’s upscaling options — useful for older titles.

Useful Tools and Packages

These won’t magically increase FPS, but they make troubleshooting much easier.

NVIDIA extras

• nvidia-settings – verify driver status and clocks
• nvidia-modprobe – ensures device nodes exist
• vulkan-utils – sanity-check Vulkan support

AMD extras

• mesa-utils – OpenGL diagnostics
• vulkan-tools – Vulkan validation
• radeontop – real-time GPU usage monitoring

Quick Reference Table

Practical Tip

• NVIDIA users:
  Use the Graphics Drivers PPA (ppa:graphics-drivers/ppa) if you want the newest stable driver without waiting for Ubuntu updates.
• AMD users:
  For bleeding-edge Mesa, consider Ubuntu’s -proposed repository or a trusted Mesa PPA — newer Mesa often means real performance gains.

Takeaway

On Ubuntu, DLSS and FSR don’t fail because “Linux gaming is bad.”
They fail because one layer is outdated — driver, kernel, Mesa, or Proton.

Once those pieces line up, upscaling on Linux works shockingly well — and sometimes better than on Windows.

6. Setting Up a Gaming-Ready Ubuntu System

At this point, we know why upscaling exists and how DLSS and FSR work. Now comes the part that actually decides whether any of that matters: preparing Ubuntu so games can talk to your GPU properly.

This chapter isn’t about tweaking for maximum FPS. It’s about building a clean, modern baseline — drivers, Vulkan, Steam, and Proton — that won’t fight you later.

Installing the Latest NVIDIA Driver

On Ubuntu, NVIDIA works best when you let it do its thing — using the official proprietary driver.

Step 1: Enable the Graphics Drivers PPA

Ubuntu’s default repositories lag behind NVIDIA’s releases. The Graphics Drivers PPA bridges that gap without going fully bleeding-edge.

sudo add-apt-repository ppa:graphics-drivers/ppa
sudo apt update

Step 2: Install the driver

Replace 575 with the newest recommended version if a newer one is available.

bash no-line-numberssudo apt install nvidia-driver-575

This installs:

• The NVIDIA kernel module
• CUDA and OpenGL libraries
• Vulkan support required for Proton and DLSS

Step 3: Install Vulkan utilities

These tools don’t improve performance, but they’re invaluable for verification and debugging.

sudo apt install vulkan-utils

Step 4: Reboot

This is non-negotiable. The kernel module won’t load until you reboot.

sudo reboot

Verify after reboot

Once the system is back up, confirm everything is wired correctly:

nvidia-smi

You should see:

• Driver version
• GPU model
• Current memory usage

And confirm Vulkan support:

vulkaninfo | grep "VK_VERSION"

If Vulkan 1.3 shows up, you’re in good shape.

For more information about NVIDIA drivers installation and DirectX support on Ubuntu, check my previous posts:

• Mastering DirectX Gaming on Linux: A Complete Setup & Performance Guide
• The Ultimate Guide to vkBasalt on Ubuntu 24.04 (Noble Numbat)

Installing the Latest AMD / Mesa Stack

AMD’s Linux story is refreshingly simple.

Most of the driver stack already lives in the kernel and Mesa. You mainly want to make sure it’s up to date.

sudo apt update
sudo apt upgrade mesa-utils libgl1-mesa-dri libvulkan1 mesa-vulkan-drivers

This updates:

• OpenGL
• Vulkan (RADV)
• User-space GPU tooling

Optional: AMDGPU-PRO

For most gamers, you don’t need this.

sudo apt install amdgpu-pro

This is only useful for:

• Some older GPUs
• Very specific professional workloads

For Steam, Proton, and FSR, Mesa is usually the better choice.

Installing Steam

Steam is the delivery mechanism for almost everything that follows — Proton, DXVK, VKD3D, DLSS toggles, FSR support.

Ubuntu gives you three safe options. None of them are “wrong”; they just solve different problems.

Example: Installing the deb package

First, enable the multiverse repository:

sudo add-apt-repository multiverse
sudo apt update
sudo apt install steam

Once installed, log in and let Steam update itself fully before moving on.

Optional but Recommended: Proton-GE & DXVK

Steam’s built-in Proton is good — Proton-GE is usually better for new or demanding games.

Proton-GE is a community-maintained fork that ships:

• Newer DXVK
• Newer VKD3D-Proton
• Faster fixes for DLSS, FSR, and Vulkan regressions

Manual installation

mkdir -p ~/.steam/root/compatibilitytools.d
cd ~/.steam/root/compatibilitytools.d
wget -O proton-ge.tar.gz \  https://github.com/GloriousEggroll/proton-ge-custom/releases/download/GE-Proton9-35/GE-Proton9-35.tar.gztar -xf proton-ge.tar.gz
rm proton-ge.tar.gz

Restart Steam after installation.

Enable it in Steam

Go to:

Steam → Settings → Steam Play

• Enable Steam Play for all titles
• Select Proton GE 9.x from the drop-down

From this point on, games will automatically use the newer runtime unless overridden per-title.

More about GE-Proton in my previous post: Ultimate Guide to Installing Proton‑GE (Custom Proton) on Linux.

Where You Should Be Now

At this stage, your system has:

• A modern GPU driver
• Working Vulkan 1.3
• Steam installed and updated
• Proton ready for DLSS and FSR

Nothing fancy. Nothing experimental. Just a solid base that behaves predictably.

And that’s exactly what you want before starting to flip upscaling toggles.

7. Enabling DLSS / FSR in Steam

At this point, your system is ready. Drivers are loaded, Vulkan works, Steam and Proton are in place. Now it’s time to actually turn on upscaling.

The good news: on Linux, DLSS and FSR don’t require command-line tricks or config files. If a game supports them, the toggle appears right where you expect it.

Step 1: Tell Steam Which Proton to Use

Open Steam and go to your Library.

1. Right-click a game that supports DLSS or FSR
2. Select Properties
3. Open the Compatibility tab
4. Enable “Force the use of a specific Steam Play compatibility tool”
5. Choose Proton-GE (recommended) or the default Proton version

This ensures the game runs with a modern DXVK/VKD3D stack that exposes DLSS and FSR correctly.

Step 2: Launch the Game and Find the Upscaling Option

Start the game normally.

Once you’re in the graphics or video settings, look for:

• DLSS (on NVIDIA RTX GPUs), or
• FSR (on AMD and most other GPUs)

If the game supports it, you’ll usually see a dropdown with modes like:

• Ultra Quality
• Quality
• Balanced
• Performance
• (Sometimes) Fidelity or Auto

Select the mode that fits your target:

• Quality / Ultra Quality → best image
• Balanced → good compromise
• Performance → maximum FPS

Step 3: Apply and Restart if Needed

After changing the upscaling mode:

• Save the settings
• Restart the game if prompted

Some engines only initialize DLSS or FSR at launch, so a restart is normal and expected.

Linux-Specific Note: Wayland vs X11

On Linux, there’s one extra detail worth knowing.

Some games hide the DLSS or FSR UI toggle when running under Wayland, even though the hardware and drivers are fully capable. This is a game or engine limitation, not a driver failure.

If you don’t see the option:

• Close Steam
• Relaunch it under X11 instead of Wayland

For example:

steam --force-x11

or, on some systems:

steam --force-glx

Once running under X11, many games suddenly expose the full DLSS/FSR menu.

What “Working” Looks Like

When everything is set up correctly:

• DLSS / FSR appears in the game’s graphics menu
• FPS increases immediately after enabling it
• GPU usage often drops while image quality remains stable

If you see that, congratulations — your Linux gaming stack is doing exactly what it should.

Summary: What We’ve Learned So Far

By now, one thing should be very clear: modern games didn’t suddenly become “badly optimized.” They became ambitious.

4K resolution, ray tracing, dense worlds, cinematic lighting — all of that is expensive, and the real enemy turned out not to be shaders or AI or even ray tracing itself, but something far more basic: pixels.

Rendering and shading millions of them every frame is where GPUs burn most of their time. Upscaling exists not as a shortcut, but as a survival strategy — a way to stop wasting power on pixels the player can’t really see.

Once that clicks, everything else starts to make sense.

Two Roads to the Same Destination

We saw how the industry split into two philosophies:

• NVIDIA DLSS, which leans on AI, trained models, and dedicated Tensor Cores to reconstruct detail that was never rendered.
• AMD FSR, which relies on math, motion, and temporal accumulation — trading specialization for openness and broad compatibility.

Both aim to do the same thing:
render fewer pixels, keep the image looking native, and free GPU time for things that actually matter.

Neither approach is universally better. Each has strengths, weaknesses, and very real trade-offs.

The Mystery Removed

DLSS stopped being “AI magic” once we broke it into training and inference.
FSR stopped being “just sharpening” once we looked at its temporal logic.

We learned that:

• Temporal data is everything
• One frame lies, many frames tell the truth
• Frame generation improves smoothness, not simulation speed
• Bad motion vectors break even the smartest upscalers

In short: these systems are clever, but they’re not miracles.

Linux Was Never the Problem

On Ubuntu, DLSS and FSR don’t fail because Linux gaming is immature.
They fail because something is outdated — a driver, a kernel, Mesa, or Proton.

Once the stack is aligned:

• Modern kernel
• Correct GPU driver
• Vulkan working
• Steam + Proton configured properly

Upscaling works. Reliably. Sometimes shockingly well.

At this point, you’re no longer guessing — you’re in control.