DLSS 5 Runs on Intel Arc 140V iGPU at 2.4 FPS
Nvidia’s DLSS 5 neural rendering pipeline has now been experimentally ported to Intel integrated graphics, demonstrating that the technology can execute outside Nvidia’s CUDA and NGX software ecosystem.
A GitHub research project named dlss-nr-on-intel successfully runs the DLSS 5 neural rendering pipeline on Intel’s Xe2-based Arc 140V integrated GPU. Instead of relying on Nvidia hardware or the original NGX runtime, the project reimplements the neural-network execution path using Vulkan and Intel’s XMX matrix engines.
The result is technically significant but far from practical for gaming. At 1920×1080 output resolution, the neural-rendering stage takes approximately 412 ms per frame, equivalent to only about 2.4 FPS before accounting for the game’s own rendering workload.
The project therefore currently serves primarily as a proof of concept for cross-vendor neural rendering rather than a playable DLSS 5 implementation.
🧠How DLSS 5 Was Ported to Intel #
The project targets the Arc 140V, an integrated GPU used with Intel’s Lunar Lake platform. The GPU contains eight Xe2 cores and is distinct from newer discrete Arc products based on subsequent Xe architectures.
Rather than wrapping Nvidia’s DLSS DLLs, the project takes a more fundamental approach: it reimplements the 71 U-Net neural networks used by the DLSS 5 neural-rendering pipeline.
The implementation uses the Vulkan extension VK_KHR_cooperative_matrix to access Intel Arc’s XMX matrix engines, which are designed to accelerate matrix-oriented workloads such as AI inference.
Intel’s GPU architecture provides the hardware primitives required for this approach. XMX acceleration is available across relevant Arc discrete and integrated graphics products, making Vulkan-based neural workloads possible without depending on Nvidia-specific CUDA execution paths.
Vulkan interception architecture #
The project operates under Linux and uses a Vulkan interception layer to capture frame data during presentation.
Captured frames are then passed to a separate process responsible for running the neural networks on the GPU’s XMX hardware. This architecture separates the neural-rendering implementation from the original application’s graphics pipeline.
Because Proton can translate Windows games to Vulkan-based execution on Linux, the approach can also be used with Windows games running through environments such as DXVK and VKD3D-Proton.
The developers have already demonstrated the technique with games including Tekken 7, Dead or Alive 5: Last Round, and Mortal Kombat 1.
Nvidia model weights are still required #
Although the execution runtime itself is independent of Nvidia’s CUDA and NGX stack, the project is not completely free of Nvidia-derived components.
The repository does not distribute Nvidia binaries or the neural-network weights. Users must therefore manually extract the required weights from an existing nvngx_dlssnr.dll.
This distinction is important: the project demonstrates that the neural-rendering workload can execute on Intel hardware without Nvidia’s runtime, but it does not constitute a completely independent recreation of every component involved in DLSS 5.
The developers explicitly describe the project as a research port, rather than a consumer-ready DLSS replacement.
âš¡ Severe Performance Bottlenecks #
The biggest limitation is currently performance.
At 1920×1080 output resolution with a 0.55 render scale, the neural-rendering stage alone requires approximately 412 ms per frame. That corresponds to a theoretical throughput of only about 2.4 FPS, before the game’s conventional rendering workload is included.
Reducing the output resolution improves performance substantially, but the results remain far below normal gaming requirements.
| Output Resolution | Approximate Neural Rendering Time | Approximate Performance |
|---|---|---|
| 1920×1080 | 412 ms/frame | 2.4 FPS |
| 1024×768 | 168 ms/frame | ~6 FPS |
| 640×360 | — | 12.5–13.5 FPS |
| 512×288 | — | ~14 FPS |
The numbers illustrate how strongly the neural-rendering workload scales with output resolution.
At 640×360, the project reaches approximately 12.5–13.5 FPS depending on the render scale. Reducing the output further to 512×288 brings performance close to 14 FPS.
These figures still exclude some of the overhead associated with running an actual game.
Real-world game performance is lower #
In an actual Tekken 7 test, the setup reportedly reaches approximately 10.5 FPS at 640×360.
This gap between isolated neural-rendering measurements and complete game performance highlights an important limitation of the current implementation. Neural rendering is only one component of the overall frame-generation or rendering pipeline, and the game itself introduces additional CPU and GPU workloads.
As a result, the already-low standalone neural-rendering throughput does not translate directly into equivalent in-game performance.
Output resolution remains a major bottleneck #
One reason reducing the internal render resolution provides limited relief is that several stages of the neural-rendering pipeline continue to operate at the full output resolution.
Consequently, lowering the resolution at which the game initially renders does not eliminate the computational cost associated with processing the final output frame.
This characteristic makes output resolution a major determinant of the current implementation’s execution time. On the Arc 140V, the available XMX compute resources are simply insufficient to process the complete neural workload at conventional gaming resolutions within an acceptable frame budget.
🔬 What the Intel Port Actually Proves #
The current implementation demonstrates an important architectural point: neural rendering itself is not inherently restricted to Nvidia hardware.
DLSS is normally associated with Nvidia GPUs because Nvidia controls both the neural-rendering algorithms and the hardware/software stack used to execute them. By recreating the neural-network execution path and mapping it to Intel’s XMX hardware through Vulkan, the project demonstrates that the underlying computation can be performed on another GPU architecture.
However, this should not be interpreted as evidence that Intel GPUs currently deliver DLSS-class performance for this workload.
The Arc 140V is an integrated GPU designed for a mobile processor, and its available compute resources are substantially different from those of high-end discrete graphics cards. The current benchmark therefore primarily validates compatibility rather than performance scalability.
Discrete Intel GPUs remain an open question #
The developers note that the current measurements are specific to the Arc 140V and should not be interpreted as representative of Intel’s entire GPU lineup.
Discrete products such as the Arc B580 provide considerably different hardware resources and may support the required XMX and Vulkan functionality. However, without corresponding real-world benchmark results from the project, their actual DLSS 5 neural-rendering performance cannot yet be established.
This distinction is important when evaluating the project’s potential. A successful iGPU proof of concept establishes that the software architecture works, but it does not establish how efficiently the implementation scales to larger XMX configurations.
🔄 DLSS 5 Beyond Nvidia Hardware #
This Intel port follows earlier efforts to execute DLSS 5 neural rendering on AMD Radeon RX 9000 and RX 7000 series GPUs.
Those projects likewise rely on reimplemented or alternative runtimes rather than directly executing Nvidia’s native implementation. Taken together, these efforts demonstrate that the neural computations underlying modern rendering pipelines can potentially be mapped to different GPU architectures.
However, hardware comparisons must account for the enormous differences between the platforms involved.
For example, comparing a Radeon RX 9070 XT with an Arc 140V would not provide a meaningful measure of architectural compatibility or efficiency because the former is a high-performance desktop discrete GPU, while the latter is an integrated GPU sharing a mobile processor’s power and thermal envelope.
The more useful conclusion is therefore about software portability, not absolute GPU performance.
🚧 Proof of Concept, Not a Gaming Solution #
The dlss-nr-on-intel project represents a notable technical demonstration of cross-platform neural rendering. It successfully executes the DLSS 5 neural-rendering pipeline on Intel’s Arc 140V without depending on Nvidia’s CUDA or NGX runtime.
At the same time, its current performance makes clear how much optimization remains necessary.
With approximately 2.4 FPS at 1080p for the neural-rendering stage alone, the implementation is nowhere near practical gaming performance on the Arc 140V. Lowering the output resolution improves throughput, but even the resulting frame rates remain unsuitable for normal gameplay.
For now, the project’s primary value is demonstrating that Nvidia’s neural-rendering workload can be mapped onto Intel XMX hardware through Vulkan. Future optimization, better workload scheduling, more efficient neural-network execution, and testing on substantially more powerful discrete Intel GPUs will determine how far this proof of concept can ultimately scale.