The boundaries separating proprietary hardware ecosystems are beginning to blur as independent developers push the limits of modern graphics processing units (GPUs). In a fascinating technical achievement, a modder has successfully managed to run NVIDIA’s highly proprietary DLSS 5 Neural Rendering technology on an Intel Arc 140V integrated graphics processor (iGPU). This feat showcases the potential of cross-hardware compatibility, demonstrating that advanced neural network-based rendering pipelines can be executed on non-NVIDIA silicon without relying on the green team’s closed-source software libraries.
The breakthrough was shared by Reddit user u/UzbekUnknown, who developed an open-source project dubbed "dlss-nr-on-intel". The project targets the integrated Arc 140V GPU, which is built into Intel’s latest Lunar Lake mobile processors. Traditionally, NVIDIA’s Deep Learning Super Sampling (DLSS) suite—including its advanced neural reconstruction and denoising algorithms—is strictly locked to GeForce RTX hardware, relying on proprietary APIs like CUDA and the NVIDIA NGX runtime. However, this community-driven project bypasses those restrictions entirely, porting the neural rendering pipeline to run natively on Intel’s Xe2 graphics architecture.
To fully appreciate the complexity of this achievement, it is helpful to understand what neural rendering and modern reconstruction entail. Over the last several years, the video game industry has shifted away from traditional spatial upscaling techniques toward deep learning-based temporal reconstruction. While early iterations of upscalers relied on basic heuristic algorithms, modern solutions leverage artificial intelligence to analyze previous frames, motion vectors, and depth buffers to reconstruct high-resolution images from lower-resolution inputs. Neural rendering represents the bleeding edge of this paradigm, utilizing deep neural networks to handle complex tasks such as denoising ray-traced shadows, reflections, and global illumination, as well as generating intermediate frames to boost perceived performance.
How the Technology Works
The key to this achievement lies in abstraction layers and industry-standard APIs. Instead of attempting to translate CUDA code directly, the "dlss-nr-on-intel" project implements a custom Vulkan layer. This layer intercepts the game’s rendering pipeline directly at the presentation stage, allowing the mod to function without needing NVIDIA’s proprietary CUDA or NGX libraries.
The project reconstructs the 71-block U-Net architecture that forms the backbone of DLSS’s Neural Rendering model. U-Net is a type of convolutional neural network commonly used in computer vision for image-to-image translation and reconstruction tasks. To run this massive network on Intel’s hardware, the developer utilized the "VK_KHR_cooperative_matrix" Vulkan extension. This extension allows the GPU to perform cooperative matrix multiply-accumulate operations, which are essential for accelerating deep learning workloads.
The execution utilizes FP16 (half-precision floating-point) and FP32 (single-precision floating-point) accumulations to process the neural network’s mathematical operations. By leveraging these standard formats, the workload can be offloaded directly to Intel’s hardware-based Xe Matrix Extensions (XMX) engines. These XMX engines are specialized matrix-math accelerators built into the Xe2 architecture, serving a highly similar functional purpose to NVIDIA’s Tensor Cores.
Crucially, the entire pipeline is integrated into Vulkan-supported games using the "vkQueuePresentKHR" hook. This function hook allows the custom Vulkan layer to intercept the finished frame before it is presented to the display, run the neural rendering reconstruction model, and then output the enhanced frame to the screen. Because it operates at the API layer, it completely avoids the need for NVIDIA’s proprietary software suite.
The hardware context of this experiment is equally important. The Intel Arc 140V is the flagship integrated GPU of the Lunar Lake architecture, featuring Intel’s second-generation Xe2 "Battlemage" graphics technology. This architecture introduces massive improvements over the first-generation Xe-HPG graphics, particularly in terms of efficiency and AI throughput. The inclusion of dedicated XMX engines on an integrated GPU is a crucial hardware feature that made this experiment possible. Without hardware-level matrix math accelerators, attempting to run a 71-block U-Net neural network on a graphics chip would be entirely impossible, even for basic static image rendering.
Performance Results and Technical Limitations
While the implementation is a resounding success from a purely technical and conceptual standpoint, the real-world performance results reveal that integrated GPUs are not yet powerful enough to handle these workloads in real-time. The developer tested the "dlss-nr-on-intel" Vulkan layer across several popular games, including Dead or Alive 5 Last Round, Tekken 7, and Mortal Kombat 1.
During testing on the Intel Arc 140V, running the neural rendering pipeline at a modest 720p resolution resulted in frame rates hovering between just 3 and 5 frames per second (FPS). This is a far cry from the 60 FPS target required for smooth gameplay, particularly in fast-paced fighting games.
To see if lowering the resolution would yield playable results, the developer scaled the input resolution down to an ultra-low 640x360p. At this extremely low resolution, performance improved slightly, with Tekken 7 reaching approximately 10.5 FPS. However, this is still well below any standard definition of playability.
When attempting to scale the resolution up to a standard 1080p (1920×1080), the rendering pipeline slowed down significantly. Processing a single frame at 1080p took hundreds of milliseconds. In modern gaming, a target of 60 FPS requires a frame to be rendered and presented in under 16.6 milliseconds. A render time of several hundred milliseconds per frame translates to an unplayable slideshow, highlighting the extreme computational bottleneck imposed by the heavy neural network.
Beyond pure compute limitations, memory bandwidth and capacity present another major obstacle. At 720p resolution, the neural rendering pipeline requires approximately 2.3 GB of dedicated device buffers just to store the neural network’s weights, intermediate activations, and frame buffers. Because the Intel Arc 140V is an integrated graphics processor, it does not have its own dedicated high-speed VRAM. Instead, it must share the system’s LPDDR5X RAM. Allocating 2.3 GB of system memory solely for the neural rendering buffers severely starves the rest of the system and the game engine of vital memory capacity and bandwidth, compounding the performance issues.
Additionally, this project is entirely unofficial and experimental. It is not a plug-and-play mod that average gamers can easily install to boost their frame rates. Because of licensing and legal restrictions surrounding NVIDIA’s proprietary model weights, the developer cannot distribute the pre-trained neural network weights. Consequently, users who want to try this mod must provide their own compatible DLSD (Deep Learning Super Denoising) or DLSS model files and extract the necessary weight parameters themselves to feed into the Vulkan layer.
Ultimately, while a performance of 3 to 5 FPS is obviously unplayable, the significance of this project lies in its proof of concept. It demonstrates that proprietary, vendor-locked AI technologies can be reverse-engineered and run on open APIs like Vulkan using hardware from competing manufacturers. As integrated graphics chips become more powerful and include even more robust matrix math accelerators, open-source projects like this could lay the groundwork for universal upscaling and neural rendering solutions. It shows that the industry does not necessarily have to remain fractured by proprietary vendor locks, and that cross-compatibility is achievable through community dedication and open-standard APIs.
