# Why games don't render 4K at 4K

> 2026-11-08 · Graphics · rendering, temporal accumulation, optimization, machine learning
> https://hyna.dev/en/posts/why-games-dont-render-4k

Open the graphics settings of a recent PC game and there is always an unfamiliar menu next to the resolution. Under names like DLSS, FSR and XeSS sit steps called Quality, Balanced, Performance and Ultra Performance. Your monitor may be set to 4K, but with DLSS on Quality the game actually draws only 2560×1440. On Performance it draws 1920×1080, and on Ultra Performance 1280×720. Of the pixels on screen, the share actually drawn in that frame is about 44%, 25% and about 11% respectively.

Even so, the result is less blurry than you might expect. When the scene stands still, it is often hard to tell apart from native 4K. You can check this yourself in the lab below. The output is drawn small, at 384×216 pixels, and shown enlarged so that every pixel is visible.

> Interactive demo: A 384×216 output drawn at a smaller internal resolution (Quality 1.5x, Performance 2x, Ultra Performance 3x) and scaled up. Compare the low-res frame as is, a bilinear upscale, temporal accumulation (each frame samples a different point inside the pixel with a Halton jitter and pulls the previous frames in with motion vectors) and native, then switch off the jitter, the accumulation, the motion vectors, the 3×3 neighbourhood colour clamp, the thin-line lock or the disocclusion check one at a time to see what breaks. A loupe magnifies the pixels, and a moving ball shows the ghost trail. — https://hyna.dev/en/posts/why-games-dont-render-4k

You can move the loupe at the lower right by tapping the frame or with the arrow keys. Try these first.

- Switch the method back and forth between 'Bilinear' and 'Temporal'. The internal resolution is the same, but only 'Temporal' brings back the chain-link fence and the wires.
- With 'Move the ball' on, turn off 'Neighbourhood clamp' and 'Disocclusion check'. A long trail drags behind the ball.
- Turn off 'Thin-line lock' and the fence and wires, standing perfectly still, flicker and break apart.

Here is the short answer. **There isn't the budget to draw every 4K pixel within one frame, so each frame draws a few pixels in different places, and those are gathered back together over many frames.** Upscaling is less a technique for enlarging a blurry picture than a technique for gathering pixels drawn scattered across time, and the hardest part of it is deciding what to throw away from earlier frames. From DLSS 2 onwards, machine learning took over exactly that decision from hand-written rules.

## The budget is short, and one frame holds too little

Resolution grows by multiplying width and height. Taking 1080p as the baseline, 4K is exactly 4 times as many pixels.

![A figure comparing the pixel counts of 1080p, 1440p and 4K as cells drawn to scale. One cell is 640×360 pixels; 1080p is 2,073,600 pixels (1.00x), 1440p is 3,686,400 pixels (1.78x) and 4K is 8,294,400 pixels (4.00x). Below, filled cells show the share the engine actually draws for each DLSS mode at a 4K output: Quality (1.5x) is 2560×1440, about 44%; Performance (2.0x) is 1920×1080, 25%; Ultra Performance (3.0x) is 1280×720, about 11%. The empty cells are filled by the upscaler. A note says that at 60fps all of this has to be drawn within 16.7ms.](/images/posts/why-games-dont-render-4k/pixel-cost-en.svg)

Work that runs for every pixel on screen, such as pixel shaders, lighting, shadow sampling and post-processing, mostly grows in cost with the number of pixels. A game aiming for 60fps has to finish a frame in about 16.7ms. Take a scene that barely fit that budget at 1080p and draw it at 4K, and the per-pixel work alone is four times as much. Effects that cast a ray per pixel, like ray tracing, hurt even more.

So engines separate the output resolution from the per-pixel work.

Epic's [TSR documentation](https://dev.epicgames.com/documentation/unreal-engine/temporal-super-resolution-in-unreal-engine?lang=en-US) shows the difference with an example. Rendering at 1080p and upscaling to 4K cuts the GPU frame time from 57.50ms to 33.37ms, which the page describes as *reducing GPU frame time by half*. What upscaling buys, in the end, is this time.

The easiest approach is to take the picture drawn at a low resolution and scale it up as it is. The colour of each new spot is guessed from the pixels around it. Blending the four neighbouring pixels by distance is bilinear.

[FSR 1.0](https://gpuopen.com/fidelityfx-superresolution/), which AMD released in 2021, is a spatial upscaler of this kind.

![The same part of the lab scene compared three ways at the Performance 2× ratio. On the left, 'Low-res as is' shows the low-res pixels as big squares; the dense chain-link fence is smeared into a coarse X pattern, the thin wire into a single thick bar, and the horizontal bar of the window frame is missing. In the middle, 'Bilinear upscale' only blurs the edges of the squares; the fence pattern and the wire look the same as on the left. On the right, 'Native' shows the dense fence, the thin wires and the horizontal bar of the window frame.](/images/posts/why-games-dont-render-4k/spatial-upscale-en.webp)

But a spatial upscaler has a limit it cannot get past. A single 1080p frame holds only 2,073,600 pixels' worth of information. Whatever filter you use, it can only fill the gaps plausibly; it cannot know what was in the places that were never drawn. Wires and fences thinner than a pixel are drawn smeared or broken at a low resolution, and they stay that way when scaled up. That is the middle of the figure above. Bilinear only blurs the steps; the fine pattern of the fence and the thin wires don't come back. A sharpening filter can emphasise the edges that remain, but it can't revive lines that are gone.

We need more information.

## The information is in time

A game draws the same scene dozens of times a second. If the camera barely moves, consecutive frames are practically repeated photos of the same scene. The trouble is that each photo is taken at the same spot. Sampling only the one point at the pixel centre, you get the same information however many times you draw.

So the camera is nudged every frame by less than a pixel. This is called jitter. One frame samples the top left of a pixel, the next the bottom right, and so on, taking turns at different spots inside the same low-res pixel.

The figure below is the Performance mode case. One render pixel covers 2×2 output pixels, so gathering four frames that each sampled a different spot fills every cell at the output resolution.

![A grid in which 2×2 render pixels cover 4×4 output pixels, with the edge of an object running diagonally across it, in Performance mode. From frame 1 to frame 4 the sample position moves inside the pixel each time, through the 2nd to 5th values of the Halton 2,3 sequence: (0.25, 0.67), (0.75, 0.11), (0.13, 0.44), (0.63, 0.78). A render pixel whose sample hits the object takes the object colour as a whole. In the grid that gathers the four frames, each output cell is labelled with the number of the frame that sampled it, every cell is filled, and the edge shows up as steps at the output resolution. Below are the DLSS guide's jitter recommendations: at least 16 phases, 32 or more preferred, minimum count = 8 × ratio², 32 for Performance mode.](/images/posts/why-games-dont-render-4k/jitter-steps-en.svg)

The samples taken this way pile up in a buffer at the output resolution, usually called the history. Each frame, the newly drawn colour is blended into the existing history. In its simplest form it looks like this.

$$
H_t = (1 - \alpha)\,H_{t-1} + \alpha\,C_t
$$

`H` is the history, `C` the colour drawn this frame, and `α` how much to trust this frame. The smaller `α` is, the longer earlier frames linger and the more samples are blended in, so the result gets smoother. Roughly speaking, about `1/α` frames' worth of samples are mixed together. A large `α`, on the other hand, reacts quickly to new frames but gathers less.

![The same part of the lab scene at the Performance 2× ratio, scene paused, compared in four stages. '1 frame' is the stair-stepped low-res picture as is, with the wire broken into thick chunks. In '4 frames' the wires start to join up like dotted lines, but a checker pattern remains on the wall siding and the window frame. In '16 frames' the wires join up thin, the siding stripes come together evenly and the edges are smooth. On the far right, 'Native' is sharper, but steps remain visible along the roof edge and the wires.](/images/posts/why-games-dont-render-4k/jitter-accumulate-en.webp)

In the lab, with 'Move the ball' off, turn off 'Jitter' or 'Accumulate' one at a time and press 'Restart'. With jitter on and accumulation off, the image only shakes; with accumulation on and jitter off, it stacks the same samples and stays as it was. Only with both does the information grow.

There is a reason the 16-frame result in the figure looks smoother than native. The lab's 'Native' samples a single point per output pixel without any anti-aliasing, so steps remain along the roof edge and the wires. Accumulating with jitter blends samples from several spots inside each pixel, which wipes out those steps as well. Temporal accumulation fills in the missing resolution and does anti-aliasing at the same time, and that is why a temporal upscaler's output can look cleaner than native without anti-aliasing. In exchange, edges are a little less crisp than native.

Gathering several frames at the same resolution to wipe out the steps is TAA; gathering at a lower resolution to fill a larger history is temporal upscaling.

Still, the ratio has its limits. Below, the lab's paused scene was accumulated long enough and captured with only the ratio changed.

![The same part of the lab scene, paused and accumulated long enough, compared with only the ratio changed. In 'Quality 1.5×' and 'Performance 2×' the thin stripes of the wall siding, the window frame and the fence look almost the same. In 'Ultra Performance 3×' the siding stripes are gone, replaced by blotchy bands of uneven thickness, and the fence is blurrier too.](/images/posts/why-games-dont-render-4k/modes-en.webp)

'Quality 1.5×' and 'Performance 2×' are almost indistinguishable, but at 'Ultra Performance 3×' the wall siding turns into blotchy bands. The spacing of the siding stripes is finer than one low-res pixel (3 output pixels). Rather than blurring, the fine detail disappears and a pattern that was never there is left behind. In a mode that draws only a ninth of the output, some detail can't be recovered no matter how many frames you gather.

## What happens when things move

If the scene stood still, the story would end here. But games move. When the camera turns right, the previous frame's history should be shifted left on screen. Blend it in as it is and everything smears.

So engines also draw a motion vector for every pixel. It records where on screen the surface seen in this pixel was in the previous frame. The upscaler follows this vector to fetch colour from the history. This is called reprojection.

![Grids of frame N−1 and the current frame N side by side. A blue object has moved 3 cells to the right, and in the current frame the spot where the object was in the previous frame is outlined with a dotted line. A green pixel on the object follows the motion vector arrow to the same point in the previous frame and uses its record as is. A red pixel on the hatched background just revealed as the object moved away has zero motion, so it points to the same spot in the previous frame, but that spot holds only the object colour and there is no usable record. A note says that the afterimage left by blending in this wrong record is ghosting.](/images/posts/why-games-dont-render-4k/reprojection-en.svg)

With accurate motion vectors, accumulation carries on even in a moving scene. That is why NVIDIA's [DLSS Programming Guide](https://raw.githubusercontent.com/NVIDIA/DLSS/main/doc/DLSS_Programming_Guide_Release.pdf) states that *incorrect or poor precision motion vectors are the most common cause of visual artifacts*. This is why upscalers have to hook deep into the engine. From the finished image alone, this information can't be known.

Some cases aren't solved even with accurate motion vectors. Once an object passes, the background behind it is newly revealed. That background was hidden behind the object in the previous frame, so the history has no record of the spot. This is called disocclusion. The background didn't move, so its motion vector is 0, and following it fetches, wrongly, the colour of the object.

There are also things whose movement a single motion vector can't fully describe, like translucent smoke, reflections and shadows. A character reflected on the floor moves differently from the floor surface, but the motion vector of that pixel is the floor's.

Blend stale history into spots like these as it is, and a faint afterimage trails behind a moving object like a tail. This is called ghosting. You can see it right away in the lab by turning on 'Move the ball' and turning off 'Neighbourhood clamp' and 'Disocclusion check'. In the end, a temporal upscaler's job splits in two: trusting the history as long as possible to gather samples, and throwing away, in time, the history that shouldn't be trusted. The first is easy; the second is hard.

## From rules to a neural network

### Rules written by hand

Before machine learning, upscalers made this decision with rules people wrote. FSR 2.0, which AMD presented at GDC in 2022, is a good example. The [GDC slides](https://gpuopen.com/download/GDC_FidelityFX_Super_Resolution_2_0.pdf) lay out those rules step by step.

The first is the disocclusion mask. It compares the current frame's depth with the reprojected depth of the previous frame and doesn't trust the history where a spot looks newly revealed. The lab's 'Disocclusion check' imitates this in a simple way. If a spot was the ball in the previous frame and is background now, so the depth jumps sharply, it throws away that pixel's history.

The second is neighbourhood colour clamping. It looks at the colours of the 3×3 pixels around that pixel in this frame and finds the minimum and maximum. If the colour fetched from the history falls outside that range, it is treated as a colour that can't be anywhere near here right now and pushed back inside the range. Even if the history carries a bright colour from where a bright object passed, if everything around it is now dark, that record is clipped to the edge of the dark range. The lab's 'Neighbourhood clamp' imitates it in a simple way, taking the per-channel minimum and maximum of the RGB of the surrounding 3×3 low-res samples and clipping the history to them.

![A figure showing neighbourhood colour clamping when it is right and when it is wrong, one above the other. At the top is a spot an object has passed: the current frame's 3×3 is all dark blue, but the old record is bright yellow. On an axis running from dark to bright, the 3×3 colours form a box between min and max, and the bright record outside the box is clipped to the box edge, so the afterimage is thrown away (right). At the bottom is a bright line one pixel wide: this frame's samples miss the line, so the 3×3 is all dark, and even the bright record holding the real line is clipped to the box edge and the line flickers (wrong). At the very bottom, a note says this box clipping is the colour-based side of FSR 2's History rectification, that one-pixel-wide ridges are detected as thin features and locked, and that a lock not released in time becomes ghosting.](/images/posts/why-games-dont-render-4k/neighborhood-clamp-en.svg)

In a shader it looks roughly like this. This is an example simplified for explanation.

```hlsl
// Simplified example for explanation
float3 minC = 1e9;
float3 maxC = -1e9;
for (int y = -1; y <= 1; y++)
for (int x = -1; x <= 1; x++)
{
    float3 c = CurrentColor.Load(int3(pixel + int2(x, y), 0)).rgb;
    minC = min(minC, c);
    maxC = max(maxC, c);
}

float3 current = CurrentColor.Load(int3(pixel, 0)).rgb;
float3 history = HistoryColor.SampleLevel(LinearClamp, uv - motion, 0).rgb; // reproject
history = clamp(history, minC, maxC);                                      // clip to the neighbourhood range
float3 result = lerp(history, current, alpha);                             // accumulate
```

Below, in the lab with 'Move the ball' on, is the same moment as the ball passes in front of the fence, captured with only 'Neighbourhood clamp' changed. To isolate the effect of clamping, 'Disocclusion check' is off in both.

![Two captures of the same moment as a ball passes to the right in front of a chain-link fence. On the left, in 'Clamp off', the ball colour from earlier frames remains as a long smeared tail over the fence behind the ball. On the right, in 'Clamp on', the long tail is gone, but bright blotches are scattered where the ball passed and a short red streak remains right behind the ball.](/images/posts/why-games-dont-render-4k/ghosting-en.webp)

Clamping removes the long tail. The right side still has blotches and a short red streak, though.

Clamping comes at a price. This rule distrusts information that exists only in the history. But in upscaling, the information that exists only in the history is exactly what we set out to gather. A wire thinner than a pixel may be broken, or missing altogether, in this frame's low-res picture. Then the wire's colour isn't in the 3×3 neighbourhood, and the wire painstakingly gathered in the history is clipped away. The wire flickers or disappears. That is the bottom half of the neighbourhood clamping figure.

FSR 2 adds a third rule here, 'Thin features – Locking' in the slides. As the slide puts it, *We detect pixel wide ridges as thin features and lock them*: the history of spots that look like thin objects is locked. The lab's 'Thin-line lock' borrows this idea in a simplified form and differs from FSR 2's actual rule. Turn this switch off and you can watch the still fence and wires flicker and break apart.

But a lock is a rule too. The slides point out that a lock not released in time turns straight into ghosting. To avoid that risk, the lab doesn't lock where there is motion. The price is the bright blotches left on the right of the ghosting figure. A spot the ball has just passed has no lock, so clamping erases even the fence's thin lines, and the sky blue shows through the gaps. The short red streak right behind the ball is a spot where the 3×3 neighbourhood still contains the colour of the ball's edge, so clamping doesn't clip it. Lock generously and afterimages remain; lock sparingly and detail is erased. People are tuning by hand, one at a time, the criteria that separate history to keep from history to throw away.

These rules aren't expensive. The Quality mode cost listed in the slides is under 1.1ms on an RX 6800 XT at 4K output.

### The seat machine learning took

NVIDIA went another way. DLSS 1.0 enlarged low-res images with a neural network. But as the [DLSS 2.0 announcement](https://www.nvidia.com/en-us/geforce/news/nvidia-dlss-2-0-a-big-leap-in-ai-rendering/) itself says, 1.0 *required training the AI network for each new game*.

DLSS 2.0, in March 2020, changed the structure. Its inputs are *low resolution, aliased images* and *low resolution, motion vectors*, and it uses one *generalized network that works across games*. Look at the inputs and they are the same as the temporal upscaler we've just seen. What changed is the part that decides how to blend the history from those inputs.

![A figure comparing the two kinds of temporal upscaler. The same five inputs on the left, low-res colour, motion vectors, depth, exposure and the previous output, split into two branches. The upper branch is FSR 2's hand-written rules: build a disocclusion mask by comparing depth, clip the record to the 3×3 neighbourhood colour range, and lock thin objects. The lower branch is the trained network from DLSS 2 onwards, where weights learned from countless scenes decide what to throw away. Both branches produce a high-res output, which becomes the previous output for the next frame. Below, a note says DLSS 1 (Dec 2018) trained a new network for each game, while DLSS 2 (2020) uses one general network across many games, and that the inputs are the same; only the part that decides how far to trust the old record differs.](/images/posts/why-games-dont-render-4k/ml-pipeline-en.svg)

As I see it, this figure is the heart of the post. Machine learning didn't so much reinvent upscaling from scratch as replace one box in the pipeline, the box that decides how far to trust the history. Hand-written rules judge from a few clues people picked, like a 3×3 range or a depth difference. A neural network takes the same inputs and learns even which clues to look at, and how much.

After the hand-written FSR 2 and 3, AMD released the machine-learning-based [FSR 4](https://www.amd.com/en/newsroom/press-releases/2025-2-28-amd-unveils-next-generation-amd-rdna-4-architectu.html) with RDNA 4 in March 2025.

It isn't free. Neural networks cost more than rules, and the bigger the model, the more they cost. DLSS 4's transformer model was introduced with the line that it *packs four times the computations and twice the number of parameters, in a similar frame budget*. The execution times for Performance mode at 4K output in the DLSS guide show the difference clearly.

![A horizontal bar chart comparing the Super Resolution execution time for upscaling 1080p to 4K in DLSS Performance mode, by GPU and model. The models are, in order, CNN (models E/F), transformer (models J/K), model L and model M. RTX 5090: 0.40, 0.87, 1.37 and 1.05ms. RTX 4090: 0.53, 1.06, 1.67 and 1.39ms. RTX 3060: 2.08, 5.05, 13.81 and 11.10ms. RTX 2080 Ti: 1.30, 3.50, 10.60 and 7.51ms. A vertical line marks 16.7ms, one frame at 60fps, and the source is the NVIDIA DLSS Programming Guide 310.6.0 (31 Mar 2026).](/images/posts/why-games-dont-render-4k/runtime-cost-en.svg)

Run the same 4K output with model L on an RTX 3060 and it takes 13.81ms, most of the 16.7ms budget for 60fps. Machine-learning upscalers are a technology that assumes dedicated compute units like tensor cores, and where those units are weak, the upscaler spends again the time the upscaler saved.

## Where the saved budget goes

If upscaling is a technique for drawing fewer pixels, the next step was drawing fewer frames. Either way, what is left is closer to a question of where to spend the budget the upscaler saves. According to NVIDIA, in [Cyberpunk 2077's RT Overdrive mode](https://www.nvidia.com/en-us/geforce/news/cyberpunk-2077-ray-tracing-overdrive-update-launches-april-11/), the RTX 4090's 4K performance goes up 4.6 times to 103 FPS with DLSS 3, which combines upscaling and frame generation. Working backwards (103 ÷ 4.6), native is about 22 FPS. Lighting that casts rays per pixel is hard to choose at this resolution without upscaling.

According to [PCGamesN](https://www.pcgamesn.com/remnant-2/upscaling), Remnant 2's developer Gunfire Games said in 2023 that it *designed the game with upscaling in mind*, meaning DLSS, FSR and XeSS. If an upscaler is a tool that buys budget, putting that budget into the plan from the start is a natural next step. As I see it, the problem is less the technique itself than what happens when the upscaler stops being an option and becomes a minimum requirement: lower-end hardware has to drop to an even lower resolution. As we saw earlier, the smaller the input, the less information there is to gather, and the more visible flaws like ghosting become.

Spend the budget on image quality and upscaling buys a better picture; spend it on skipping optimisation and it shows the same picture blurrier.

## References

Original sources for the techniques

- [Brian Karis, High-Quality Temporal Supersampling, SIGGRAPH 2014 Advances in Real-Time Rendering](https://advances.realtimerendering.com/s2014/)
- [Jalal Eddine El Mansouri, Rendering Rainbow Six | Siege, GDC 2016](https://gdcvault.com/play/1022990/Rendering-Rainbow-Six-Siege)
- [Chao Dong, Chen Change Loy, Kaiming He, Xiaoou Tang, Image Super-Resolution Using Deep Convolutional Networks (arXiv, 31 Dec 2014)](https://arxiv.org/abs/1501.00092)
- [Lei Xiao et al., Neural Supersampling for Real-time Rendering, SIGGRAPH 2020](https://research.facebook.com/publications/neural-supersampling-for-real-time-rendering/)
- [Colin Riley, Thomas Arcila, FidelityFX Super Resolution 2.0, GDC 2022 (PDF)](https://gpuopen.com/download/GDC_FidelityFX_Super_Resolution_2_0.pdf)
- Edward Liu, DLSS 2.0 – Image Reconstruction for Real-time Rendering with Deep Learning, GTC 2020
- [Epic Games, Temporal Super Resolution in Unreal Engine](https://dev.epicgames.com/documentation/unreal-engine/temporal-super-resolution-in-unreal-engine?lang=en-US)

NVIDIA

- [DLSS Programming Guide 310.6.0 (31 Mar 2026, PDF)](https://raw.githubusercontent.com/NVIDIA/DLSS/main/doc/DLSS_Programming_Guide_Release.pdf)
- [DLSS beta and Game Ready driver for Final Fantasy XV (12 Dec 2018)](https://www.nvidia.com/en-gb/geforce/news/final-fantasy-xv-dlss-game-ready-driver/)
- [Ray tracing and DLSS in Battlefield V and Metro Exodus (13 Feb 2019)](https://www.nvidia.com/en-au/geforce/news/battlefield-v-metro-exodus-ray-tracing-dlss)
- [NVIDIA DLSS 2.0: A Big Leap In AI Rendering (23 Mar 2020)](https://www.nvidia.com/en-us/geforce/news/nvidia-dlss-2-0-a-big-leap-in-ai-rendering/)
- [DLSS 2.0 – Image Reconstruction for Real-time Rendering with Deep Learning, NVIDIA Developer Blog (21 Jul 2020)](https://developer.nvidia.com/blog/dlss-image-reconstruction-for-real-time-rendering-with-deep-learning)
- [DLSS 3 announcement (20 Sep 2022)](https://www.nvidia.com/en-us/geforce/news/dlss3-ai-powered-neural-graphics-innovations/)
- [Cyberpunk 2077 Ray Tracing: Overdrive update (Apr 2023)](https://www.nvidia.com/en-us/geforce/news/cyberpunk-2077-ray-tracing-overdrive-update-launches-april-11/)
- [DLSS 3.5 Ray Reconstruction (22 Aug 2023)](https://www.nvidia.com/en-us/geforce/news/nvidia-dlss-3-5-ray-reconstruction/)
- [DLSS 4 Multi Frame Generation announcement (Jan 2025)](https://www.nvidia.com/en-us/geforce/news/dlss4-multi-frame-generation-ai-innovations/)
- [DLSS 4 research page, NVIDIA Research](https://research.nvidia.com/labs/adlr/DLSS4/)
- [DLSS 4.5 announcement (6 Jan 2026)](https://www.nvidia.com/en-us/geforce/news/dlss-4-5-dynamic-multi-frame-gen-6x-2nd-gen-transformer-super-res/)
- [DLSS 4.5 Dynamic Multi Frame Generation and 6X mode released (31 Mar 2026)](https://www.nvidia.com/en-us/geforce/news/dlss-4-5-dynamic-multi-frame-generation-6x-mode-released/)
- [DLSS 5 3D-Guided Neural Rendering released (1 Sep 2026)](https://www.nvidia.com/en-us/geforce/news/dlss-5-3d-guided-neural-rendering/)
- [A faster AI model for DLSS 5 (13 Oct 2026)](https://www.nvidia.com/en-us/geforce/news/dlss-5-faster-ai-model-hogwarts-legacy-rtx-spark-laptops/)
- [DLSS 5 in Hogwarts Legacy and War Thunder (5 Nov 2026)](https://www.nvidia.com/en-us/geforce/news/hogwarts-legacy-war-thunder-dlss-5-3d-guided-neural-rendering/)

AMD

- [FidelityFX Super Resolution 1.0, GPUOpen](https://gpuopen.com/fidelityfx-superresolution/)
- [FSR source released (15 Jul 2021)](https://gpuopen.com/fsr-source-available/)
- [FidelityFX Super Resolution 2, GPUOpen](https://gpuopen.com/fidelityfx-superresolution-2/)
- [FSR 3 in games: technical details (29 Sep 2023)](https://gpuopen.com/news/fsr3-in-games-technical-details/)
- [AMD unveils RDNA 4 and FSR 4 (28 Feb 2025)](https://www.amd.com/en/newsroom/press-releases/2025-2-28-amd-unveils-next-generation-amd-rdna-4-architectu.html)
- [AMD FSR Redstone, FSR SDK 2.1 (10 Dec 2025)](https://gpuopen.com/learn/welcome-amd-fsr-redstone-amd-fsr-sdk-21-available/)
- [AMD FSR SDK 2.3 (24 Jun 2026)](https://gpuopen.com/learn/amd-fsr-sdk-2-3-blog/)
- [AMD FSR SDK 2.4 (28 Oct 2026)](https://gpuopen.com/learn/amd-fsr-sdk-2-4-rx-6000-ryzen-apus/)

Other upscalers and platforms

- [Sony, PlayStation 4 Pro announcement (7 Sep 2016)](https://sony.mediaroom.com/2016-09-07-Sony-Interactive-Entertainment-Unveils-PlayStation-4-Pro-Delivering-Enhanced-PS4-Experience)
- [Engadget, Mark Cerny interview on the PS4 Pro (20 Oct 2016)](https://www.engadget.com/2016-10-20-ps4-pro-mark-cerny-interview-hardware.html)
- [Intel Arc graphics release (Oct 2022)](https://game.intel.com/stories/intel-arc-graphics-release/)
- [Intel XeSS SDK, GitHub](https://github.com/intel/xess)
- [Apple, MetalFX upscaling, WWDC 2022 session 10103](https://developer.apple.com/videos/play/wwdc2022/10103/)
- [PlayStation 5 Pro announcement (10 Sep 2024)](https://blog.playstation.com/2024/09/10/welcome-playstation-5-pro-the-most-visually-impressive-way-to-play-games-on-playstation/)
- [Upgraded PSSR announced (27 Feb 2026)](https://blog.playstation.com/2026/02/27/upgraded-pssr-upscaler-is-coming-to-ps5-pro/)
- [Upgraded PSSR in 007 First Light on PS5 Pro (19 May 2026)](https://blog.playstation.com/2026/05/19/007-first-light-on-ps5-pro-upgraded-pssr-upscaling-details/)
- [Microsoft, DirectSR preview (29 May 2024)](https://devblogs.microsoft.com/directx/directsr-preview/)
- [Microsoft, Auto SR (6 Jun 2024)](https://devblogs.microsoft.com/directx/autosr/)

Articles

- [PC Gamer, on the RTX 5070 versus RTX 4090 performance claim (Jan 2025)](https://www.pcgamer.com/hardware/graphics-cards/nvidias-new-rtx-5070-will-deliver-rtx-4090-performance-at-usd549-when-it-launches-in-february)
- [PCGamesN, Remnant 2 and upscaling (28 Jul 2023)](https://www.pcgamesn.com/remnant-2/upscaling)
- [Euronews, gamers react to the DLSS 5 reveal (19 Mar 2026)](https://euronews.com/next/2026/03/19/yassified-graphics-and-uncanny-faces-gamers-turn-nvidias-dlss-5-reveal-into-a-meme-storm)

GeekNews (Korean)

- [OpenDLSS: reimplementing NVIDIA's DLSS 5 neural rendering network in Vulkan (Korean, 1 Oct 2026)](https://news.hada.io/topic?id=34604)
- [AMD and Sony's PS6 chipset aims to restructure the current graphics pipeline (Korean, 12 Oct 2025)](https://news.hada.io/topic?id=23602)
- [NVIDIA won, and we all lost (Korean, 5 Jul 2025)](https://news.hada.io/topic?id=21829)
