DLSS 5 Neural Rendering Rewritten From Scratch to Run on Intel Arc 140V Integrated GPU

A project circulated on September 20, 2026 does the software equivalent of re-pouring a wall from someone else's blueprint: it reimplements NVIDIA's DLSS 5 neural rendering from scratch so it runs on an Intel integrated GPU. The developer, credited as Uzbekunknown, published the work as dlss-nr-on-intel, targeting the Arc 140V iGPU inside an Intel Core Ultra 7 256V (Lunar Lake, Xe2 architecture, eight Xe cores, up to 64 TOPS INT8), on Arch Linux with Mesa drivers.

Not a wrapper, but a full reimplementation

The project is not a bridge around NVIDIA's dynamic libraries. Three key choices define the pipeline:

• The network itself. The 71-block U-Net used by DLSS 5 neural rendering is fully rebuilt, which is why the project needs roughly 2.3 GB of device buffers — the network genuinely runs, rather than being forwarded.
• Precision. NVIDIA stores weights in FP8, which Xe2 does not support; the project converts weights to FP16 and keeps accumulation in FP32 for numerical stability.
• The interface. Inference runs entirely via Vulkan's VK_KHR_cooperative_matrix extension on Intel's XMX matrix engines — no CUDA, no NVIDIA NGX. The hook is attached to vkQueuePresentKHR, so it should apply to any program presenting via Vulkan.

Context: DLSS 5 neural rendering launched on September 4, 2026. Within weeks the community ported it to older RTX cards, then AMD RX 9000 series, and now Intel integrated graphics — the technical barrier to porting is dropping.

Runnable, but not usable: 412 ms per inference

Performance leaves no room for optimism:

• 640×360 in Tekken 7: about 10.5 FPS
• 720p: 3–5 FPS, with ~2.3 GB of device buffers drawn from shared system memory
• 1080p: 1.5–2 FPS; a single neural rendering inference takes about 412 ms, capping the theoretical frame rate at ~2.4 FPS even if the game itself rendered instantly

The cost scales almost entirely with output resolution. This is a working proof of concept, not a usable solution. The author notes that desktop-class Intel discrete GPUs (such as the A770 or B580) would see significantly better frame rates thanks to higher memory bandwidth.

Image quality exposes the model's stylistic bias

Validation used three fighting games: Dead or Alive 5 Last Round, Tekken 7, and Mortal Kombat 1. The DLSS 5 NR model was trained on photorealistic imagery, so it performed well at detail enhancement and noise suppression on Tekken 7 and Mortal Kombat 1.

On the more anime-styled Dead or Alive 5 Last Round, the model over-enhanced textures and lighting, and character faces showed an unintended "aging" effect — overall worse than native rendering. This is a more valuable observation than the frame rates: a photorealism-trained model actively "corrects in the wrong direction" on stylized content, pushing sharp-lined anime faces toward realistic ones rather than simply blurring or sharpening. Anyone planning to bring this technology into stylized games, animation, or fan-production pipelines must solve this in advance.

The code was mostly written by two AI models

The most counterintuitive part is the development method. The author states the code was primarily written by Anthropic's Claude and OpenAI's GPT-6 Astra; the author provided the hardware platform, the original binaries, and judgment on the overall technical path, while modeling, adaptation, and debugging were executed autonomously by AI agents.

The project also preserves an unusual record: while analyzing driver-layer behavior, the AI generated a nonexistent hypothesis of a "driver-level compatibility flaw." This fabricated problem was treated as a real obstacle and influenced decision-making across three key development stages. The author kept this detour in the project documentation as a record of cognitive bias.

What makes this painful is how long the false assumption survived — it wasn't dismissed as a throwaway hallucination but entered engineering decisions across three stages. Breaking such a chain requires either someone re-verifying assumptions mid-flight, or a process gate that demands falsification before proceeding. This is the most transferable lesson from the episode.

Where it sits versus in-pipeline approaches

This must be distinguished from another recent effort: AMD's ECCV presentation on single-step latent diffusion for indirect lighting, where the GPU computes only direct light and a diffusion model fills in diffuse indirect illumination. That approach is embedded in the pipeline and takes engine 3D data as input.

DLSS 5 neural rendering is described as 3D-Guided Neural Rendering: it performs deep scene reconstruction in post-processing on finished frames, taking rendered frames plus motion vectors as input. The former requires engine cooperation; the latter only needs the image. That is why this port can bypass the engine entirely — it hooks the presentation layer.

A side effect of the post-processing position: the project requires users to supply their own DLSS files to extract weights. This implementation is a community project, not endorsed or supported by NVIDIA, and its terms-of-use and licensing status are not publicly documented.

Open questions

• When will a Windows build appear?
• Actual frame rates on desktop-class Intel discrete GPUs?
• Baseline results on AMD RDNA3 and newer architectures?
• The provenance and licensing boundaries of the extracted weights?
• Can third parties independently reproduce the same numbers from AI-written porting code?

The last item is the project's most valuable contribution to AI engineering: an open-source project led by models that documents its own judgment errors offers a testable sample. Give the same path to another person and another set of models — do you get the same frame rates, and do you fall into the same nonexistent "driver-level flaw"?

A ten-year-old Tekken 7 running at 10.5 FPS at one-eleventh the resolution is a useless number by itself. What it proves is different: a neural network locked inside a specific vendor's execution libraries can be re-poured from scratch by an outsider and made to run on entirely different matrix units. The next question: when porting someone else's model to your own hardware costs one person and two models, does the hardware vendor's moat still live in silicon — or has it moved somewhere else?

---

References

1. VideoCardz, *Modder gets DLSS 5 Neural Rendering running on Intel Arc 140V integrated graphics*, 2026-09-20. https://videocardz.com/newz/modder-gets-dlss-5-neural-rendering-running-on-intel-arc-140v-integrated-graphics 2. Wccftech, *Intel Arc 140V Runs DLSS 5 Neural Rendering Without CUDA, But Frame Rates Collapse To Just 3-5 FPS*, 2026-09-20. https://wccftech.com/intel-arc-140v-runs-dlss-5-neural-rendering-without-cuda 3. Mydrivers / Sina Tech, *DLSS 5 ported to Intel Arc iGPU, code mostly AI-written: Arc 140V hits 10.5 FPS*, 2026-09-20. https://k.sina.com.cn/article_5952915720_162d2490806704va9k.html 4. PC Central, *Intel Arc 140V Runs DLSS 5 Neural Rendering in Linux Proof-of-Concept*, 2026-09-20. https://pccentral.net/intel-arc-140v-runs-dlss-5-neural-rendering-linux-proof-of-concept 5. GameGPU, *DLSS 5 works on Intel Arc Xe2 at 720p with performance up to 3-5 FPS*, 2026-09-20. http://en.gamegpu.com/news/zhelezo/dlss-5-zarabotal-na-intel-arc-xe2-v-720p-s-proizvoditelnostyu-do-3-5-fps