Introducing Adreno Neural Fusion SDK for Snapdragon mobile platforms
Co-written with Rob Van Reenen, Jacob Yenney, Jeremy Williams, Angel Tamarit Porter, Philipp Nagele.
Mobile GPUs in games spend most of their power budget on shading. Push the target resolution up and thermals climb. Push the frame rate up and the battery drains. Lowering the render resolution was the only real option for recovering efficiency, and it came with a visible cost in image quality.
Adreno Neural Fusion (ANF) addresses this with two AI-based techniques: Super Resolution (SR) and Frame Generation (FG), each running as GPU compute dispatches on Adreno hardware. SR reconstructs a full-resolution output from a half-resolution jittered input. FG synthesizes an intermediate frame between two consecutively rendered frames.
A title running both SR and FG renders at half resolution and generates half as many real frames but delivers full-resolution output at double the submitted frame rate.
ANF is supported on Snapdragon 8 Elite Gen 6 and higher — with broader support planned farther down our platform roadmap.
Temporal super resolution
ANF SR is a temporal upscaler. The reconstruction model accumulates subpixel samples across multiple frames to recover details the rasterizer never produced in any single pass.
Each frame, the camera's projection matrix is shifted by a small offset, distributed within [-0.5, 0.5] pixels in X and Y. Low-discrepancy sequences, Halton or Sobol, distribute those samples evenly across the pixel area. Random jitter is technically valid, but produces uneven coverage that degrades reconstruction over time.
Over a sequence of frames, each shift gives the model a slightly different subpixel view of the same geometry. The model uses that accumulated history to reconstruct high-frequency detail that the half-resolution rasterizer cannot produce alone: thin features, Nyquist-frequency surface patterns, fine subpixel geometry.
SR takes four inputs per frame: the jittered color buffer at half resolution, the jittered depth buffer at half resolution, motion vectors at half resolution without jitter, and the scalar jitter offset for the current frame. Output is a single full-resolution color image.
ANF does not add any size restrictions. When configuring SR, the game supplies input and output dimensions that match the selected technique's scaling factor.
Sign up for Developer monthly newsletter
Join thousands of developers around the globe who receive latest news and updates from our monthly curated newsletter.
?$QC_Responsive$&fmt=png-alpha)
Motion vectors are what make temporal accumulation work. Without accurate reprojection, historical samples land on the wrong pixels leading to ghosting artifacts. ANF expects full-scene motion vectors, static objects included, using standard clip-space delta math.
The model uses those vectors with depth to detect disocclusion: when a moving object reveals geometry that was previously hidden, historical samples behind that surface are invalid, and the model falls back to a local neighborhood estimate rather than blending stale history into the output.
The same discard logic applies to lighting that changes without corresponding geometry motion, shadows crawling across static surfaces, flickering particle effects, and to transparent objects, where the RGB signal is structurally decorrelated from depth and motion vector data.
Post-processing and UI are excluded from SR inputs. The model operates on the raw scene before tone mapping because those operations belong at full resolution on the upscaled output. UI is excluded because it is screen-space geometry with no valid depth or motion vector signal. Both are composited onto the SR output after the technique dispatch completes, which matches the pass ordering most modern rendering pipelines already use.
Temporal frame generation
FG takes two consecutively rendered full-resolution frames and synthesizes the frame between them, at the cost of one additional rendered frame's worth of input latency. The initial SDK release produces one interpolated frame per real frame.
FG runs after post-processing; on frames the SR stage or the native rasterizer has already produced at full resolution. Its inputs are the post-processed color buffers from frame N-1 and frame N, and the depth and the motion vectors from frame N.
The model estimates where every surface sat at the midpoint between the two frames and warps from both directions to produce the intermediate output. Depth provides the occlusion signal: surfaces visible in frame N, but hidden in N-1 cannot be warped from history and must be inferred from surrounding context. UI is composited after.
Come for support, stay for the community
Get support from experts, connect with like-minded developers, and access exclusive virtual events.
Motion vector precision affects interpolation quality directly. FP16 is the ideal format, with a value of 1.0 representing a full-screen displacement. Coarser precision introduces estimation error that compounds in fast-moving scenes, where a wrong midpoint warp produces visible artifacts in the synthesized frame.
The technology behind Adreno Neural Fusion
Both SR and FG dispatches record into a primary VkCommandBuffer outside of any render pass, either inline by the application or submitted directly by ANF in immediate dispatch mode. The input buffers, color, depth, and motion vectors, are already resident in GPU memory from the preceding render passes. Output writes back into GPU memory.
On devices with Adreno matrix cores, the model inference runs directly on its hardware: AI-dedicated matrix multiplies units built into the Adreno GPU. Although Snapdragon has had matrix acceleration on the NPU and CPU for several generations, this is the first time Adreno has carried dedicated matrix hardware on the GPU itself, where the rendered frame data already lives.
The model reads the color, depth, and motion vector buffers that the render passes just wrote, runs inference, and writes the output without transferring data to a separate processor. During the dispatch, ANF takes ownership of Adreno High Performance Memory (HPM), a dedicated on-chip memory layer that debuted with Snapdragon 8 Elite, purpose-built for the GPU. This is our persistent tile memory.
Intermediate model tensors and reconstruction state stay in that on-chip pool across the dispatch rather than spilling to system memory. Applications must release any HPM they hold before dispatching ANF and should treat VkCommandBuffer state as undefined after the dispatch returns, rebinding pipelines, descriptor sets, and any other state that subsequent rendering depends on.
This data locality is central to the architecture. HPM provides a dedicated on-chip memory pool close to the GPU’s compute hardware, allowing ANF to retain intermediate tensors and reconstruction state locally instead of repeatedly spilling them to LPDDR. Avoiding those external-memory writes and subsequent reads reduces memory traffic and power consumption, benefits that become especially important for models that run every frame.
On devices without matrix cores, ANF may route the same techniques through the NPU via GPU-NPU interop (Graph Pipelines). The framework selects the optimal path automatically based on the physical device capabilities reported at technique creation time. The API is the same either way.
Integration and Profiling
ANF uses the same inputs standardized by temporal upscalers and frame generators: color, depth, and motion vectors. For titles that already ship one of these techniques, those buffers are typically already produced in the format ANF expects. The integration work is therefore primarily about ordering: ensuring post-processing and UI are applied at the right stage, verifying that jitter is applied correctly to the projection matrix, and confirming that motion vectors provide full-scene coverage, including static geometry.
The ANF SDK brings together the integration and profiling resources for Vulkan, the Unreal Engine plugin across UE5 versions, Unity 6.6+, and Snapdragon Profiler.
A debug overlay built into the SDK is available; it composites motion-vector heatmaps, depth visualization, warp and reprojection views, and jitter-accumulation views directly onto the upscaled output. This lets developers verify input correctness before evaluating reconstruction quality.
Sustained clocks and longer sessions
Rendering at a lower internal resolution reduces the number of pixels the GPU needs to shade per frame. This lowers rasterization work and memory bandwidth demand, helping reduce power draw and slow heat buildup during extended play. With less sustained thermal pressure, the device is less likely to reduce GPU clocks to remain within its thermal limits.
Frame Generation improves perceived smoothness by inserting generated frames between rendered frames, without requiring the game to render another full scene frame.
Together, these techniques provide a more efficient path to higher apparent frame rates and steadier performance over longer play sessions, while preserving GPU budget for the work that still needs to be rendered.
Getting started
ANF is available now for developers who want to explore what AI-based super resolution and frame generation can bring to their games. Start with the SDK, samples, and documentation at https://github.com/SnapdragonGameStudios/adreno-neural-fusion, then try it in your own rendering pipeline.
We’d love to see what you build: Join the Qualcomm Developers Discord Server to talk with the community, ask questions, and share feedback, or subscribe through the Snapdragon Gaming contact form for news and updates.
You can also reach out via the contact form.
