We may be living in the post-resolution age, but there are still many heated debates about native resolution gaming on modern 4K (or greater) displays. Does rendering at native resolution actually matter? Perhaps it's time to let it go.

What Is "Native" Resolution?

Flat-panel displays, whether LED, OLED, or plasma, have a grid of physical pixels. When an image has at least as many pixels worth of data as the screen can physically display, you're getting the maximum sharpness and clarity possible on that screen. This is different from older CRT (Cathode Ray Tube) displays, which use a charged beam to draw an image on the phosphorescent layer on the back of the screen. Images on a CRT look good at any resolution because the beam can simply draw the number of pixels It needs, up to a certain limit at least.

On flat-panel screens, when the number of pixels in your content (for example, a game, photograph, or video) is less than the native resolution of the display, the image has to be "scaled." A 4K display has four times the number of pixels compared to a Full HD display, so to scale a Full HD image to 4K you can use four 4K pixels to represent one Full HD pixel. This works quite well and in general, the picture will still look good, just not as sharp as a native image.

The trouble starts when lower resolution images don't divide so neatly into the native pixel grid of the display. This is where we move into the realm of estimating pixel values. When we have a perfectly divisible scaling factor, the groups of pixels that represent one low res pixel all have the same color and brightness value as the original. With an imperfect scaling factor, some pixels have to represent the color and brightness values of different original pixels. There are various approaches to solving this, such as averaging the values of the split pixels. Sadly, this generally makes for an ugly image.

Native Resolution and Gaming Performance

Conventional wisdom has been to only use native resolution content or, at the very least, content that scales perfectly to the higher resolution. For gaming, this effectively means that the game has to render at the native resolution of the display for the best image quality. Unfortunately, this puts a heavier load on the GPU (Graphics Processing Unit) which takes longer to draw each frame of the game, since there are more pixels. If the additional burden is too much, the GPU may not be able to draw frames fast enough to make the game smooth and playable.

If we can't lower the resolution, then the only way to reduce the load on the GPU and increase the framerate is to dial back other visual features. For example, you might lower the quality of lighting, texture detail, draw distance, etc. In effect, you are forced to trade visual quality for visual clarity. If you choose to simply accept the lower frame rate, you're then trading motion clarity and responsiveness for better quality in each frame. There's no correct answer here since different games and different players assign different values to these, but there's a tradeoff no matter what.

What about falling back on perfect scaling? While this does deal with the worst scaling artifacts, it offers the opposite problem. For example, the next lower resolution that scales perfectly with 3840x2160 (UHD 4K) is 1920x1080 (Full HD). As we mentioned before, that's four times fewer pixels. On modern hardware, there's a good chance you won't be using all of your GPU power at this resolution.

You can use that extra headroom to increase other visual quality settings or you can take advantage of faster frame rates, especially if you have a display capable of displaying them thanks to fast refresh rate support.

Neither of these solutions is optimal, and there's a vast gulf between these two points where you could strike the perfect balance of resolution, frame rate, and rendering quality. if only that arbitrary resolution would look good. For most of flat-panel history, it didn't. Today things are very different.

Output Resolution vs. Rendering Resolution

The first concept that helps us understand why non-native resolutions don't look horrible on flat-panel displays is that of rendering resolution and output resolution. The rendering resolution is the image resolution that the game renders internally. The output resolution is the resolution of the frame that's actually sent to the display.

For example, if you have a PlayStation 5 connected to a 4K display, the display will report that it's receiving a 4K signal. That's irrespective of what the game's actual internal resolution is. Why go through all this effort into fooling the display into thinking it's getting a 4K picture? In short, it's because it prevents the display's built-in scaler from kicking in and lets the game developer have total control over how their image is scaled from the internal resolution to the native resolution of the screen. This is the secret of why native resolution doesn't really matter anymore.

We Have the Technology

Game developers now have an entire arsenal of scaling techniques at their disposal. We couldn't cover them all here, but there are a few important ones worth knowing about.

First of all, if the game has control over the scaling process, it can make sure to calculate the best pixel values in the final image, derived from the internal render. Since the game developer has complete control of the scaling process, they can fine-tune their scaler to reproduce the desired look for their specific game.

Using a custom, internal scaling technique also makes Dynamic Resolution Scaling (DRS) possible This is where each frame is rendered at the highest resolution possible while maintaining a specific target framerate. The end result is a little like streaming video, where the quality dynamically varies according to available bandwidth. Except, DRS is much much more finely-grained and reactive. This ends up being a pretty great solution, because your game looks crispest when there's not much going on, and has resolution dips in the heat of the action when the player is least likely to notice.

There are also advanced techniques to "reconstruct" lower resolution images into higher resolution versions. Image reconstruction methods are basically intelligent scaling methods that don't just multiply a number by two. For example, TAA (Temporal Anti-Aliasing) uses information from previous frames, to sharpen the current frame. DLSS (Deep Learning Super Sampling) uses machine learning algorithms to upscale lower resolution images with special hardware found on Nvidia RTX graphics cards. Often with results that are almost indistinguishable from native 4K.

Checkerboard rendering, commonly used on Sony's PS4 Pro console, only renders 50% of each 4K frame in a sparse grid of pixels. The gaps in the sparse grid are then derived from the pixels that are there and, in some cases, previous frames. The pixel grid can also be shifted in a per-frame alternating pattern, improving the reconstruction quality. Although this method can be used on any hardware, the PS4 Pro actually has special hardware to improve the performance and quality of checkerboard rendering, which is why many developers choose to use it there.

This is just the tip of the iceberg, but all of these methods are part of the reason rendering at native resolutions isn't an issue anymore. The game developers have exact control of the scaling process and what the final image will look like at native resolution output.

Perception Is Everything

The final reason we don't think native resolution rendering is something worth losing sleep over as a target is that resolution is only a small part of the image quality puzzle. Ultimately, what really matters is the quality of the image you perceive, not an arbitrary pixel count.

For example, a 4K image of a stick figure drawn in pencil is certainly less pleasing to the eye than a beautiful renaissance painting at 1080p. Color, contrast, smoothness, lighting quality, art direction, and texture detail are all examples of image quality factors in games that are part of the overall quality you perceive. Evaluate a game's visuals holistically and in a way that reflects how it's intended to be played. Not by way of a magnifying glass to count the individual pixels dancing on the head of a pin.