NVIDIA DLSS (advanced)¶

Jetstream builds

This page is for Jetstream builds of Slipstream, 1.5.0.4 and newer (older builds only offer Ray Reconstruction and need the manual path setting below). DLSS is an advanced, do-it-yourself option: you build one small helper with a single command, from NVIDIA's files that you download yourself. If you just want a faster picture, use FSR instead.

What it is¶

Slipstream can use two of NVIDIA's DLSS networks:

DLSS Super Resolution (SR) renders the scene at a lower resolution and rebuilds a sharp, full-resolution picture. This is the one that lifts frame rates, with or without ray tracing.
DLSS Ray Reconstruction (RR) does the same upscaling and replaces our own ray-tracing denoisers in one step. It gives the cleanest picture when ray-traced global illumination (GI), shadows from all lights or ray-traced reflections are on, at a higher cost per frame than SR.

You don't have to choose by hand: with Ray Reconstruction set to Auto (the default), Slipstream uses RR while noisy ray-traced lighting is on and SR otherwise.

You need:

an NVIDIA RTX graphics card (20-series or newer). Both SR and RR run on every RTX card; RR costs more on older cards, so on a 20- or 30-series card with ray tracing off, SR is the better fit;
a current NVIDIA driver (the newest Ray Reconstruction needs driver 580 or later);
the Vulkan renderer (the default).

Why you build it yourself¶

Slipstream does not include any NVIDIA files. NVIDIA's DLSS SDK licence does not allow the SDK to become part of an open-source program, so the route is "bring your own SDK": you download NVIDIA's SDK (which means you accept its licence, LICENSE.txt -- read it first), and a script builds a small helper library, the shim, from it on your own computer. The shim's source is MIT-licensed and lives in the Slipstream repository under contrib/ngxshim. If you redistribute a built shim, NVIDIA's licence terms apply to you. This page is not legal advice.

Set it up on Linux¶

Download NVIDIA's SDK (this is where you accept NVIDIA's licence):
```
git clone https://github.com/NVIDIA/DLSS ~/DLSS
```
Get the Slipstream source (only the contrib/ngxshim folder is used; the script is not part of the installed viewer):
```
git clone --depth 1 https://git.slipstreamviewer.org/sky_line/Slipstream.git ~/Slipstream
```

Run the script:

~/Slipstream/contrib/ngxshim/build.sh ~/DLSS

Flatpak install: add --flatpak so the files land where the sandboxed viewer can see them:

~/Slipstream/contrib/ngxshim/build.sh --flatpak ~/DLSS

Restart Slipstream.

Set it up on Windows¶

This takes about half an hour, most of it waiting for Visual Studio to install. You install four free tools once, then copy three commands into PowerShell.

The script is not in your Slipstream install

The script that builds the shim is part of Slipstream's source code, not of the installed viewer (AppData\Local\Programs\Slipstream has no contrib folder). Step 3 downloads the source with Git. You don't have to compile Slipstream itself.

Install the tools. Accept the defaults unless a step says otherwise.
- Git: Git for Windows -- take the "64-bit Git for Windows Setup" installer. The default options are fine (they make git work in PowerShell).
- Visual Studio 2022 or 2026 (download). Any edition works: the free Community edition is all you need. In the installer, tick the "Desktop development with C++" workload. With Visual Studio 2026, also open the Individual components tab and tick "MSVC v143 - VS 2022 C++ x64/x86 build tools" (NVIDIA's library is built with that toolset). Already installed? Open Visual Studio Installer from the Start menu and click Modify to add them.
- CMake (download): take the Windows x64 Installer (the .msi, e.g. cmake-4.x.x-windows-x86_64.msi), not the .zip, and tick "Add CMake to the system PATH" while installing (PATH is the list of folders Windows searches when you type a command; this option lets PowerShell find cmake). Visual Studio 2026 needs CMake 4.2 or newer. If you already unzipped the .zip, uninstall nothing: just run the .msi as well.
- Vulkan SDK (download): run the installer with its default options.
Open a new PowerShell window: press the Windows key, type powershell, and press Enter. (It must be opened after the installs, or it won't find the new tools.) Check them:
```
git --version
cmake --version
```
Each should print a version number. If one says "not recognized", that tool's install didn't add itself to PATH: rerun its installer (for CMake, tick "Add CMake to the system PATH"), then open a new PowerShell window again.
Download the two sources and build. Copy these lines into the PowerShell window and press Enter (right-click pastes in PowerShell). They make a folder C:\src, download NVIDIA's SDK (this is where you accept NVIDIA's licence) and Slipstream's source into it, and run the script:
```
mkdir C:\src -Force
cd C:\src
git clone https://github.com/NVIDIA/DLSS
git clone --depth 1 https://git.slipstreamviewer.org/sky_line/Slipstream.git
powershell -ExecutionPolicy Bypass -File C:\src\Slipstream\contrib\ngxshim\build.ps1 C:\src\DLSS
```
The downloads take a few minutes. When the script finishes it prints where it put the files. If it stops with a message instead, it says what is missing; fix that and run only the last line again.
Restart Slipstream.

To update later (a newer SDK or shim), run in a new PowerShell window:

cd C:\src\DLSS; git pull
cd C:\src\Slipstream; git pull
powershell -ExecutionPolicy Bypass -File C:\src\Slipstream\contrib\ngxshim\build.ps1 C:\src\DLSS

What the script does¶

The script checks that you have everything it needs (CMake, a compiler, the Vulkan headers, the right SDK files) and tells you what is missing before it changes anything. It builds the shim, copies it together with NVIDIA's two runtime libraries from the SDK's rel folder (SR: libnvidia-ngx-dlss.so.* / nvngx_dlss.dll; RR: libnvidia-ngx-dlssd.so.* / nvngx_dlssd.dll) into the dlss folder of the viewer's data folder:

	Folder
Linux	`~/.slipstreamviewer/dlss`
Linux (Flatpak)	`~/.var/app/org.slipstreamviewer.Slipstream/.slipstreamviewer/dlss`
Windows	`%APPDATA%\SlipstreamViewer\dlss`

Slipstream looks in that folder automatically, so there is nothing to configure. It is safe to run the script again later, for example with a newer SDK.

Older Jetstream builds

Builds older than Jetstream 1.5.0.4 don't look in the dlss folder by themselves: set the debug setting RenderVKDlssShimPath to the folder the script prints (a full path), then restart.

Windows

The Windows script has been confirmed working by a tester with Visual Studio 2026. It's newer than the Linux one, so if it fails for you, please tell us what it printed.

Turning it on¶

Open Me > Preferences > Graphics > Advanced Settings… > Upscaling and pick a DLSS mode:

Mode	Render size
DLSS DLAA	1x (native, best quality)
DLSS Quality	1.5x smaller
DLSS Balanced	1.7x smaller
DLSS Performance	2x smaller
DLSS Ultra Performance	3x smaller

Next to it, Ray Reconstruction chooses the network:

Auto (default): Ray Reconstruction while ray-traced reflections, GI or shadows from all lights are on; Super Resolution otherwise.
On: always Ray Reconstruction.
Off: always Super Resolution (our own ray-tracing denoisers stay on).

If DLSS can't run (the files are missing, the card isn't supported, or a frame fails), Slipstream falls back to FSR at the matching preset automatically, so you always get a picture. A choice whose NVIDIA library is missing is greyed out with the reason.

Check that it works¶

Open your log and look for the lines starting with DLSS::

	Log
Linux	`~/.slipstreamviewer/logs/Slipstream.log`
Linux (Flatpak)	`~/.var/app/org.slipstreamviewer.Slipstream/.slipstreamviewer/logs/Slipstream.log`
Windows	`%APPDATA%\SlipstreamViewer\logs\Slipstream.log`

DLSS: available -- Super Resolution: yes; Ray Reconstruction: yes at start-up: the files were found and your card can run both.
DLSS: running SR ... or DLSS: running RR ... after you pick a DLSS mode: it is drawing the picture (with the quality and the render and display sizes).
DLSS: shim not found; looked in: ... lists every folder Slipstream checked.

Tips¶

For the best Ray Reconstruction result, set the debug settings RenderVKDenoiseScale, RenderVKGIScale and RenderVKRTShadowMaskScale to 1: at full size the network has the most to work with.
RenderVKDlssRawSignals (Ray Reconstruction only) chooses which ray-tracing signals go to the network untouched instead of through our own denoisers; the default suits most scenes. If you changed it earlier, reset it to the default.
RenderVKDlssShim set to 0 stops Slipstream loading the shim at all (restart needed).
Reporting problems: use Help > Report Bug in the viewer; it attaches your graphics card, driver, settings and a cleaned log excerpt. See Reporting bugs.

Troubleshooting¶

DLSS does nothing, or the picture looks like FSR. Read the DLSS: lines in the log (see above).

Shim not found: the script's folder isn't where Slipstream looks. Check the paths in the log line; on older builds set RenderVKDlssShimPath (see above). Restart after any change.
Super Resolution or Ray Reconstruction says "no": that network's NVIDIA library is missing from the folder or your driver is too old. Run the script again and check its output.
"rebuild the shim": the shim in the folder is older than your viewer. Run the script again.
"not this frame": DLSS couldn't run for that frame and FSR drew it instead; the reason is in the line. If it keeps repeating, report it.

Not an NVIDIA card. DLSS needs a GeForce RTX card. On other GPUs the DLSS choices are greyed out with the reason shown, and nothing is loaded. Use FSR instead.

NGX "Permission denied" on Linux. NVIDIA's software tries to create /usr/share/nvidia/ngx and logs a "Permission denied" message when it can't. This is harmless.

More detail. NVIDIA's own messages are written to Slipstream.log under the NGX debug tag.