Super resolution has become a non-negotiable feature for PC games in 2026. Players expect it. Storefronts surface it. Digital Foundry tests it. And with NVIDIA, AMD, and Intel all shipping mature upscaling technologies, the question for developers is no longer "should I support upscaling?" but "how do I support all three without losing my mind?"

This guide covers the complete integration of DLSS 4, FSR 4, and XeSS 2 in Unreal Engine 5.7. We'll walk through what each technology does, how they differ under the hood, how to set them all up in a single project, and how to make smart decisions about quality presets and platform targeting. We'll also cover DirectSR — Microsoft's unified API that simplifies multi-vendor support — and where using the Unreal MCP Server can automate the tedious configuration work.

Let's get into it.

What Each Upscaler Does and How They Differ

All three technologies solve the same basic problem: render the game at a lower resolution and then reconstruct a higher-resolution image using some form of intelligent upscaling. This lets you hit higher framerates (because you're rendering fewer pixels) while maintaining visual quality that approaches or matches native resolution.

But the "intelligent upscaling" part is where they diverge significantly.

NVIDIA DLSS 4 (Deep Learning Super Sampling)

DLSS 4 represents NVIDIA's fourth major iteration of their AI-powered upscaling technology. Here's what's under the hood:

Architecture: DLSS 4 uses a transformer-based neural network trained on NVIDIA's supercomputer infrastructure. The model runs on dedicated Tensor Cores found in RTX GPUs. It takes the low-resolution rendered frame, motion vectors, depth buffer, and previous frame data as inputs, and outputs a reconstructed high-resolution frame.

What's new in DLSS 4:

• Multi Frame Generation: DLSS 4 can now generate up to three additional frames between rendered frames on RTX 50-series GPUs, effectively quadrupling frame output. On RTX 40-series, single-frame generation remains available.
• Improved temporal stability: The transformer model handles disocclusion (revealing previously hidden areas) significantly better than the CNN-based DLSS 3. Ghosting artifacts are reduced in fast-motion scenarios.
• Per-pixel confidence maps: DLSS 4 generates internal confidence maps that tell the model which areas of the frame it's uncertain about, allowing it to fall back to more conservative upscaling in those regions.
• Ray Reconstruction integration: DLSS 4's Ray Reconstruction mode replaces the traditional denoiser for ray-traced effects, using the same neural network to simultaneously upscale and denoise.

Hardware requirements: RTX 20-series or newer for basic DLSS upscaling. RTX 40-series for single Frame Generation. RTX 50-series for Multi Frame Generation.

Key advantage: Image quality. DLSS 4 produces the best visual quality of any upscaler at equivalent performance levels, particularly in motion and in scenes with complex lighting. The dedicated hardware (Tensor Cores) means the upscaling computation doesn't compete with rendering for GPU resources.

Key limitation: NVIDIA-only. About 75-80% of the Steam hardware survey, but that still leaves 20-25% of players without access.

AMD FSR 4 (FidelityFX Super Resolution)

FSR has evolved dramatically from its origins as a spatial-only upscaler. FSR 4 is AMD's answer to DLSS, and it's now a genuinely competitive technology.

Architecture: FSR 4 is AMD's first fully machine-learning-based upscaler, running on dedicated AI accelerators in RDNA 4 GPUs. For older RDNA 3 and RDNA 2 hardware, FSR 3.1 (the temporal upscaler with frame generation) remains available as a fallback. FSR 4 uses a compact neural network optimized for AMD's matrix accelerator hardware.

What's new in FSR 4:

• ML-based upscaling on RDNA 4: FSR 4 is a ground-up rewrite that uses machine learning inference on dedicated hardware, abandoning the algorithmic approach of FSR 1-3.
• Fluid Motion Frames 2.0: AMD's frame generation technology now supports generating two intermediate frames on RDNA 4, with improved latency handling through AMD Anti-Lag 2.
• Cross-vendor fallback: FSR 4's ML upscaler is RDNA 4-only, but FSR 3.1 (temporal + algorithmic) remains available as an automatic fallback for older hardware, including NVIDIA and Intel GPUs. This is a significant practical advantage over DLSS.
• Improved ghosting handling: FSR 4's temporal accumulation has been significantly improved. The persistent "smearing" artifacts that plagued FSR 2 are largely resolved.

Hardware requirements: Any GPU for FSR 3.1 fallback (temporal upscaling). RDNA 4 for FSR 4 ML upscaling. RDNA 3+ for Fluid Motion Frames.

Key advantage: Reach. FSR 3.1's fallback mode works on essentially any modern GPU, including NVIDIA and Intel hardware. If you can only implement one upscaler, FSR gives you the broadest hardware support.

Key limitation: Quality gap with DLSS on NVIDIA hardware. When an NVIDIA user enables FSR instead of DLSS, they're getting a slightly inferior image on hardware that could run the superior option. The RDNA 4-exclusive ML mode means full FSR 4 quality only benefits AMD's latest GPUs.

Intel XeSS 2 (Xe Super Sampling)

XeSS is Intel's entry in the upscaling race, and XeSS 2 is a meaningful improvement over the original.

Architecture: XeSS 2 uses a hybrid approach: an XMX-accelerated (Intel's matrix extensions) neural network on Arc GPUs, with a DP4a (integer dot product) fallback path for non-Intel hardware. The neural network is smaller and less complex than DLSS 4's transformer, but it runs efficiently on Intel's hardware.

What's new in XeSS 2:

• Xe Frame Generation: Intel's first frame generation technology, available on Arc B-series and newer GPUs. Generates one intermediate frame with XeLLE (Xe Low Latency Engine) for latency compensation.
• Improved sharpness model: XeSS 2's upscaling model produces noticeably sharper images than XeSS 1, particularly at Performance and Ultra Performance quality levels.
• Better motion vector utilization: Improved handling of per-object motion vectors reduces ghosting on fast-moving objects.

Hardware requirements: Any GPU with DP4a support for basic upscaling (this includes most modern GPUs). Intel Arc for XMX-accelerated quality. Intel Arc B-series for Frame Generation.

Key advantage: Good fallback quality. XeSS 2's DP4a path provides a reasonable upscaling option for GPUs that don't support DLSS or FSR 4's ML mode. It's also the best option for Intel Arc users, obviously.

Key limitation: Smallest market share. Intel Arc GPUs are used by roughly 1-3% of Steam players. The fallback mode is useful, but most players with NVIDIA or AMD GPUs should be using DLSS or FSR respectively.

Side-by-Side Quality and Performance Comparison

Let's compare the three technologies at equivalent quality presets. These benchmarks are from our internal testing with a standardized UE5.7 scene (medium-complexity open world, Nanite geometry, Lumen lighting, hardware ray-traced shadows).

Quality Comparison at 4K Output

All three upscalers are rendering at their respective internal resolutions for each quality preset and outputting at 3840x2160.

Quality Mode (highest quality preset):

Balanced Mode:

Performance Mode (lowest quality, highest performance):

Key takeaway: DLSS 4 wins on quality at every preset, but the gap narrows at higher quality levels. FSR 4 on RDNA 4 is competitive, especially in Quality and Balanced modes. The fallback modes (FSR 3.1 and XeSS DP4a) show their age at aggressive upscaling ratios.

Performance Comparison

Test system: RTX 4070 (for DLSS), RX 7800 XT (for FSR 3.1), RX 9070 XT (for FSR 4), Arc B580 (for XeSS 2). Same scene, same settings except upscaler.

4K output, no Frame Generation:

Note: Cross-GPU comparisons have limited value since the base performance differs. What matters is the percentage improvement relative to native rendering on the same GPU.

With Frame Generation enabled:

Frame Generation adds visual fluidity but introduces latency. NVIDIA's Reflex and AMD's Anti-Lag 2 mitigate this, but it's still a consideration for competitive or latency-sensitive games.

DirectSR: The Unified API

DirectSR is Microsoft's attempt to solve the "implement three upscalers" problem at the API level. Introduced in DirectX and available in UE5.7, DirectSR provides a single interface that dispatches to whichever upscaler is available and appropriate for the current hardware.

How DirectSR Works

Instead of integrating DLSS, FSR, and XeSS separately, you integrate DirectSR once. At runtime, DirectSR:

1. Detects the GPU vendor and capabilities
2. Selects the optimal upscaler (DLSS on NVIDIA, FSR on AMD, XeSS on Intel)
3. Translates your quality preset into the vendor-specific equivalent
4. Handles all the vendor-specific buffer requirements and API calls

The practical benefit: One integration instead of three. One set of quality presets. One UI toggle. The driver handles the rest.

The catch: DirectSR is currently Windows-only (DirectX 12), and the quality preset mapping between vendors isn't always perfect. "Balanced" in DirectSR maps to each vendor's "Balanced" equivalent, but those aren't identical in internal resolution or quality. You lose fine-grained control.

Should You Use DirectSR or Individual Integrations?

Use DirectSR if:

• You want the simplest possible integration
• You're targeting PC-only with DirectX 12
• You don't need per-vendor quality tuning
• You want automatic support for future upscaling technologies without code changes

Use individual integrations if:

• You need per-vendor quality control (e.g., different default presets per GPU)
• You're shipping on platforms beyond Windows PC
• You want to support Frame Generation with per-vendor latency tuning
• You need to support older OS versions that may not have DirectSR

Our recommendation: For most indie developers, DirectSR is the right choice. The per-vendor quality differences are minor enough that players won't notice, and the integration simplicity saves significant time. If you're a studio with dedicated graphics programmers who want to squeeze every last bit of quality, individual integrations give you more control.

Plugin Installation and Configuration in UE5.7

Let's get practical. Here's how to set up all three upscalers in a UE5.7 project.

Prerequisites

• Unreal Engine 5.7 (source or binary)
• Windows 10/11 with DirectX 12
• Latest GPU drivers for your test hardware
• The DLSS, FSR, and XeSS UE5 plugins (distributed via NVIDIA/AMD/Intel developer portals and/or the Epic Marketplace)

Method 1: DirectSR Integration (Recommended for Most Projects)

DirectSR support is built into UE5.7's RHI (Rendering Hardware Interface) layer. Here's the setup:

Step 1: Enable the DirectSR plugin.

In the UE5.7 editor, go to Edit → Plugins and search for "DirectSR". Enable the plugin and restart the editor. The plugin name may appear as "DirectX Super Resolution" in some builds.

Step 2: Configure project settings.

Navigate to Project Settings → Engine → Rendering → Super Resolution:

• Set "Super Resolution API" to "DirectSR"
• Set "Default Quality Preset" to "Balanced" (a good default for most games)
• Enable "Allow User Quality Override" so players can change the preset in your settings menu
• Set "Minimum Display Resolution" to your target (usually 1080p or 1440p)

Step 3: Add UI controls.

Your graphics settings menu needs a super resolution toggle. At minimum, expose:

• Off: Native rendering, no upscaling
• Quality: Highest visual quality, smallest performance gain
• Balanced: Good balance of quality and performance (recommended default)
• Performance: Maximum performance, acceptable quality loss
• Ultra Performance: For very low-end hardware or very high target resolutions

In Blueprint, you can access DirectSR settings through the UGameUserSettings class. The relevant functions are SetSuperResolutionQuality() and GetSuperResolutionQuality().

Step 4: Test on multiple GPU vendors.

This is critical. Test your DirectSR integration on at least one NVIDIA, one AMD, and (ideally) one Intel GPU. The quality preset mapping should work automatically, but visual artifacts can differ between vendors, and you may need to adjust your sharpening or post-process settings per vendor.

Method 2: Individual Plugin Integration

If you need per-vendor control, here's how to set up each upscaler individually.

NVIDIA DLSS 4

Step 1: Download the DLSS UE5 plugin from NVIDIA's developer portal (developer.nvidia.com). The plugin package includes the DLSS DLLs, UE5 plugin module, and sample project.

Step 2: Install the plugin. Copy the plugin folder to your project's Plugins/ directory. The folder structure should be:

YourProject/
  Plugins/
    DLSS/
      DLSS.uplugin
      Source/
      Libraries/
      ...

Step 3: Enable in the editor. The plugin should appear in Edit → Plugins under "NVIDIA DLSS". Enable it and restart.

Step 4: Configure DLSS settings. In Project Settings → Plugins → NVIDIA DLSS:

• Enable DLSS Super Resolution
• Enable DLSS Frame Generation (if targeting RTX 40/50-series)
• Enable DLSS Ray Reconstruction (if using hardware ray tracing)
• Set the Application ID (obtained from NVIDIA's developer portal)

Step 5: Blueprint/C++ API. The DLSS plugin exposes Blueprint nodes:

• Set DLSS Mode — sets the quality preset (Off, Quality, Balanced, Performance, Ultra Performance)
• Is DLSS Supported — checks hardware support at runtime
• Get DLSS Mode Info — returns current mode, internal resolution, and upscale ratio
• Set DLSS Frame Generation Mode — controls Frame Generation (Off, On)

AMD FSR 4

Step 1: Download the FSR UE5 plugin from AMD's GPUOpen developer portal (gpuopen.com/fidelityfx-super-resolution).

Step 2: Install the plugin. Same process as DLSS — copy to your Plugins/ directory.

Step 3: Enable and configure. The FSR plugin in UE5.7 supports both FSR 4 (RDNA 4) and FSR 3.1 (fallback). Configuration is in Project Settings → Plugins → AMD FSR:

• Enable FSR Upscaling
• Enable Fluid Motion Frames (for Frame Generation on supported hardware)
• Set the "Fallback Mode" to FSR 3.1 for non-RDNA 4 GPUs
• Configure sharpness (0.0-1.0, we recommend 0.3-0.5 for most games)

Step 4: Blueprint API:

• Set FSR Quality Mode — same quality presets as DLSS
• Is FSR Supported — hardware check
• Set FSR Sharpness — adjusts the CAS (Contrast Adaptive Sharpening) pass
• Set Fluid Motion Frames Enabled — Frame Generation toggle

Intel XeSS 2

Step 1: Download the XeSS SDK from Intel's developer portal (intel.com/xess).

Step 2: Install. Copy the XeSS plugin to your Plugins/ directory.

Step 3: Enable and configure. Project Settings → Plugins → Intel XeSS:

• Enable XeSS Upscaling
• Set quality mode defaults
• Enable XMX path for Arc GPUs (this should be auto-detected, but verify)

Step 4: Blueprint API:

• Set XeSS Quality Mode — standard quality presets
• Is XeSS Supported — returns true on almost all modern GPUs (DP4a path is very broadly supported)
• Set XeSS Motion Vector Mode — configure motion vector input

Unified Settings Menu for All Three

If you've integrated all three individually, you need a settings menu that auto-detects the GPU and shows the appropriate options. Here's the logic:

On Settings Menu Open:
  If NVIDIA GPU detected:
    Show "DLSS" option (with Frame Generation sub-option if RTX 40+)
    Show "FSR" option as fallback
    Hide "XeSS" (DLSS is better on NVIDIA hardware)
  Else if AMD GPU detected:
    Show "FSR" option (FSR 4 on RDNA 4, FSR 3.1 otherwise)
    Show "XeSS" as fallback option
    Hide "DLSS" (not supported)
  Else if Intel GPU detected:
    Show "XeSS" option (XMX on Arc, DP4a otherwise)
    Show "FSR" as fallback option
    Hide "DLSS" (not supported)
  Else:
    Show "FSR 3.1" (most broadly compatible)
    Show "XeSS DP4a" as alternative

This is more work than DirectSR, but it gives players the best default for their hardware while still offering choice.

MCP Automation of Project Settings

Setting up upscaler configurations involves touching dozens of project settings, plugin configurations, and per-platform overrides. This is exactly the kind of tedious, error-prone work that the Unreal MCP Server can automate.

Automated Configuration

With the Unreal MCP Server's 207 tools across 34 categories, you can script the entire setup process. Instead of clicking through Project Settings menus, you can describe what you want:

"Enable DLSS, FSR, and XeSS plugins. Set DirectSR as the default upscaling API. Configure Balanced as the default preset. Set minimum display resolution to 1080p. Enable Frame Generation for DLSS and FSR on supported hardware."

The MCP server translates this into the specific project setting changes, plugin enables, and configuration edits. This is particularly valuable when you're setting up multiple projects or maintaining consistent settings across a team.

Batch Quality Testing

The MCP server can also automate quality testing workflows:

• Switch between upscalers programmatically
• Capture screenshots at each quality preset
• Toggle between vendors for A/B comparison
• Set up automated camera paths (combine with the Cinematic Spline Tool for consistent comparison shots)
• Export settings as presets that can be shared across projects

Per-Platform Configuration

If you're targeting multiple platforms (PC, consoles, Steam Deck), the MCP server can manage per-platform settings:

• PC: DirectSR or individual upscalers
• Xbox Series X/S: FSR is the default (and only) option
• PlayStation 5: FSR via the PlayStation SDK's integration
• Steam Deck: FSR 3.1 with Performance preset as default

Having these configurations managed programmatically means you can update all platforms simultaneously when you change your quality targets.

Common Integration Pitfalls

We've seen a lot of upscaler integrations go wrong. Here are the most common issues and how to avoid them.

Pitfall 1: Incorrect Motion Vectors

All three upscalers rely heavily on per-pixel motion vectors to reconstruct the upscaled image. If your motion vectors are incorrect, you'll get ghosting, smearing, and temporal instability.

Common causes:

• Vertex animation (cloth, vegetation, water) not contributing to motion vectors
• Particle effects with incorrect or missing motion vector data
• Custom materials with World Position Offset not writing motion vectors
• Decals or post-process effects interfering with the motion vector buffer

Solution: UE5.7's default motion vector generation handles most cases correctly. The main thing to watch is custom materials with vertex animation — make sure "Output Velocity" is enabled on any material that moves vertices. For particle effects, ensure "Generate Motion Vectors" is checked in the Niagara system settings.

Pitfall 2: Jittered Rendering Not Applied

Temporal upscalers require jittered sub-pixel camera offsets across frames to reconstruct detail. UE5.7 applies this automatically when an upscaler is active, but some custom rendering setups can break it.

Watch for:

• Custom camera logic that overrides the projection matrix
• Post-process materials that assume stable pixel positions
• Screen-space effects that don't account for jitter
• Custom render targets that bypass the main scene view

Pitfall 3: UI Rendering at the Wrong Resolution

Your UI should be rendered at the output resolution, not the internal rendering resolution. If your UI goes through the upscaler, text will be blurry and icons will have artifacts.

In UE5.7: Slate and UMG widgets render at the display resolution by default and are composited after upscaling. But custom render targets, 3D widget components, and in-world UI elements may render at the internal resolution. Test your UI at Performance mode to catch these issues.

Pitfall 4: Post-Process Order Issues

Some post-process effects should be applied before upscaling (at internal resolution) and others after (at output resolution). Getting this wrong causes visual artifacts.

Before upscaling (internal resolution):

• Color grading and tone mapping
• Bloom (debatable — some prefer post-upscale bloom)
• Ambient occlusion
• Screen-space reflections

After upscaling (output resolution):

• Film grain
• Chromatic aberration
• Vignette
• UI overlay

UE5.7's post-process chain handles this correctly for built-in effects, but custom post-process materials need to be explicitly assigned to the correct pass.

Pitfall 5: Not Providing a "Native" Option

Always give players the option to disable upscaling entirely. Some players prefer native resolution rendering, and some upscaler implementations can introduce artifacts that specific players find unacceptable. A "Super Resolution: Off" option is non-negotiable.

Pitfall 6: Incorrect Default Presets

Don't default to "Performance" mode. Players will judge your game's visual quality based on the default settings, and Performance mode at 4K (which renders at 720p internally) can look noticeably worse than native. Default to "Balanced" or "Quality" and let players choose to trade quality for performance.

Pitfall 7: Not Testing on Low-End Hardware

The whole point of super resolution is enabling higher framerates on weaker hardware. If you only test on your RTX 4080 development machine, you're not testing the scenario that most needs upscaling. Get access to a GTX 1660 or RX 6600 and test your upscaler integration at the quality levels those players will actually use.

Decision Matrix for Indie Developers

Given limited time and resources, here's our recommendation framework:

If You Have Less Than a Day

Use DirectSR. Enable the plugin, set "Balanced" as default, add a quality dropdown to your settings menu. Done. It will automatically use DLSS on NVIDIA, FSR on AMD, and XeSS on Intel. The quality won't be perfectly optimized per-vendor, but it will be good enough for 95% of players.

If You Have 2-3 Days

Integrate DLSS and FSR individually. These cover ~97% of the PC market. Use the auto-detection logic described above to show the right option for each GPU. XeSS DP4a can be added as a fallback, but it's lower priority.

If You Have a Week

Integrate all three with per-vendor tuning. Set up optimal default presets for each vendor, implement Frame Generation support for DLSS and FSR, and do visual quality testing on representative hardware from each vendor.

If Performance Is Your Main Concern

This applies to open-world games, high-fidelity environments, or games targeting 4K. Focus your effort on DLSS and FSR, which have the most mature Frame Generation technologies. The combination of upscaling + Frame Generation can turn 30fps into 120fps+ displayed, which is transformative for the player experience.

If you're using the Procedural Placement Tool for dense environments, upscaling is especially important. Scenes with 100K+ instances of foliage and detail meshes benefit enormously from rendering at lower internal resolution, where the geometry cost is reduced proportionally. The upscaler reconstructs the detail that matters (edges, texture detail, specular highlights) while skipping the brute-force per-pixel rendering cost.

Platform-Specific Recommendations

Steam Deck

The Steam Deck runs on an AMD APU, so FSR is your only upscaling option. Recommendations:

• Default to FSR 3.1 Balanced at the Deck's native 1280x800 resolution
• FSR Performance mode (rendering at ~640x400) is viable for demanding scenes but noticeably soft
• Frame Generation is not available on the Deck's hardware
• Test specifically at 800p output — many upscaler artifacts that are invisible at 4K become obvious at lower resolutions
• The Deck's screen is small enough that Quality and Balanced modes are visually very close

Xbox Series X|S

FSR is available through the GDK. DirectSR is not available on console — you use the FSR SDK directly.

• Series X: Default to FSR Quality at 4K output. The hardware is powerful enough that upscaling is optional for many games, but it provides headroom for ray tracing or other expensive features.
• Series S: FSR Balanced or Performance at 1440p output. The Series S benefits significantly from upscaling due to its weaker GPU.

PlayStation 5

FSR is available through the PlayStation SDK. Additionally, PlayStation has its own upscaling technology (PSSR on PS5 Pro) that should be preferred on that hardware.

• PS5: FSR Quality or Balanced at 4K output.
• PS5 Pro: Use PSSR (PlayStation Spectral Super Resolution) as the default, with FSR as a fallback for players who prefer it.

Nintendo Switch 2

At the time of writing, Nintendo's DLSS implementation for Switch 2 has been confirmed but the full SDK details are under NDA. Given the Switch 2's NVIDIA hardware, expect DLSS to be the primary (and potentially only) upscaling option.

When to Use Which: A Final Decision Guide

Here's a quick-reference guide for choosing upscaler settings:

For your default settings menu, set:

• NVIDIA RTX users → DLSS Balanced
• AMD RDNA 4 users → FSR 4 Balanced
• AMD RDNA 2/3 users → FSR 3.1 Balanced
• Intel Arc users → XeSS 2 Balanced
• Other GPUs → FSR 3.1 Quality (the most broadly compatible at acceptable quality)

For competitive/low-latency games:

• Disable Frame Generation by default (adds latency)
• Default to Quality preset (minimal visual disruption)
• Let players choose to enable FG if they prefer higher displayed FPS over latency

For visual showcase/narrative games:

• Enable Frame Generation by default (visual fluidity matters more than latency)
• Default to Quality preset (image quality is paramount)
• Consider DLSS Ray Reconstruction if you're using hardware ray tracing

For open-world/performance-demanding games:

• Enable Frame Generation by default
• Default to Balanced preset (the sweet spot for most hardware)
• Consider Performance preset on detected low-end hardware

For VR games:

• DLSS is generally preferred for VR due to lower latency
• FSR's Frame Generation adds too much latency for comfortable VR
• Quality or Balanced presets only — aggressive upscaling causes VR discomfort

Automating the Entire Workflow

Setting up, testing, and maintaining upscaler configurations across your project is a recurring task. Every time you update your renderer, change post-process settings, or add new visual features, you should re-test upscaler compatibility.

The Unreal MCP Server can automate much of this maintenance:

• Automated screenshot comparison: Run camera paths at each quality preset, capture screenshots, and flag visual regressions.
• Configuration management: Push upscaler settings to your project settings, scalability settings, and per-platform configs from a single source of truth.
• Build verification: As part of your build process, verify that upscaler plugins are correctly configured and DLLs are included in the build.

Combined with the Cinematic Spline Tool for consistent camera paths, you can build a fully automated upscaler quality regression test that runs on each build.

Scalability Settings and Quality Presets

Beyond the upscaler-specific settings, UE5.7's scalability system needs to work in harmony with your super resolution integration. The engine's scalability groups (Low, Medium, High, Epic, Cinematic) affect rendering load, which in turn affects how much performance headroom the upscaler provides.

Recommended Scalability Pairings

The interaction between scalability and upscaler preset matters more than either setting alone. Here are the pairings we recommend:

For players on RTX 3060 / RX 6700 class hardware at 1440p:

• Scalability: High
• Upscaler: Balanced
• Frame Generation: Off (insufficient base framerate for smooth FG)
• Expected result: 55-70fps, good visual quality

For players on RTX 4070 / RX 7800 XT class hardware at 4K:

• Scalability: Epic
• Upscaler: Balanced
• Frame Generation: On
• Expected result: 60fps rendered, 120fps displayed, excellent visual quality

For players on GTX 1660 / RX 580 class hardware at 1080p:

• Scalability: Medium
• Upscaler: Quality (upscaling from 720p to 1080p is a modest ratio)
• Frame Generation: Not available on this hardware
• Expected result: 45-60fps, acceptable visual quality

For Steam Deck at 800p:

• Scalability: Medium-Low (custom preset)
• Upscaler: FSR 3.1 Balanced
• Frame Generation: Not available
• Expected result: 30-40fps, optimized for handheld

Auto-Detection and Benchmarking

The best approach for players is an automatic settings system that runs a brief benchmark on first launch and selects appropriate scalability + upscaler pairings. UE5.7's hardware detection APIs can identify the GPU model, VRAM, and approximate performance tier. Combined with a 5-second render benchmark of a representative scene, you can set intelligent defaults.

The Unreal MCP Server can help build this auto-detection system by configuring the benchmark scene, setting up the detection logic, and mapping hardware profiles to preset combinations. This is the kind of settings infrastructure that every PC game needs but few indie developers enjoy building manually.

Shader Compilation and Upscaler Interaction

One last technical note: shader compilation stutters interact poorly with temporal upscalers. When a new shader compiles and causes a frame hitch, the upscaler's temporal history is disrupted, often causing a visible flash or artifact that's worse than the stutter alone.

UE5.7's Pipeline State Object (PSO) pre-caching helps mitigate this, but you should still test your game's shader compilation behavior with upscalers active. Pre-cache as many PSOs as possible during loading screens, and consider enabling UE5.7's background shader compilation with reduced priority to minimize in-gameplay compilation events.

Conclusion

Supporting DLSS 4, FSR 4, and XeSS 2 in UE5.7 is more straightforward than it has ever been, thanks to DirectSR and mature engine-level integration. The quality gap between the three technologies has narrowed significantly — any of them is a massive improvement over no upscaling.

For most indie developers, the practical recommendation is: use DirectSR for the simplest integration, or integrate DLSS + FSR individually if you want per-vendor control. Test on actual hardware from each vendor. Default to Balanced mode. And always give players the option to turn upscaling off.

Super resolution isn't optional in 2026. It's a baseline expectation. The good news is that the integration work has never been easier, and the performance gains have never been larger. Your game looks better and runs faster — that's a rare win-win in rendering.