DLSS vs FSR vs XeSS: Upscaling Technologies Explained

A few years ago, the question "what resolution are you playing at?" had a simple answer: whatever your monitor's native resolution was. Today, the answer is more complicated. Most modern games offer some form of upscaling — rendering the frame at a lower resolution and reconstructing a higher-resolution image — and the choice of upscaler can have a bigger effect on your visuals and frame rate than the resolution itself.

The three major upscaling technologies are NVIDIA DLSS, AMD FSR, and Intel XeSS. They share the same goal but take different approaches, with real consequences for image quality, performance, and hardware compatibility. This guide explains how each one works, how they compare, and how to choose.

Why Upscaling Exists

Rendering a full frame at 4K resolution is enormously expensive for the GPU. Every pixel requires lighting calculations, texture sampling, and post-processing. Cut the resolution in half, and the GPU has to do roughly a quarter of the pixel work — which translates directly to higher FPS.

The problem is that a lower-resolution image looks soft and pixelated when stretched to fill a 4K screen. Upscaling technologies solve this by intelligently reconstructing the missing detail. Done well, the upscaled image can look nearly indistinguishable from a native render, while delivering much higher frame rates.

The appeal is obvious: better performance without a proportional loss in visual quality. This is especially valuable when combined with demanding features like ray tracing, which would otherwise make high resolutions unplayable.

NVIDIA DLSS

DLSS (Deep Learning Super Sampling) was the first major AI-based upscaler and remains the most mature. It works by rendering the frame at a lower resolution and then using a neural network, trained on millions of high-resolution image pairs, to reconstruct the full-resolution output.

How it works:

• The neural network runs on NVIDIA's Tensor Cores, dedicated hardware present on all RTX cards
• It uses motion vectors from previous frames to inform reconstruction (temporal upscaling)
• The network has been trained to recognize what high-resolution detail should look like for a given low-resolution input

Strengths:

• Excellent image quality, especially in motion, thanks to well-trained models and robust temporal reconstruction
• Consistent performance across a wide range of games, with per-game training in earlier versions and generalized models in DLSS 3 and beyond
• DLSS Frame Generation can synthesize entirely new frames between rendered ones, dramatically increasing perceived smoothness in GPU-bound scenarios

Limitations:

• Requires an NVIDIA RTX GPU (the Tensor Cores are mandatory)
• Frame Generation adds a small amount of input lag, which some competitive players find objectionable
• Image quality can degrade in scenes with lots of fine detail or rapid motion, though this has improved significantly in recent versions

DLSS is generally considered the highest-quality upscaler available, but only if you own compatible hardware.

AMD FSR

FSR (FidelityFX Super Resolution) is AMD's answer to DLSS. The most important difference is that FSR does not require dedicated AI hardware — it runs on standard shader cores and works on virtually any modern GPU, including NVIDIA and Intel cards.

How it works:

• FSR 1 used purely spatial upscaling (reconstructing detail from a single frame). It was fast but lower quality.
• FSR 2 introduced temporal reconstruction, using motion vectors like DLSS. Quality jumped dramatically.
• FSR 3 added Frame Generation, similar in concept to DLSS 3.
• FSR 4 introduced a machine-learning model for reconstruction, but it is currently limited to AMD's RDNA 4 GPUs.

Strengths:

• Runs on nearly every GPU, including older and competitor hardware
• Open and free for developers to integrate, which has led to broad adoption
• Quality is competitive with DLSS in many games, especially at higher upscaling ratios

Limitations:

• Temporal reconstruction can produce shimmering or ghosting in motion, particularly on fine geometry like fences and hair
• Image quality is generally slightly below DLSS at equivalent upscaling ratios, though the gap has narrowed
• FSR 4's ML model is hardware-limited, reducing the open-hardware advantage for the latest version

For gamers without an RTX card, FSR is often the best upscaling option available.

Intel XeSS

XeSS (Xe Super Sampling) is Intel's upscaler, introduced alongside the Arc GPU lineup. It occupies a middle ground between DLSS and FSR in both technology and positioning.

How it works:

• On Intel Arc GPUs and any hardware with DP4a instruction support, XeSS uses a neural network similar to DLSS
• On older hardware without DP4a, it falls back to a lower-precision path that still works but with reduced quality

Strengths:

• Runs on a wide range of hardware, not just Intel GPUs
• Quality is competitive with DLSS in well-implemented titles
• Broadens the AI-upscaling ecosystem beyond NVIDIA

Limitations:

• Less widely supported than DLSS or FSR, since adoption depends on Intel's market share
• Quality varies more between games than DLSS, due to less mature integration tooling
• The fallback path on non-DP4a hardware is noticeably lower quality

XeSS is a solid option when available, but it is currently the least common of the three.

Quality and Performance Comparison

At a high level, the ranking for image quality is roughly:

1. DLSS — consistently the best, especially in motion
2. XeSS — very close to DLSS in well-optimized games
3. FSR — slightly behind on fine detail and motion stability, but close

For performance (FPS gain), all three deliver similar benefits when set to the same upscaling ratio. The choice of technology matters less than the ratio: "Quality" mode (which upscales from a relatively high internal resolution) looks good on all three, while "Performance" mode (which upscales from a much lower internal resolution) shows the quality differences more clearly.

Frame Generation is a separate consideration. DLSS Frame Generation and FSR Frame Generation both produce large FPS increases, but they add input lag and can produce visual artifacts in fast motion. They are best suited for single-player games where smoothness matters more than responsiveness.

How to Choose

Use this framework:

1. Check what your hardware supports. If you have an RTX card, DLSS is usually the best choice. If you have an AMD or Intel card, use FSR or XeSS respectively.
2. Use the highest quality mode your frame rate allows. Quality mode looks better than Performance mode; only drop to Performance if you need the extra FPS.
3. Test before and after. Run an FPS test to establish your baseline, enable the upscaler, and measure the gain. Read the on-screen image critically — if shimmering or softness bothers you, the trade-off may not be worth it.
4. Pair with ray tracing carefully. Upscaling is what makes ray tracing playable at high resolutions, but the combination can still be demanding. Tune both together.

The Future of Upscaling

Upscaling is no longer a niche feature. Most major game releases now ship with at least one upscaler built in, and many include all three. Engine-level solutions like Unreal Engine's TSR are also improving rapidly, offering high-quality temporal upscaling without vendor-specific hardware.

As ML-based reconstruction becomes more sophisticated and hardware becomes more capable, the gap between native rendering and upscaled rendering will continue to narrow. In a few years, "playing at native resolution" may be an outdated concept — nearly every game will render internally at a lower resolution and reconstruct to the display, because the performance benefit is too large to ignore.

Final Thoughts

DLSS, FSR, and XeSS are not competing marketing claims. They are genuinely useful technologies that let you trade a small amount of image quality for a large gain in frame rate. The right choice depends mostly on your hardware, but all three are worth using when the alternative is an unplayable frame rate.

Establish your baseline FPS, enable the upscaler appropriate for your hardware, and tune the quality mode until you find the combination of performance and image quality that works for you. The result is usually a dramatically smoother game with visuals that are hard to distinguish from native rendering.