XeSS (Xe Super Sampling) is a spatial-temporal image scaling technology. In simple terms, the video card renders the game at a lower resolution, and a special neural network-based algorithm reconstructs the picture to a high resolution, significantly increasing the frame rate without critical loss of quality.
The technology is used in modern computer games that support DirectX 12 and Vulkan APIs. It is universal and works on discrete Intel Arc video cards with built-in XMX matrix engines, as well as on any competitor video cards that support DP4a instructions, including NVIDIA and AMD solutions. Integration into engines occurs through an open cross-platform toolkit, which simplifies its implementation by developers.
When used on unsupported hardware without dedicated XMX blocks, the main problem manifests itself: the balance between performance gain and quality shifts for the worse. Rendering takes more time, and with aggressive performance settings, noticeable flickering of fine details, ghosting (trails behind moving objects), and particle dissociation can occur. Early versions of the SDK also demonstrated instability on semi-transparent textures.
How XeSS works
The operating principle of XeSS is similar to NVIDIA DLSS and AMD FSR 2+, but has key architectural differences. Like its competitors, XeSS uses information from the current low-resolution frame, motion vectors, and depth buffers, combining them with historical data from previous frames (jittering). Unlike the fully software-based FSR 2, the core of XeSS is a neural network trained to reconstruct details, which makes it akin to DLSS. However, unlike proprietary DLSS, XeSS does not require a specialized hardware block of tensor cores: the XMX path uses acceleration on Intel Arc matrix math, delivering reference quality and speed, while the cross-platform DP4a path allows the neural network to execute on the general-purpose compute blocks of other manufacturers’ video cards. Network training occurs on an extensive set of reference ultra-high-resolution images, which allows the algorithm to intelligently draw fine textures, wiring, and grids absent from the low-resolution source data, minimizing the difference from native rendering.
XeSS functionality
- Spatial upscaling using a neural network. The XeSS algorithm reconstructs each frame from an input resolution lower than native to the target output. The core of the method is a convolutional neural network trained to restore high-frequency details lost during rendering, minimizing deviations from a reference ultra-high-quality image.
- Motion vector and historical buffer consideration. To enhance the stability of frame sequences, the mechanism receives object motion vectors, the depth buffer, and color data from the previously reconstructed frame as input. Motion-compensated subpixel sampling from the historical buffer suppresses flickering and ghosting of fine geometric structures.
- Modified accumulation feedback. Instead of standard exponential filtering, a weighted blending of the current raw pixel with historical data is used, where the weight is determined by a confidence map. The network dynamically adjusts the contribution of past samples, breaking the dependency if the photometric offset exceeds an adaptive threshold, preventing trails behind moving objects.
- Internal model architecture. The base DP4a model uses accelerated integer dot product with accumulate instructions for fast inference on a wide range of graphics processors. The advanced XMX model utilizes the specialized matrix engines of the Intel Arc architecture, performing block matrix multiplication operations on low-precision INT8 tensors for maximum utilization of the compute array.
- Multi-class pixel classifier. The network implicitly segments the scene into areas with different characteristics: smooth sky gradients, areas of subpixel vegetation, high-contrast silhouette edges. For each class, a non-linear restoration kernel is applied, suppressing aliasing artifacts without excessive texture blur.
- High dynamic range processing and tone mapping. Input data is received in linear HDR color space prior to the tone mapping stage. The network operates on raw luminance values, excluding the non-linearities of perceptual compression. The output tensor is additionally passed through a lightweight module approximating local tone mapping to improve detail readability in deep shadows.
- Learning rate control during the optimization stage. XeSS models were trained using a cyclical convergence rate scheduler, varying the step size between boundaries to avoid narrow local minima of the loss function. The combination of perceptual loss taken from a pre-trained VGG network and spatial L1-norm guarantees structural correspondence to the reference.
- Contrast sensitivity-based loss function. The error metric takes into account the frequency-dependent susceptibility of human vision. High-frequency frame components receive a larger penalty coefficient than low-frequency fills. This approach forces the network to expend peak representation accuracy on contours and micro-texture critical for perceived sharpness.
- Native anti-aliasing mode. When a frame of target resolution is submitted without scaling, XeSS functions as an advanced temporal anti-aliasing. The algorithm replaces edge detection heuristics with the fuzzy logic of a neural network module, eliminating the stair-stepping of polygonal edges and shader aliasing with quality exceeding standard TAA.
- Depth map as an occlusion predictor. The scene’s Z-buffer serves as an additional input channel, allowing the attention mechanism to detect sharp depth discontinuities at object junctions. Given significant parallax between foreground and background, the network forcibly resets the pixel’s history, preventing projection errors and halos.
- Projection matrix jitter. To ensure the uniqueness of subpixel samples for each frame, the driver communicates a fractional pixel offset of the view matrix to the application using a pseudo-random Halton sequence. This introduces controlled dispersion into rasterization coordinates, giving the neural network redundancy to extrapolate details beyond the sampling limit.
- Predictive sampling from high-resolution textures. Unlike bilinear interpolation, XeSS performs adaptive filtering of environment maps and albedo based on luminance gradients. The decoding module reconstructs normals and micro-relief baked into mip-levels, restoring specular highlights of materials without increasing the set of texture coordinates.
- User interface scaling. Overlay elements are output after the upscaling module at the display’s native resolution, bypassing neural network processing. Fonts, icons, and the radar remain perfectly sharp, while the 3D scene underneath undergoes reconstruction, excluding rasterization artifacts on contrasting text boundaries.
- Dynamic resolution control system. Upon activating a target frame rate profile, the driver continuously measures frame rendering time and commands the application to vary the input resolution in real time. XeSS compensates for pixel density fluctuations, smoothing transitions between different scaling factors imperceptibly to the player.
- Optimization for heterogeneous architectures. The inference code is adapted to the thread scheduler specifics of various APIs. In the DirectX 12 environment, command placement in the copy queue with synchronization via fences is used, and in Vulkan, the timeline semaphores extension is used for pipeline parallelism of graphics and compute queues without idle bubbles.
- Intra-frame disparity and stereoscopic rendering. For virtual reality applications, a single tensor is submitted, combining the maps for the left and right eyes. The network calculates disparity maps for parallax, reusing features from one eye during the synthesis of the other, which reduces computational redundancy compared to separate invocation of two passes.
- Hardware acceleration on the XMX engine. The Xe Matrix eXtensions blocks perform convolution operations on fp16 and int8 format tensors with throughput up to hundreds of trillions of operations per second on the ACM-G10 die. Specialized shared on-die memory minimizes accesses to global memory during convolution, reducing layer computation latency by an order of magnitude.
- Matrix (Storing data in tabular form)
- Compatibility parameters and quality levels. The interface includes presets: Ultra Performance with a 3.0x factor for portable devices, Balanced with 2.0x, and Ultra Quality with 1.3x for minimal losses. Each level loads a model with a different number of filters in the hidden layers, balancing inference time and edge restoration accuracy.
- Vendor independence via the DP4a standard. The implementation based on dp4a instructions does not require specialized tensor cores and executes on graphics hardware with Shader Model 6.4 support, including competitor products. The mixed-precision representation with int32 accumulation ensures numerical stability equivalent to floating point, with lower energy consumption of the arithmetic blocks.
Comparisons
- XeSS vs DLSS. Intel XeSS technology uses a hybrid approach with spatial upscaling and a neural network model running on XMX or DP4a cores. Unlike proprietary DLSS from NVIDIA, which requires tensor cores, XeSS demonstrates broader hardware compatibility, at the cost of slightly lower image stability in motion on video cards without specialized matrix accelerators.
- XeSS vs FSR. The principal difference between XeSS and AMD FidelityFX Super Resolution lies in the algorithmic foundation. FSR versions 2.x and newer use an analytical temporal method without machine learning. This provides FSR with full cross-platform capability, whereas the AI-based XeSS produces a more detailed image with fewer artifacts on fine geometric structures.
- XeSS vs TSR. Temporal Super Resolution from Epic Games operates with information from the Unreal Engine, accessing motion vectors and depth buffers at the rendering level. XeSS functions as an external post-effect, not requiring deep integration, which simplifies implementation in various projects. However, TSR’s access to the engine’s internal data allows it to reconstruct geometry more accurately in some scenarios.
- XeSS vs PSSR. PlayStation Spectral Super Resolution is a machine learning solution deeply optimized for the console’s unified GPU architecture. Unlike XeSS, which must account for the variability of the PC market, PSSR achieves more predictable performance due to fixed hardware. XeSS, in turn, provides flexible quality presets, adapting to the performance of a wide range of graphics processors.
- XeSS vs MetalFX. Apple-developed MetalFX Spatial and Temporal uses the neural engine of M-series chips. Comparison with XeSS reveals an ecosystem difference: Intel’s solution is aimed at the high-performance gaming PC segment with ray tracing tasks, while MetalFX is focused on energy-efficient upscaling under the thermal constraints of mobile devices, balancing quality and power consumption.
OS and drivers
XeSS is implemented at the level of the Intel Arc graphics driver and the integrated graphics of Core Ultra processors, which ensures its operation in Windows 10/11 via DirectX 12 and Vulkan interfaces. On Linux, support is provided through the open-source runtime environment in Mesa and the ANV driver, where scaling is integrated into Vulkan extensions. The driver intercepts rendering calls at the post-processing stage, substituting the standard frame resolution with the target one using a pre-loaded neural network model, the format of which depends on available hardware instructions.
Security
XeSS security is ensured by the isolated execution of the neural network within the user mode of the driver, without access to kernel system memory or the file system. The graphics driver loads precompiled blobs of XMX or DP4a models from a protected Intel repository into the ring of GPU commands, where they work exclusively with pixel buffers. All interactions with the game process occur through standard graphics APIs, which excludes malicious code injections at the scaling stage.
Logging and debugging
Logging functions through the standard tracing mechanism of the Intel Graphics Control Panel, where XeSS initialization events, model loading, and fault states are recorded in the Windows Event Tracing system log. When advanced debugging mode is enabled, the driver records timestamps for the execution of each scaling pass, the amount of occupied video memory, and neural network initialization error flags. The Intel GPA toolkit allows developers to visualize intermediate buffers of motion vectors, depth maps, and the final image in real time for artifact diagnostics.
Hardware and software limitations
The DP4a instruction version of XeSS works on most video cards with Shader Model 6.4 support, but performance drops proportionally to the absence of specialized XMX matrix blocks, which are only present in discrete Intel Arc GPUs. The source frame resolution is limited by a minimum threshold, below which the neural network cannot reconstruct scene geometry due to a lack of pixel information for motion vectors. Applications using non-standard depth buffers or asynchronous compute queues may fail scaling initialization during the compatibility check stage.
Architecture evolution
The history of XeSS began with an announcement in 2021 as a response to DLSS, when Intel introduced an architecture based on a convolutional autoencoder with a temporal accumulation mechanism, trained on synthetic and real data with a resolution of 64 samples per pixel. Version 1.1 introduced an updated model with reduced haloing and optimization for moving light sources, while version 1.3 transitioned to a new reprojection grid and a reworked Anti-Ghosting algorithm, reducing blur on fast-moving objects. Further development integrated frame generation support and Low Latency technology, transforming XeSS into a comprehensive rendering platform with feedback from the frame buffer.