Boot up a game from 2013 on a 1080p monitor and the image is crunchy, jagged in places, but sharp. Boot up a game from the last five years on a better monitor at a higher resolution and something is off: edges are clean, sure, but the whole frame has a soft, slightly smeared quality, like a photo taken through a freshly cleaned window that somehow still isn’t clean. Pan the camera and fine detail dissolves. Stop moving and it crawls back over a few frames.
That softness has a name, and the name gets cursed in graphics settings menus daily: temporal anti-aliasing, TAA. It’s in nearly every big game now, frequently with no off switch. Two things are true at once, and this post exists to reconcile them: the people who say TAA ruined image clarity are right, and the engineers who put it in everything anyway had extremely good reasons. The story is just longer than a settings menu tooltip.
The original sin: one sample per pixel
Start at the bottom. A 3D scene is made of continuous math, and a monitor is a grid of discrete dots. Rendering asks a brutally simplified question for each pixel: what color is the scene at this one exact point? One sample, one answer, no context.
A diagonal edge doesn’t pass politely through pixel centers, so it gets chopped into stairsteps. A power line half a pixel wide gets sampled where it exists in some pixels and where it doesn’t in others, turning into a dashed morse-code version of itself. This is aliasing, and the still-image version is only half the problem. In motion it becomes shimmer: as the edge slides a fraction of a pixel per frame, each pixel flips between “hit” and “miss,” and the whole edge boils and sparkles. Foliage, chain-link fences, distant railings, anything thin turns into glitter.
Below is the underlying disease, isolated. Same scene, one side sampled once per pixel with no anti-aliasing, the other side supersampled at 8x. Drag across the thin lines:
Supersampling, the method behind the smooth side, is the brute-force fix: render at a much higher resolution, average down. It’s also a tax of 4x to 8x your entire frame cost, which is why it lives in glamour screenshots and not in shipping framerates.
The clever decades
Real-time graphics spent twenty years finding discounts on that tax.
MSAA, multisample anti-aliasing, was the great one. It noticed that the expensive part of rendering is shading (computing the color) while the aliasing mostly lives at geometric edges, so it computed shading once per pixel but tested coverage at 4 or 8 sub-pixel positions along triangle edges. Edge quality close to supersampling at a fraction of the price. Through the Xbox 360 era, “4x MSAA” was practically a system requirement for respectability.
Then engines changed underneath it. To afford scenes with hundreds of dynamic lights, renderers moved to deferred shading: draw all geometry first into a fat stack of buffers (depth, normals, material properties), then compute lighting afterward as a screen-space pass reading those buffers. Decoupling geometry from lighting is what makes modern scene complexity possible, and it breaks MSAA’s core trick, because by the time lighting runs, the per-sample coverage information MSAA depends on is gone (keeping it multiplies your buffer memory and lighting cost by the sample count, which defeats the point).
MSAA has a second, quieter problem that sealed the verdict: it only fixes geometric edges. As materials got physically-based and shiny, aliasing started coming from shading itself, tiny bright specular highlights that flicker in and out between samples. MSAA does nothing for that. You can’t fix a sparkling highlight by sampling triangle coverage more finely.
So around 2011 the industry reached for filters. NVIDIA’s Timothy Lottes wrote FXAA, a single post-process pass that scans the finished frame for high-contrast edges and blurs along them. It costs about a millisecond and works on anything. It also can’t tell an aliased edge from detail you wanted, so it softens texture and text along with jaggies. SMAA, published by Jorge Jimenez and colleagues at Eurographics 2012, did the same job with much smarter pattern recognition and became the quality pick of the era.
But post-process filters share a ceiling: they only see the final frame, which contains one sample per pixel of information. They can hide stairsteps. They cannot un-shimmer a fence, because the information about what’s between the samples was never captured; the dashed power line stays dashed, just with softer dashes.
TAA’s actual idea, which is a good one
Somebody eventually asked the right question: we can’t afford 8 samples per pixel per frame, but we render 60 frames a second, so what if the samples came from time?
That’s TAA. Each frame, the camera’s projection is nudged by a sub-pixel offset, a jitter, following a pattern like the Halton sequence so that over 8 or so frames the samples cover the pixel evenly. Each new frame is blended into an accumulated history image, typically at around 5 percent new frame, 95 percent history, per the standard recipe. Stand still for a quarter of a second and every pixel has effectively been supersampled 8x or more, for approximately the cost of a blend.
The scheme goes back further than most people think. Tiago Sousa presented a temporal AA in CryEngine 3 at SIGGRAPH 2011, and the approach matured through Brian Karis’s UE4 implementation, presented at SIGGRAPH 2014 as High Quality Temporal Supersampling, plus Playdead’s much-cited INSIDE talk and Marco Salvi’s variance clipping work. By the late 2010s it was the default everywhere.
And on paper it dominates: near-free, kills geometric aliasing, kills specular sparkle (the highlight gets averaged over its flickers), works with deferred shading, scales to any content. There’s a reason every engine adopted it. TAA in a still frame, given a good implementation, is close to magic.
The problems start the instant anything moves. Which, in a video game, is always.
Where the blur actually comes from
Motion breaks the core assumption. Blending this frame with the last one is only valid if each pixel is looking at the same piece of the world it saw last frame. Move the camera and nothing is where it was, so TAA reprojects: using per-pixel motion vectors, it looks up where each surface was in the history image and samples there. Now count the compromises that follow.
Compromise one: the history lands between pixels. A reprojected position is almost never a nice integer pixel coordinate; the world doesn’t slide in one-pixel increments. So the history must be interpolated from surrounding pixels, and interpolation is a small blur. Do it with plain bilinear filtering, every frame, compounding, and your accumulated image smears itself soft in under a second of camera motion. Good implementations use a sharper Catmull-Rom filter to slow the bleeding, and it’s still one of the main reasons the image goes soft precisely when you move, which is precisely when you’re playing.
Compromise two: the history can lie. Round a corner and a wall is revealed that wasn’t on screen last frame; it has no history at all. A character walks past a doorway and the pixels behind them hold history that belongs to the character, not the doorway. Trust stale history and you get ghosting, the smeared trail behind moving objects that is TAA’s most infamous artifact. The standard defense is to clamp the history to the range of colors in the current frame’s neighborhood (Karis’s clamp, refined into Salvi’s variance clipping), which is a statistical guess, not knowledge. Tune it strict and you re-admit shimmer and flicker. Tune it loose and edges trail. Every TAA implementation is a point on that tightrope, and no point on it is “off.”
Compromise three: even the still image is a filtered average. With jitter running, a static scene converges to samples spread across each pixel’s area combined by a reconstruction filter, which is mathematically a slightly soft image compared to a razor-aligned single-sample frame. It’s more correct (the single-sample frame was lying to you with false crispness and would shimmer the moment anything moved), but softer. Some of what players call TAA blur is this, and it’s the part sharpening filters can partially repay.
Compromise four: some things can’t be reprojected. Transparent effects, particles, anything animated inside a texture like scrolling UI or waterfalls: these either don’t write motion vectors or can’t have meaningful ones. They get wrong history and either ghost or flicker. Implementations bolt on masks and exceptions per effect, which is exactly the kind of care that separates a game where TAA is invisible from one where it’s the first thing reviewers mention. The production reality, per people who ship this stuff, is that TAA needs feeding and maintenance for the whole life of a project.
Add the four up and you get the modern look: clean, stable, and soft, sharpest when nothing is happening.
Why you often can’t turn it off
Then there’s the part that turns irritation into anger: the vanishing off switch. It’s not spite. Somewhere in the mid-2010s, engineers noticed that if TAA is going to average the last several frames anyway, other effects can lean on it.
Want soft hair or dense foliage without the cost of true transparency? Render it as a noisy dither pattern and let TAA melt the noise into smoothness. Ambient occlusion, soft shadows, screen-space reflections, volumetric fog, ray-traced lighting: all of them are now commonly computed from a handful of noisy samples per pixel, at a fraction of the full cost, on the assumption that temporal accumulation will average the noise away. The technique is stochastic rendering, and TAA is the washing machine it throws its laundry into.
Which means in many modern engines TAA isn’t a filter applied to a finished image. It’s a load-bearing wall. Force it off with a config file or a mod and the hair turns into static, the shadows crawl, and surfaces sparkle with raw sample noise, because the image was never designed to be viewed unwashed. That’s why the off switch disappeared, and it’s also why the sharper complaint isn’t “let me disable TAA” so much as “stop building games that fall apart without it.” Graphics programmers argue this point too; there’s a well-known plea for accessibility from inside the field noting that TAA’s ghosting and jitter cause real motion sickness for some players, and that communities reliably build TAA-disabling mods for any game that forces it, broken hair or not.
The upscaler era: TAA eats itself
The strangest turn in this story: the thing that’s replacing TAA is TAA.
DLSS 2 and its relatives (FSR 2 and 3, XeSS, and the newer transformer-based variants) are temporal accumulators with the same skeleton: jittered samples, motion vectors, history, rejection. The difference is what makes the accept-or-reject decision. Classic TAA uses hand-written heuristics like neighborhood clamps. DLSS uses a neural network trained on enormous quantities of image data to judge which history to keep, and it makes that call well enough to upscale at the same time, rendering fewer pixels than the output resolution and reconstructing the rest from time.
This is why “DLSS Quality” in many games looks better than the same game’s native-resolution TAA, which sounds impossible until you realize they’re the same machine with different brains. It’s also why NVIDIA ships DLAA, which is DLSS running at native resolution with no upscaling: it exists purely as a better TAA. If a game offers DLAA, or lets you run an upscaler at native res, that’s usually the single biggest image-clarity upgrade in the menu.
The blur didn’t leave, to be clear. It shrank. Temporal reconstruction still resamples history and still guesses wrong at disocclusions; ghosting still happens behind fast objects in most implementations. The tightrope got wider, but everyone is still up on it.
Decoding the settings menu
Part of the confusion around TAA is that no two games call anything the same thing. What the usual labels mean:
TAA / TXAA / Temporal AA. The classic hand-tuned accumulator described above. Quality varies enormously between engines and even between games on the same engine, because the tuning is per-game work.
TSR. Unreal Engine 5’s built-in temporal upscaler, a generational step past UE4’s TAA, with smarter history rejection. Runs on any GPU.
DLSS / FSR / XeSS in their upscaling modes. Temporal reconstruction plus upscaling. “Quality” typically renders at two-thirds of output resolution per axis. Counterintuitively, these often beat native-res TAA on clarity because their history handling is simply better.
DLAA, and FSR’s Native AA mode. The same reconstruction with no upscaling: full-resolution input, all the intelligence spent purely on anti-aliasing. Usually the best-looking option in any menu that has it.
FXAA / SMAA. The old post-process filters, kept around as the “no temporal smearing, please” option. Sharp in motion, but they bring back the shimmer, and in a modern engine full of stochastic effects they may also expose noise the art was built to hide.
Sharpening sliders. Not anti-aliasing at all; a partial refund on temporal softness, applied after the fact. Useful in moderation, destructive past it.
One practical warning about comparing these: never judge them from screenshots alone. A still frame is TAA’s best case, fully converged, nothing moving. The differences that matter, shimmer versus smear versus ghosting, only exist in motion, so any fair evaluation needs both a still comparison and a slow camera pan while you watch fences, hair, wires and foliage. The still shows the resolution cost; motion is where temporal methods give themselves away.
What you can actually do about it
Practical moves, in rough order of payoff.
If the game offers DLAA, or lets you pair an upscaler with a native-resolution mode, use it. If you have GPU headroom, resolution scale above 100 percent (or rendering at 4K on a 1440p screen, DSR/VSR style) attacks the sample-starvation problem at its root; TAA on top of more samples both blurs less and has less to fix. Sharpening filters like AMD CAS or the engine’s own sharpener repay some of the reconstruction softness, though they can’t resurrect detail the accumulation destroyed outright, and past about 20 percent strength they trade blur for a crispy halo look that’s arguably worse.
And if you’re tuning a specific game: don’t A/B anti-aliasing by memory. Your eyes adapt within seconds and motion hides half the differences. Take matched screenshots from the same spot, one per setting, and put them under a slider where you can drag across the exact same fence, the same hair, the same distant wire. The differences that survive a slider are the ones worth an FPS budget. There’s a full workflow for that in the DLSS, FSR and TAA comparison guide, and the same method applies to any graphics setting.
A few capture details that decide whether your comparison means anything. Save as PNG, always; JPEG’s own artifacts sit in exactly the fine-detail regions you’re inspecting, and they’ll contaminate the verdict. Let the image settle for a second after you stop moving before you screenshot, because TAA needs a handful of frames to converge, and a shot taken mid-pan is a different (and also interesting) test than a shot at rest. Capture both if you can: one still pair, one pair taken during identical slow pans, which is where temporal methods show their true faces. And change one variable at a time; a TAA-versus-DLAA comparison taken at two different times of day in a game with dynamic weather is a weather comparison.
If a game refuses to expose the option you want to test, the usual escape hatches are config files and community mods, with the stochastic-effects caveat from earlier: a game built on dithered hair and noisy reflections will look broken with TAA fully off, and that’s not the mod’s fault. The realistic comparison in those games isn’t TAA versus nothing, it’s the engine’s TAA versus DLAA or an upscaler’s native mode, which is a fight the newer methods usually win.
A note on resolution, because it explains why opinions on TAA split so cleanly along monitor lines. TAA’s core problem is information starvation: one jittered sample per pixel per frame, and everything else is inference. Raise the resolution and every one of its compromises shrinks. At 4K there are simply more samples describing the same fence, the reconstruction filter covers a smaller angular area of your vision, and the softness that’s obvious at 1080p becomes hard to spot at normal viewing distance. When someone says TAA looks fine and someone else says it’s vaseline, before arguing, ask what screens they’re on. They’re describing different amounts of the same artifact, and both descriptions are usually accurate.
The same logic explains a classic disappointment in reverse: people who upgrade from an older 1080p game to its shiny modern sequel on the same monitor sometimes feel the image got worse. It did, in per-pixel sharpness. The new game is resolving more effects with fewer samples per pixel and leaning on the accumulator to hide the shortfall, and 1080p is where the shortfall shows most.
Two questions come up often enough to answer directly. Does TAA hurt competitive play? Mostly indirectly: the softness can make distant player silhouettes marginally harder to pick out against busy backgrounds, which is why esports titles tend to ship lighter AA and why competitive players often prefer the shimmer. Ghosting on a fast-moving enemy is information arriving late, in principle, though at competitive framerates the history is only a few milliseconds old. And does TAA cause motion sickness? For some people the combination of ghosting, jitter and motion blur demonstrably contributes, which is the accessibility argument for an off switch in its strongest form: for most players TAA is an aesthetic tradeoff, and for a minority it’s the difference between playing and not.
The fair verdict
TAA is what a correct answer looks like when the question is unfair. One sample per pixel isn’t enough information to build a stable image, supersampling is unaffordable, spatial filters are blind, and time was the only place left to find free samples. Everything players hate about the result, the softness in motion, the trails, the vaseline, is a compromise some engineer measured and chose as the least bad option on a 16-millisecond budget.
It’s still fair to hate the outcome. A whole generation of games traded crispness for stability and then quietly removed the option to disagree. The good news is that the trade keeps improving: learned reconstruction already returns most of the sharpness, and engines are slowly re-learning that “optional” is a feature. Until then, at least you now know exactly what that soft window-glass look is: eight frames of the past, politely averaged, hoping you won’t move.