The three-dlss-nr brought the Neural Rendering network associated with DLSS 5 to the Three.js ecosystem via TSL and WebGPU. Ben Houston's project, updated on October 2, 2026, ports the open implementation of OpenDLSS-NR and executes all 71 network blocks as compute kernels within the WebGPURenderer, with no CPU readback.

Furthermore, the developer states that the intermediate result was validated byte for byte against the WebGPU implementation used as a reference. This makes the project especially interesting as a technical demonstration of DLSS 5 in Three.js, although it does not yet represent a ready-to-use solution for games or real-time applications.

Demonstration of three-dlss-nr with synthetic weights in split-screen view. Image: Ben Houston/three-dlss-nr.

DLSS 5 in Three.js uses 71 blocks and 451 dispatches

According to the project documentation, the network is a U-Net with transformer blocks and a global ViT at the bottom. In total, the WebGPU formulation executes 451 compute dispatches per frame. Therefore, the work is not limited to a visual interface: the complete network was ported to TSL compute nodes.

three-dlss-nr receives the rendered frame, noise, reprojected temporal history, and conditioning parameters. It then outputs an RGB residual and a value used in temporal composition. Thus, the process maintains the same input and resolution; it does not function as a traditional upscaler.

This point also distinguishes the Super Resolution technology. NVIDIA itself describes DLSS 5 as a generative rendering step guided by the content already produced by the engine. The independent project attempts to reproduce the open OpenDLSS-NR network within the Three.js pipeline, but has no official affiliation with NVIDIA.

Base scene used by the project's public demonstration. Image: Ben Houston/three-dlss-nr.

Port is validated byte by byte against the WebGPU reference

To check the fidelity of the port, Houston compares the kernels and tensors with the OpenDLSS-NR WebGPU reference on the same device. According to the repository, the tests cover FP8 and FP16 kernel families, windowed attention, global ViT, elementary operations, and pre- and post-processing steps.

In addition, the complete network was compared at 64 × 64 and 512 × 512 with synthetic weights. The author reports a match in 83 out of 83 verified tensors. However, this does not mean that the public demonstration reproduces the actual appearance of DLSS 5, since the synthetic weights only serve to validate the math and the network flow.

Project does not yet run Neural Rendering in real time

Despite numerical parity, performance still limits practical use. On an RTX 3060 Ti, the author measured about 201 ms per frame at 512 × 512 on the TSL backend and approximately 659 ms at 1280 × 720. The WGSL reference was faster in the same test, with about 123 ms and 412 ms, respectively.

That is why the repository itself makes it clear that the port is not yet real-time. The TSL backend appears approximately 1.6 times slower than the optimized WGSL reference on the same hardware. Thus, the numbers should be understood as a benchmark for an experimental implementation, rather than the expected performance of official DLSS 5 in games.

The project also requires WebGPU and Three.js r180 or later. There is no fallback for WebGL. In addition, the implementation limits the internal size to 1280 × 720 and depends on the compute capabilities available on the graphics adapter.

three-dlss-nr does not distribute NVIDIA's proprietary weights

Another important limitation involves the model. The repository does not include, download, host, or extract NVIDIA's proprietary weights. Instead, the public demo can generate deterministic synthetic weights, which allow running the entire pipeline and verifying parity without distributing the actual model.

Consequently, the visual output from the synthetic weights does not represent DLSS 5 quality. The goal is to prove that the DLSS 5 in Three.js performs the same mathematical function as the reference when given the same data. For meaningful visual output, the user would need to provide a model directory for which they have the appropriate rights.

The advancement adds to other recent experiments with Neural Rendering. Allves Games also followed the DLSSNR-AMD running an independent implementation on a Radeon RX 9070 XT, although the two projects use different architectures and goals.

Finally, three-dlss-nr shows that the open network of OpenDLSS-NR can be integrated into the modern Three.js pipeline and executed entirely on the GPU via WebGPU. The next challenge is to reduce the cost of the kernels to bring the implementation closer to truly interactive frame rates.

Sources: official project repository; NVIDIA technical documentation on DLSS 5.