FSR is an AMD technology that increases frame rates in games by rendering images at a lower resolution and intelligently upscaling them to the target resolution. You get smooth gameplay without needing to buy a more powerful graphics card, while maintaining acceptable image quality.
The technology is used in a wide range of modern games from AAA titles to indie projects, supporting not only AMD Radeon graphics cards but also competitor solutions, including NVIDIA and Intel, down to integrated graphics. Integration happens both at the level of specific game engines and through drivers, as well as on game consoles with AMD architecture.
The main problems are related to artifacts on complex geometric surfaces and in motion: noticeable flickering, ghosting, and the breakup of thin lines occur, especially in Performance modes. FSR 1.0 suffered from a significant loss of text and interface sharpness, while early versions of FSR 2 and 3 experienced instability in depth of field on particles and transparent textures.
How FSR works
The operating principle differs by generation. FSR 1 is based on spatial upscaling using a Lanczos edge detection algorithm for a single frame without referencing motion history — a fast but lower quality method. In contrast, FSR 2 and later versions are temporal solutions similar to NVIDIA DLSS: they analyze the current frame, depth buffers, motion vectors, and color history, reconstructing details based on data accumulated over several frames. This brings quality closer to native resolution and combats aliasing. The key difference from the closed NVIDIA DLSS technology is the lack of hardware dependency on tensor cores and the use of manual algorithmic analysis instead of a trained neural network, although FSR 4 is transitioning to machine learning. Compared to conservative bicubic scaling, FSR actively restores high-frequency details, and compared to generic temporal anti-aliasing (TAAU), it offers more aggressive and specialized reconstruction of geometry and textures.
FSR functionality
- Spatial scaling with edge preservation. The FSR 1.0 algorithm performs frame-by-frame upscaling using a heuristic approach to edge detection based on local contrast analysis of neighboring pixels. Instead of traditional bilinear interpolation, nonlinear approximation is used, allowing the restoration of high-frequency details without accessing temporal data or motion vectors.
- Subpixel detail reconstruction via EASU. The Edge-Adaptive Spatial Upsampling stage modifies interpolation weights in real time based on the brightness gradient. The filter kernel dynamically rotates and scales, stretching along the direction of the object boundary. This prevents the smoothing of stair-step aliases and preserves the sharpness of fine geometric structures such as wires or grass.
- Adaptive sharpening RCAS. Robust Contrast-Adaptive Sharpening is applied after spatial scaling to compensate for the loss of micro-contrast. The filter extracts the difference between the original pixel and the local average brightness value, then amplifies the signal with amplitude limiting. The clipping mechanism prevents the formation of halos (ringing) in areas with extreme brightness transitions.
- Temporal FSR 2 versus depth sensor version. Unlike FSR 1, the second iteration introduces a temporal component. FSR 2 uses history buffers, color clips, and a disocclusion signal to protect against phantom trails. Depth prioritization is absent, which distinguishes the technology from DLSS: the displacement grid is calculated exclusively from the color buffer without accessing vector tensors.
- Break from machine learning. FSR does not require specialized matrix accelerators or a neural network training stage. All math is implemented through programmable pixel and compute shaders in the HLSL model. The lack of dependency on a hardware NPU ensures cross-platform compatibility, allowing execution on competitor GPUs, including Pascal and RDNA1 architectures.
- NPU (Specialized processor for parallel tensor computations)
- Reactive geometry divergence buffer. The FSR 2 subsystem blocks the sampling of incorrect historical pixels through depth difference analysis. If the distance between the current and reprojected depth buffer value exceeds a threshold, the pixel is marked as disoccluded. In the geometry overlap zone, priority is given to spatial information, preventing the smearing of moving characters.
- Dynamic resolution scaling with texture protection. The technology automatically adjusts the internal rendering buffer to the target output resolution, guided by the scaling factor from the preset (Quality, Balanced, Performance). The shader uses mip-level exposure to adjust LOD bias (Negative MIP Bias), which swaps in high-resolution textures, preventing the empirical blurring of details at low input resolution.
- Reprojection Lock mechanism in FSR 3. The third version introduces optional intermediate frame generation via optical flow. Reprojection Lock fixes interface elements using a stillness mask based on alpha channel and motion vector analysis. HUD pixels are processed separately from the game world, eliminating artifacts of text tearing and reticle breakup.
- Asynchronous frame swap pipeline. In Fluid Motion Frames mode, swap buffers with independent flip are introduced, not blocking the main render command queue. The Swapchain chain is modified by the driver to interpolate a frame between two ready presentations. This approach decouples simulation logic and output but adds a latency contribution equivalent to half the original frame time.
- Transparency lambda processing. FSR analyzes fragments with alpha testing and compositing separately. For partially transparent objects, reactive color clamping is introduced, limiting the chromaticity range of historical samples based on the min-max statistics of the current frame. This eliminates the ghosting effect on tracing particles, smoke, and tinted glass without requesting a separate stencil channel.
- Asynchronous compute unit offload. The computational load of FSR shaders is distributed across asynchronous compute engines of the GPU. Thanks to parallelization into thread groups, scalar and vector registers are used simultaneously, hiding texturing latencies behind arithmetic instructions. This is critical for GCN and RDNA architectures, where peak Compute Unit utilization is achieved without interrupting the graphics pipeline.
- Laplacian distortion metric. The edge detector uses convolution with a Laplace kernel to calculate the second derivative of the brightness signal in a local 5×5 window. Zero-crossing points define the trajectory of the line being restored. Interpolation coefficients are adjusted to minimize Laplacian distortion along the found direction, preserving the natural curvature of the contour.
- Manual frame exposure control. Through the API, the developer passes the pre-exposure value used by the tonemapping engine. FSR applies its inversion to restore linear light before upscaling, then re-multiplies the result. This manipulation eliminates nonlinear histogram stretching in HDR space, preventing the burnout of saturated highlights and degradation in deep shadows.
- Native Anti-Aliasing mode. The technology can be applied when the input and output resolutions match. In this case, EASU is bypassed, and only a high-quality anti-aliasing pass with the RCAS component is performed. This method replaces classic TAA, providing a more stable picture without decomposition into temporal samples, which is valuable for VR headsets sensitive to temporal instability.
- FidelityFX API structure. The interface is implemented as an open library with backends for Vulkan, DirectX 12, and DirectX 11. Functions export lightweight dispatch structures without hidden memory allocations. Integration requires the engine to manually provide resources: color buffer, depth, motion vectors, and the resulting render target, maintaining full control over synchronization barriers.
- Reactive mask versioning. FSR 3.1 introduces the ability to externally inject reactive masks via the Responsive Pixel Mask parameter. The developer marks UI and post-processing zones so that the algorithm inhibits temporal accumulation in these regions. The elimination of font and particle artifacts becomes deterministic rather than heuristic, raising the quality of subtitle overlay.
- Anti-jitter stabilization in motion. The combination of temporal anti-aliasing and interpolation in FSR 3 uses the Jitter Offset signal, shifting the camera projection by less than a pixel. Subpixel sample rotation is updated every frame, and the history is filtered with Gaussian decay. Low-frequency texture flickering is eliminated without capturing an excessive number of samples from areas outside the geometry.
- Memory bandwidth savings. Moving reconstruction to the end of the graphics pipeline allows internal G-Buffer and shadow buffers to be stored at low resolution. Reducing writeback to video memory decreases pressure on the bus and cache misses, which is critically important for graphics cards with a narrow memory interface, such as the RX 6500 XT or integrated APUs based on the RDNA2 architecture.
Comparisons
- FSR 1.0 vs DLSS 1.0. FSR 1.0 is a spatial upscaler that does not require specialized hardware units and works on a wide range of GPUs. DLSS 1.0, on the contrary, used a neural network temporal method, required tensor cores, and pre-training for each game. The FSR result proved more universal, while DLSS 1.0 suffered from an abundance of artifacts and blurring.
- FSR 2.0 vs DLSS 2.0. Both technologies moved to temporal data accumulation from multiple frames, analyzing motion vectors and the depth buffer. DLSS 2.0 utilized hardware acceleration of a neural network, providing more stable reconstruction of fine geometric elements and mesh structures. The software approach of FSR 2.0 provided comparable performance gains on graphics cards without tensor cores but exhibited more noticeable ghosting in dynamic scenes.
- FSR 3.0 vs DLSS 3.0 (Frame Generation). The key difference lies in the frame generation method. NVIDIA uses a hardware optical flow accelerator to interpolate a frame between two rendered ones, analyzing motion at the pixel level. AMD implemented software interpolation Fluid Motion Frames, running on asynchronous compute shaders. AMD’s solution handles sharp motion vector changes and user interface elements less accurately but is compatible with competitor graphics cards.
- FSR 3.1 vs Intel XeSS 1.3. XeSS offers two execution paths: hardware-accelerated on XMX matrix engines for Intel cards and a simplified one on DP4a instructions for other devices. FSR 3.1, completely lacking hardware dependency, updated the depth-of-field analysis algorithm, reducing the particle flickering effect. In XMX mode, Intel’s technology demonstrates quality close to DLSS, while FSR shows more pronounced instability in thin lines and transparent textures.
- XeSS (Intelligent upscaling with frame reconstruction)
- FSR 3.1 vs PSSR (PlayStation Spectral Super Resolution). PSSR is a hybrid upscaler using specialized machine learning hardware instructions in the PS5 Pro console GPU, with up to 300 TOPS of compute. Unlike AMD’s fully cross-platform software algorithm, PSSR performs more aggressive detail reconstruction with fewer disconnections at contrasting boundaries. FSR wins in openness and update frequency, while Sony’s custom solution delivers a reference-clear image with low-resolution internal rendering.
- TOPS (Measuring peak performance of AI accelerators)
OS and driver support
FSR is implemented at the software level through an open API, which eliminates dependency on specialized hardware and works on GPUs supporting modern graphics APIs — DirectX 11, DirectX 12, and Vulkan. The technology functions in Windows 10 and 11 environments, as well as in Linux distributions via Proton, where the Mesa driver ensures compatibility through universal shader compilation without the need to install proprietary AMD libraries.
Security
The FSR source code is distributed under the MIT license and is hosted on GitHub, allowing audits for the absence of hidden vulnerabilities or data collection mechanisms in the shader passes. The spatial upscaling logic runs isolated in the graphics pipeline, not interacting with user files or network sockets, and input to the API is carried out through vector buffers without injections into the game process memory, which complies with real-time application security standards.
Logging
The internal debug layer of FSR does not export events to system logs, as the technology is tailored for minimal frame latency. Activation of diagnostics is possible through the Vulkan Validation Layers or frame capture tools in GPUOpen, where the developer analyzes compute dispatches and mip levels through structural dumps rather than text logs to exclude the impact of string operations on frame time.
Limitations
The algorithm operates only on low-dimensional data of the current frame, so FSR version 2 and higher require the provision of correct motion vectors, depth, and a color buffer without disocclusion and noise, otherwise pixel breakup artifacts appear on fine geometry. The lack of hardware acceleration necessitates reserving part of the unified shader compute units, which on weak integrated graphics can lead to a resource deficit for the main render, reducing the gain to zero.
History and development
The first iteration, FSR 1.0, released in 2021, was a single-pass spatial Lanczos-like filter with adaptive contrast enhancement. The transition to FSR 2.0 in 2022 implemented temporal feedback with frame history, reprojection, and a disocclusion detector, bringing the anti-aliasing model closer to supersampling methods, and version 3 supplemented the pipeline with intermediate frame generation via asynchronous optical flow, significantly reducing the requirements for manual input accuracy from the engine.