NeuralScreen: running DLSS 5 neural rendering over the whole Windows desktop

What NeuralScreen actually does with a DLSS 5 runtime

NeuralScreen takes the neural renderer that DLSS 5 games use and points it at the Windows desktop instead of a game's swap chain. The README frames it plainly: everything on screen, games, video and photos, goes through the same network and comes back sharper. That is a different target from the usual upscaler, which sits inside a renderer and receives motion vectors, depth and jittered frames. Here there is no engine cooperation at all, so the program has to capture what the desktop compositor is showing and feed that to the network.

The audience follows from that. It is for people who already own an RTX 30, 40 or 50 card and want to see the effect applied to content that will never ship a DLSS integration: old games, video players, image viewers, a browser. It is not a performance tool for modern titles, which already expose their own DLSS path, and the README is explicit that it should not be used in competitive online games, since a fullscreen overlay is exactly what anti-cheat systems look for.

Capture path, worker reconfiguration and what the overlay draws

The repository layout tells you most of the architecture. capture.py handles getting frames, pipeline.py runs the neural pass, motion_backend.py and channels.py deal with frame generation and output channels, display.py and overlay_ui.py draw the menu, and native/ holds the parts that need to talk to Windows and NVIDIA's runtime directly. main.py and startup.py wire it together, and gpuinfo.py decides which card does the work.

The user-visible consequence of that design is in the README's window mode description. Choosing Window mode opens a list of windows, hovering a row highlights that window, and the overlay follows the window as it moves. Resizing it, a video going fullscreen or a different player size, reconfigures the worker in place with no black moment, and minimising the window pauses processing. That in-place reconfiguration is the interesting part: a naive implementation would tear down the capture and rebuild it, which is where the black frame would come from.

Boost is the other mechanism worth understanding. The network runs at a reduced resolution and a slider chooses how far down, but the result is composed onto the original frame rather than replacing it, so text and edges keep full resolution. The README reports 45.7 to 72.6 frames at the default step and 83.4 at the lowest, measured on a 5070 Ti at 4K. Those are the project's own numbers, not an independent test.

Installing NeuralScreen and getting the first frame processed

There is no installer and nothing to install. The release archive brings its own Python and the NVIDIA runtimes, so the whole procedure is unpack and run.

# 1. Download the archive from the Releases page and unpack it anywhere
# 2. From the unpacked folder, launch:
NeuralScreen.exe

Windows will likely warn about an unknown publisher, because the build is not signed with a paid certificate. The README gives the alternatives: click More info then Run anyway, or use NeuralScreen.vbs next to the executable.

Once it is running, the program sits in the tray and draws over the desktop. The menu is on Num2, and the hotkeys are on the numpad, so Num Lock has to be on.

Num2   open / close the menu
Num1   neural rendering on / off
Num7   frame generation on / off
Num3   screenshot
Num0   start / stop recording, with sound
Num5   capture the window under the cursor
Ctrl+Alt+Q   quit

A useful first check is the dot next to your graphics card in the menu: green when neural rendering really runs on it, red when it does not. If it is red, the README points at the driver first, since an old driver is the commonest reason the program refuses to start or the picture never appears. Set the before/after wipe slider to see the split, then return it to 0.

Where NeuralScreen is the wrong tool

The hardware boundary is hard. RTX 20 (Turing) is below the minimum architecture: the README says the program starts but the picture is not processed. That is a worse failure mode than a clean refusal, because nothing crashes and nothing explains itself, and the only signal is the red dot in the menu.

Frame generation has its own floor. The README states that on a card below Ada the runtime refuses and the switch flips back off with a short notice, explicitly no silent ON. That is honest behaviour, but it also means the ×2, ×3 and ×4 multipliers are unavailable on parts of the supported range. The README adds that DLSS-G was validated on RTX 50-series and that adapters beyond it are unconfirmed.

The quality trade-off is documented too, and it is not small. The three models are three different outputs, not three strengths. On a desktop capture, fine detail against the untouched frame measured Default +18.7%, Natural −11.4% and Cinematic −23.4%. Natural and Cinematic are tuned for games and soften photographs and small text. Anyone who wants a desktop-wide sharpening pass and leaves the model on Cinematic has chosen the wrong setting for the content.

Frame generation on the desktop carries a structural cost the README states outright: the depth is flat, the motion is estimated, there is no engine cooperation, so UI and text can distort. That is the known cost of the approach, not a bug to be fixed. And hybrid laptops fall back to a slower capture path on the iGPU display.

How NeuralScreen differs from Magpie and Lossless Scaling

The obvious comparison is with window-scaling tools such as Magpie or Lossless Scaling. Those take a window or a region and scale it with a spatial filter or a shader, then present the result. The frame the network sees is the frame you already had. NeuralScreen is doing something else: it routes the desktop through NVIDIA's neural renderer, the same runtime family that DLSS 5 games use, and the bundled nvngx_dlssnr.dll and nvngx_dlssg.dll are NVIDIA's own binaries, included unmodified.

That difference explains both the strengths and the limits. A spatial scaler has no notion of frame generation and no model list; NeuralScreen exposes three models and a frame generation switch with multipliers. On the other side, a scaler does not care which GPU vendor you run, while NeuralScreen requires an RTX 30, 40 or 50 card and a current driver, because the runtime talks to the driver directly. The README's own framing of the Boost measurement, frames rising from 45.7 to 72.6 at the default step and 83.4 at the lowest on a 5070 Ti at 4K, is a claim about a specific card and resolution, and it is the project's measurement rather than a third-party one.

Maintenance, licensing and the cost of upgrading

The repository is not archived, and the last push was on 2026-09-15, with v1.12.0 tagged the same day, so the project is moving. The release history shows v1.11.0, v1.11.1 and v1.12.0 all dated 2026-09-15, which suggests rapid iteration rather than a settled release cadence. For a user, that means the upgrade cost is mostly re-downloading the archive, since there is no installer and no package manager to update. The one piece of state written outside the folder is autostart, and the README warns to turn it off before moving or deleting the folder.

Licensing needs care. The repository's LICENSE file is reported as NOASSERTION, so there is no clean SPDX identifier to read off. The README carries a notice stating that the project is not affiliated with NVIDIA, that NVIDIA, DLSS and the NVIDIA logo are NVIDIA trademarks, and that the bundled nvngx_dlssnr.dll and nvngx_dlssg.dll are NVIDIA's property, included unmodified, for research and educational use only, with no warranty and use at your own risk. The README also says rights holders can ask and the next build will ship without them. That is a redistribution arrangement that depends on NVIDIA's tolerance, and it is worth reading the notice in full rather than treating the repository as conventionally licensed. This is a description of what the files say, not legal advice.

Editorial conclusion

NeuralScreen is for RTX 30, 40 or 50 owners on Windows 10 or 11 who want to see what a DLSS 5 neural pass does to ordinary desktop content and are willing to run an unsigned, portable build that carries NVIDIA's runtimes under a research-use notice. It is not for RTX 20 cards, where the README says the program starts but the picture is not processed, and it is not for competitive online play, because the overlay is the pattern anti-cheat systems look for. Before adopting it, check the TECHNICAL.md measurements for the Boost and model settings on your own card, confirm the archive you download matches the release, and read the bundled runtime notice, since the repository's LICENSE file is classified as NOASSERTION and the README says the next build can ship without those DLLs on request.

Frequently asked questions

Official sources

1. Issues
2. perseval-BLR/NeuralScreen on GitHub
3. Project website
4. README
5. Releases