Nvdia and AMD both offer tools to select the optimal graphics settings for the games you own, and both do a fine job balancing quality and performance. They really work pretty well, but I just like doing things myself. It's the PC gamer way, right? We tinker on our own terms.
If you're new to graphics tuning, this guide will explain the major settings you need to know about, and without getting too technical, what they're doing. Understanding how it all works can help with troubleshooting, setting up the most gorgeous screenshots possible, or playing with tools like Durante's GeDoSaTo.
We start with the fundamental concepts on this page. For the sections on anti-aliasing, anisotropic filtering, and post-processing that follow, I consulted with Nicholas Vining, Gaslamp Games' technical director and lead programmer, as well as Cryptic Seadesigner/programmer Alex Austin. I also received input from Nvidia regarding my explanation of texture filtering. Keep in mind that graphics rendering is much more complex than presented here. I'm a technology enthusiast translating these systems into simple analogies, not an engineer writing a technical paper, so I'm leaving out major details of actual implementation.
A pixel is the most basic unit of a digital image—a tiny dot of color—and resolution is the number of pixel columns and pixel rows in an image or on your display. The most common display resolutions today are: 1280x720 (720p), 1920x1080 (1080p), 2560x1440 (1440p), and 3840 x 2160 (4K or ‘ultra-HD’). Those are 16x9 resolutions—if you have a display with a 16x10 aspect ratio, they’ll be slightly different: 1920×1200, 2560x1600, and so on while newer ultrawide displays can be 2560x1080, 3440x1440, etc.
If you think of a game as a series of animation cells—still images representing single moments in time—the FPS is the number of images generated each second. It's not the same as the refresh rate, which is the number of times your display updates per second, and is measured in hertz (Hz). 1 Hz is one cycle per second, so the two measurements are easy to compare: a 60 Hz monitor updates 60 times per second, and a game running at 60 FPS should feed it new frames at the same rate.
The more work you make your graphics card do to render bigger, prettier frames, the lower your FPS will be. If the framerate is too low, frames will be repeated and it will become uncomfortable to view—an ugly, stuttering world. Competitive players seek out high framerates in an effort to reduce input lag, but at the expense of screen tearing (more on that below), while high-resolution early adopters may be satisfied with playable framerates at 1440p or 4K. The most common goal today is 1080p/60 fps, though 1440p, 4K, and framerates above 120 are also desirable. A high refresh rate monitor (120-144 Hz) with the framerate to match is ideal.
Because most games don't have a built-in benchmarking tool, the most important tool in your tweaking box is software that displays the current framerate. ShadowPlay or FRAPS work fine in many games, or you can use utilities like Riva Tuner for more options on what to show. (Note that some newer DX12 and Vulkan games may not work with many framerate overlay tools that worked fine with earlier DX11 games.)
Some games offer a 'rendering resolution' setting. This setting lets you keep the display resolution the same (your display's native 1080p or 1440p, for instance) while adjusting the resolution the game is being rendered at (but not the UI). If the rendering resolution is lower than your display resolution, it will be upscaledto fit your display resolution—and, as expected, look like garbage, because the image is being blown up.
If you render the game at a higher resolution than your display resolution, which is an option in Shadow of Mordor, the image will be downsampled (or 'downscaled') and will look much better at a high cost to performance.
Because it determines the number of pixels your GPU needs to render, resolution has the greatest effect on performance. This is why console games which run at 1080p often upscale from a lower rendering resolution—that way, they can handle fancy graphics effects while maintaining a smooth framerate.
I benchmarked the Shadow of Mordor resolutions above (all settings on maximum) on the Large Pixel Collider (specs here—two of its four GTX Titans active) to show how much resolution affects performance.
Shadow of Mordor resolution benchmarks (2x Nvidia GTX Titan SLI)
| Avg. FPS | Max FPS | Min FPS | |
|---|---|---|---|
| 1980x720 (1/2 resolution) | 102 | 338 | 30 |
| 2560x1440 (native resolution) | 51 | 189 | 23 |
| 5120x2880 (2x resolution) | 16 | 26 | 10 |
When a display's refresh cycle is out of sync with the game's rendering cycle, the screen can refresh during a swap between finished frames. The effect is a ‘break’ called screen tearing, where we're seeing portions of two or more frames at the same time. It is also our number one enemy after low framerate.
One solution to screen tearing is vertical sync (vsync). It’s usually an option in the graphics settings, and it prevents the game from messing with the display until it completes its refresh cycle, so that the frame swap doesn't occur in the middle of the display updating its pixels. Unfortunately, vsync causes its own problems, one being that it contributes to input lag when the game is running at a higher framerate than the display's refresh rate (this AnandTech article explains it in technical terms).
The other big problem with vsync happens when the framerate drops below the refresh rate. If the framerate exceeds the refresh rate, vsync locks it to the refresh rate: 60FPS on a 60Hz display. That's fine, but if the framerate drops below the refresh rate, vsync forces it to jump to another synchronized value: 30 FPS, for instance. If the framerate fluctuates above and below the refresh rate often, it causes stuttering. We'd much rather allow the framerate to sit at 59 than punch it down to 30.
To solve this, Nvidia's Adaptive Vertical Synchronization disables vsync anytime your framerate dips below the refresh rate. It can be enabled in the Nvidia control panel and I recommend it if you're using vsync.
New technology is starting to solve this big mess. The problem all stems from one thing: displays have a fixed refresh rate. But if the display's refresh rate could change with the framerate, we could eliminate screen tearing and eliminate the stuttering and input lag problems of vsync at the same time. Of course, you need a compatible video card and display for this to work, and there are two technologies that do that: Nvidia has branded its technology G-sync, while AMD's efforts are called Project FreeSync.
Initially, Nvidia cards only supported G-sync monitors, but GeForce cards will now work with some FreeSync monitors. However, only Nvidia GPUs can use variable refresh rates on G-Sync displays. Check our monitor buying guide for advice.
If you draw a diagonal line with square pixels, their hard edges create a jagged ‘staircase’ effect. This ugliness (among other artifacts) is called aliasing. If resolutions were much higher, it wouldn’t be a problem, but until display technology advances, we have to compensate with anti-aliasing.
There are many techniques for anti-aliasing, but supersampling (SSAA) is useful to explain the process. It works by rendering frames at a higher resolution than the display resolution, then squeezing them back down to size. On the previous page, you can see the anti-aliasing effect of downsampling Shadow of Mordor from 5120x2880 to 1440p.
Consider a pixel on a tile roof. It’s orange, and next to it is a pixel representing a cloudy sky, which is light and blueish. Next to each other, they create a hard, jagged transition from roof to sky. But if you render the scene at four times the resolution, that one orange roof pixel becomes four pixels. Some of those pixels are sky-colored and some are roof-colored. If we take the average of all four values, we get something in between. Do that to the whole scene and the transitions become softer.
That's the gist, at least, and while it looks very good, supersampling is extremely computationally expensive. You’re rendering each frame at a resolution two or more times higher than the one you’re playing at—even with our multiple high-end graphics cards, trying to run supersampling with a display resolution of 2560x1440 isn't practical. That’s why there are so many more efficient alternatives:
Multisampling (MSAA): More efficient than supersampling, but still demanding. This is typically the standard, baseline option in older games, and it's explained very simply in the video below.
Coverage Sampling (CSAA): Nvidia’s more efficient version of MSAA. You won't see this much anymore.
Custom-filter (CFAA): AMD’s more efficient version of MSAA. You also won't see this much anymore.
Fast Approximate (FXAA): Rather than analyzing the 3D models (i.e. MSAA, which looks at pixels on the edges of polygons), FXAA is a post-processing filter, meaning it applies to the whole scene after it has been rendered, and it's very efficient. It also catches edges inside textures which MSAA misses. This is the default in many modern games because it has very little overhead, though it tends to miss a lot of jaggies.
Morphological (MLAA): Available with AMD cards, MLAA also skips the rendering stage and processes the frame, seeking out aliasing and smoothing it. As Nicholas Vining explains: "Morphological anti-aliasing looks at the morphology (read: the patterns) of the jaggies on the edges; for each set of jaggies, it computes a way of removing the aliasing which is pleasing to the eye. It does this by breaking down edges and jaggies into little sets of morphological operators, like Tetris blocks, and then uses a special type of blending for each Tetris block." MLAA can be enabled in the Catalyst control panel.
Enhanced Subpixel Morphological (SMAA): Another post-processing method, described as combining MLAA with MSAA and SSAA strategies. You can apply it with SweetFX, and many modern games natively support this.
Temporal (TAA or TXAA): TXAA was initially supported on Nvidia's Kepler and later GPUs, but more general forms of temporal anti-aliasing are now available and are typically just labeled TAA. TAA compares the previous frame with the current frame to look for edges and help remove jaggies. This is done through a variety of filters and can help reduce the 'crawling' motion on edges, which looks a bit like marching ants. It cannot, however, remove actual ants from inside your display. You should probably just throw that display out.
As Vining again explains: "The notion here is that we expect frames to look a lot like each other from frame to frame; the user doesn't move that much. Therefore, where things haven't moved that much, we can get extra data from the previous frame and use this to augment the information we have available to anti-alias with."
Multi-Frame (MFAA): Introduced with Nvidia's Maxwell GPUs. Whereas MSAA samples in set patterns, MFAA allows for programmable sample patterns. Nvidia does a good job of explaining MSAA and MFAA simply in the video below.
Deep Learning Super-Sampling (DLSS): Nvidia's latest, available on certain games using new GeForce RTX cards. According to Nvidia, "DLSS leverages a deep neural network to extract multidimensional features of the rendered scene and intelligently combine details from multiple frames to construct a high-quality final image. DLSS uses fewer input samples than traditional techniques such as TAA, while avoiding the algorithmic difficulties such techniques face with transparency and other complex scene elements."
In other words, it's better and more efficient at doing the things Temporal AA does, or at least it's supposed to look better once it has been properly trained for a specific game. When it's not properly trained, it can cause a lot of blurriness.
Anti-aliasing settings almost always include a series of values: 2x, 4x, 8x, and so on. The numbers refer to the number of color samples being taken, and in general, the higher the number, the more accurate (and computationally expensive) the anti-aliasing will be.
Then there's the special case of the 'Q.' CSAA attempts to achieve a quality better than or equal to MSAA with fewer color samples, so 8xCSAA actually only takes four color samples. The other four are coverage samples, explained here. 8QxCSAA, however, bumps the number of color samples back up to eight for increased accuracy. You'll rarely encounter CSAA these days, so let's call that a fun fact.
I used Batman: Arkham City's benchmarking tool to test a few older anti-aliasing methods: MSAA, FXAA, and TXAA. The results show, as expected, that FXAA is the least resource intensive, while MSAA and TXAA cause a significant drop in average framerate over no anti-aliasing.
Batman: Arkham City AA benchmarks (2x Nvidia GTX Titan SLI)
| Avg. FPS | Max FPS | Min FPS | |
| No AA | 161 | 224 | 57 |
| MSAA 8x | 84 | 166 | 44 |
| FXAA (high) | 154 | 204 | 60 |
| TXAA (high) | 98 | 118 | 67 |
Some more modern games don't give you much of a choice. Battlefield 5, for example, offers me two TAA quality options. Assassin's Creed Odyssey offers low, medium, high, and adaptive options.
It depends on your GPU, your preference, and what kind of performance you're after. If framerate is an issue, however, the choice is usually obvious: FXAA is very efficient. If you've got an RTX card, and the game you're playing supports it, give DLSS a try—you paid for it, and it's top of the line. In older games, you'll probably have to do a bit of testing to get the combination of look and performance you want. If you have the hardware to do it, you can also try supersampling instead of using the built-in options, which usually works. Overriding settings in other ways, however, isn't a sure thing.
Theoretically, in-game graphics options shouldn’t matter. You can just open up the Nvidia or AMD control panel and override their settings. Unfortunately, that’s not really the case. While you can set overrides for any game, I've had little success getting them to work.
"Very often when overrides don't work it's due to deferred rendering," says Vining, "which just breaks a lot of common anti-aliasing techniques." Alex Austin also notes that some of his techniques don't work with override settings. So, it's just a matter of testing. Turn off all AA in the in-game options, set the override in your control panel, and hop back in: it should be apparent whether or not it took effect.
I've found that AMD's MLAA works the most when enabled in the control panel. It's important to note, however, that it's a post-processing filter and applies to everything in the scene. That means it can take care of hard edges within textures, which can be good, but comes with the side-effect that it may also go after desirable edges, such as in text. Notice how it slightly smooths the text in the BioShock Infinite menu, and even goes so far as to smooth my FRAPS FPS overlay.
Supersampling using Nvidia's DSR or AMD's Virtual Super Resolution, however, is more reliable. In the AMD settings, you simply have to turn Virtual Super Resolution on in the Display tab. If you have an Nvidia card, head to the 'Manage 3D settings' section of the Nvidia Control Panel, where you can select DSR factors up to 4x. Do one of those things, and in your games' options you should be able to select resolutions higher than your display resolution. Do so, and the game will run at the selected resolution and be downsampled to your display resolution—very taxing, but it looks nice. This can cause UI problems in some games, or just not work at all.
Texture filtering deals with how a texture—a 2D image (and other data)—is displayed on a 3D model. A pixel on a 3D model won’t necessarily correspond directly to one pixel on its texture (called a ‘texel’ for clarity), because you can view the model at any distance and angle. So, when we want to know the color of a pixel, we find the point on the texture it corresponds to, take a few samples from nearby texels, and average them. The simplest method of texture filtering is bilinear filtering, and that’s all it does: when a pixel falls between texels, it samples the four nearest texels to find its color.
Introduce mipmapping, and you have a new problem. Say the ground you’re standing on is made of cracked concrete. If you look straight down, you’re seeing a big, detailed concrete texture. But when you look way off into the distance, where this road recedes toward the horizon, it wouldn’t make sense to sample from a high-resolution texture when we’re only seeing a few pixels of road. To improve performance (and prevent aliasing, Austin notes) without losing much or any quality, the game uses a lower-resolution texture—called a mipmap—for distant objects.
When looking down this concrete road, we don’t want to see where one mipmap ends and another begins, because there would be a clear jump in quality. Bilinear filtering doesn’t interpolate between mipmaps, so the jump is visible. This is solved with trilinear filtering, which smooths the transition between mipmaps by taking samples from both.
Trilinear filtering helps, but the ground still looks all blurry. This is why we use anisotropic filtering, which significantly improves texture quality at oblique angles.
To understand why, visualize a square window—a pixel of a 3D model—with a brick wall directly behind it as our texture. Light is shining through the window, creating a square shape on the wall. That's our sample area for this pixel, and it's equal in all directions. With bilinear and trilinear filtering, this is how textures are always sampled.
If the model is also directly in front of us, perpendicular to our view, that's fine, but what if it's tilted away from us? If we're still sampling a square, we're doing it wrong, and everything looks blurry. Imagine now that the brick wall texture has tilted away from the window. The beam of light transforms into a long, skinny trapezoid covering much more vertical space on the texture than horizontal. That's the area we should be sampling for this pixel, and in the form of a rough analogy, this is what anisotropic filtering takes into account. It scales the mipmaps in one direction (like how we tilted our wall) according to the angle we're viewing the 3D object.
This is a difficult concept to grasp, and I have to admit that my analogy does little to explain the actual implementation. If you're interested in more detail, here's Nvidia's explination.
Anisotropic filtering isn't common in modern settings menus anymore, but where it does appear, it generally comes in 2x, 4x, 8x, and 16x flavors. Nvidia describes these sample rates as referring to the steepness of the angle the filtering will be applied to:
"AF can function with anisotropy levels between 1 (no scaling) and 16, defining the maximum degree which a mipmap can be scaled by, but AF is commonly offered to the user in powers of two: 2x, 4x, 8x, and 16x. The difference between these settings is the maximum angle that AF will filter the texture by. For example: 4x will filter textures at angles twice as steep as 2x, but will still apply standard 2x filtering to textures within the 2x range to optimize performance. There are subjective diminishing returns with the use of higher AF settings because the angles at which they are applied become exponentially rarer."
Anisotropic filtering it's not nearly as much of a hit as anti-aliasing, which is why it rarely appears in menus these days—it's just on, no matter what. Using the BioShock Infinite benchmarking tool, I only saw average FPS drop by 6 between bilinear filtering and 16x anisotropic filtering. That's not much of a difference considering the huge quality increase. High texture quality is pointless with poor filtering.
What quality settings actually do will vary between games. In general, they raise and lower the complexity of game assets and effects, but going from 'low' to 'high' can change a bunch of variables. Increasing the shadow quality, for instance, might increase the shadow resolution, enable soft shadows as well as hard shadows, increase the distance at which shadows are visible, and so on. It can have a significant effect on performance.
Texture quality, which lowers and raises the resolution of textures, tends to affect performance and visual quality a lot. I benchmarked BioShock Infinite with all settings set to high, changing only the texture quality, to get a sense of how expensive it is.
BioShock Infinite texture quality benchmarks (2x Nvidia GTX Titan SLI)
| Avg. FPS | Max FPS | Min FPS | |
| Very low | 103 | 295 | 30 |
| Normal | 101 | 180 | 20 |
| Ultra | 92 | 178 | 15 |
That's an average FPS jump of 11 between 'very low' and 'ultra.' Not too bad, but the amount of slow-down will vary system-to-system. There's no quick method for determining the best quality settings for your system—it's a case where they just need to be tested, and I recommend starting with Nvidia or AMD's suggestions, then raising the quality on textures, lighting, and shadows and checking your framerate.
Ambient lighting exposes every object in a scene to a uniform light—think of a sunny day, where even in the shadows, a certain amount of light is scattered about. It's paired with directional light to create depth, but on its own it looks flat.
Ambient occlusion attempts to improve the effect by determining which parts of the scene shouldn't be exposed to as much ambient lighting as others. It doesn't cast hard shadows like a directional light source, rather, it darkens interiors and crevices, adding soft shading.
Screen space ambient occlusion (SSAO) is an approximation of ambient occlusion used in real-time rendering, and has become commonplace in games in the past few years—it was first used in Crysis. Sometimes, it looks really dumb, like everything has a dark 'anti-glow' around it. Other times, it's effective in adding depth to a scene. All major engines support it, and its success will vary depending on the game and implementation.
Improvements on SSAO include HBAO+ and HDAO.
High dynamic range was all the rage in photography a few years ago. The range it refers to is the range of luminosity in an image—that is, how dark and bright it can be. The goal is for the darkest areas to be as detailed as the brightest areas. A low-dynamic-range image might show lots of detail in the light part of a room, but lose everything in the shadows, or vice versa.
In the past, the range of dark to light in games was limited to 8 bits (only 256 values), but as of DirectX 10 128-bit HDRR is possible. HDR is still limited by the contrast ratio of displays, though. There's no standard method for measuring this, but LED displays generally advertise a contrast ratio of 1000:1.
The famously overused bloom effect attempts to simulate the way bright light can appear to spill over edges, a visual cue that makes light sources seem brighter than they are (your display can only get so bright). It can work, but too often it's applied with a thick brush, making distant oil lamps look like nuclear detonations. Thankfully, most games offer the option to turn it off.
The screenshot above, which has now blinded you, is from Syndicate, which probably includes the most hilarious overuse of the effect.
Motion blur is pretty self-explanatory: it's a post-processing filter which simulates the film effect caused when motion occurs while a frame is being captured, causing streaking. Many gamers I've seen in forums or spoken to prefer to turn it off: not only because it affects performance, but because it just isn't desirable. I've seen motion blur used effectively in some racing games, but I'm also in the camp that usually turns it off. It doesn't add enough for me to bother with any performance decrease.
In photography, depth of field refers to the distance between the closest and furthest points which appear in focus. If I'm taking a portrait with a small DOF, for instance, my subject's face might be sharp while the back of her hair begins to blur, and everything behind her is very blurred. In a high DOF photo, on the other hand, her nose might be as sharp as the buildings behind her.
In games, DOF generally just refers to the effect of blurring things in the background. Like motion blur, it pretends our 'eyes' in the game are cameras, and creates a film-like quality. It can also affect performance significantly depending on how it's implemented. On the LPC, the difference was negligible, but on the more modest PC at my desk (Core i7 @ 3.47 GHz, 12GB RAM, Radeon HD 5970) my average framerate in BioShock Infinite dropped by 21 when going from regular depth of field to Infinite's DX11 'Diffusion Depth of Field.'
How these settings affect visual quality will vary from game to game, and how they affect performance will vary from system to system. These benchmarks are anecdotal, but they can give us an idea of which processes are generally more taxing than others.
Whenever a graphics intensive game releases, especially if it's on a new engine or uses new tech, you can bet we're working on a performance and settings guide for it. Check out all of our performance analyses here.
