DLSS 5 Autopilot: an installer for DLSS 5 in games that never shipped it

The gap DLSS5-Autopilot is trying to close

DLSS 5 is a network that runs over a finished frame and re-lights it: materials, skin, tone. NVIDIA shipped it on 3 September 2026 in NBA 2K27, for RTX 50 cards. That is a narrow launch window, and it left two groups stranded. Owners of RTX 40, 30 and 20 hardware had no official path to the feature at all. Everyone else had a library full of games that ship an older DLSS, or no DLSS, and no supported way to move either of those forward.

The community response was to wire DLSS 5 into other games through ReShade add-ons and an OptiScaler fork, and to re-target the runtime so older cards can run it. That works, but it is a manual job: the right ReShade build with add-on support, the right nvngx_dlssnr.dll for your architecture, motion-vector shaders, DXVK for DirectX 9, a 64-bit helper for 32-bit games, and a different arrangement of all of it depending on the game's graphics API. DLSS5-Autopilot automates that arrangement. It is explicitly unofficial, and it resolves the current version of every part each time it runs rather than pinning one.

Eight routes, and how the tool decides which one a game gets

The core mechanism is route selection. DirectX 9 through 12, Vulkan, OpenGL, 32-bit games, emulators and RTX Remix mods each reach the neural network a different way, so the tool inspects the executable and the folder before offering anything. The README's route diagram spells out the mapping: an RTX Remix mod means remix; a 32-bit game means feeder; 64-bit DirectX 9 means renodx-dlss; Vulkan means bridge with DLSS and feeder without; OpenGL and DirectX 10 mean feeder; DirectX 11 or 12 with DLSS means optiscaler on D3D12 (with native and neural-upstream also offered) or bridge on D3D11, and feeder without DLSS.

The graphics API detection is the part worth reading closely, because it is where a naive tool would get things wrong. The API comes from the executable's import table, but a d3d9.dll import is checked against the delay-load table, a D3D12 Agility SDK in the folder, and the executable's own names before the game is called DirectX 9, on the grounds that engines keep that import long after they stop drawing with it. When the import table names no graphics DLL at all, the tool reads DLL names inside the exe, the imports of the DLLs beside it, and the names inside the largest of those, then ranks them the way the import table would. A Direct3D name anywhere outranks OpenGL or Vulkan, because an engine that can drive several backends names all of them.

That heuristic is a judgement call, and it is the kind of thing that will misfire on unusual engines. The tool does not hide the result: the card shows what was read (executable, 32 or 64-bit, graphics API, whether the game ships DLSS) and the route it will take, and the dropdown lists every route the game allows, marks the recommended one, and greys out what your card cannot run. There is one documented exception to the recommendation logic. On driver 616.64 and newer, a game with no DLSS of its own gets standalone instead of the renodx-dlss5 add-on, because the add-on faults in many games.

Installing it and running a first game

There is nothing to install. The README points to the latest release page and describes the tool as one .exe, nothing to install, no admin, for Windows 10 and 11 on an NVIDIA RTX 20 or newer. Download the release, then run it.

dlss5-autopilot.exe

The window opens on your library if scan library at start is on, which the README says is the default. If you have never run it, press scan games. It reads Steam, Epic, GOG, EA, Ubisoft, Battle.net, Rockstar, Amazon, itch, Heroic, Xbox/Game Pass, D:\Games\* folders and 19 emulators. For anything outside those locations, use choose folder. Later, rescan picks up games installed or removed since the last scan, and full rescan reads every launcher, game folder and emulator location again the way the first scan does.

Pick a game. The card shows the executable, whether it is 32 or 64-bit, the graphics API, whether the game ships DLSS, and the route it will take. Check that against your card before going further. Then press INSTALL, and the log says what went where. Start the game and press the key the tool named. Afterwards, press did it work? and it reads ReShade's log, the add-on's, OptiScaler's and Windows' own crash record, and reports whether the model ran, and if not, which part stopped. If you would rather not commit blind, press What will happen? first: it lists every file INSTALL would write, back up and remove, and writes none of them. aim for _ fps works settings out from your own previous runs and says how sure it is, but applies nothing on its own.

There is a faster and more experimental path. AUTOPILOT installs the route, starts the game, reads which DLLs the game loaded, and when the tool's DLLs are not among them, or the game loaded another copy of the same name instead, it waits for you to close the game, installs the next route and repeats, up to three times. A game with anti-cheat is never started by the tool; it asks you to start it.

Keeping a game's own DLSS up to date

The second job is separate from the injection work and less risky. An install can swap super resolution (nvngx_dlss.dll), frame generation (nvngx_dlssg.dll) and, for a game that ships one, ray reconstruction (nvngx_dlssd.dll) for builds from NVIDIA's own repository. The game's original file is backed up and comes back on uninstall. A check versions action later reports which of your games has a part with a newer build available.

This is the part of the tool that maps most cleanly onto something a cautious user would want. DLL swapping for DLSS is a well-established practice, the source is NVIDIA's own repository rather than a mirror, and the operation is reversible by design. If you only want this half, the README does not describe a mode that restricts the tool to swaps alone, so you would be relying on route selection and on not pressing INSTALL for a route you do not want.

What the tool does not bundle, and why that matters for trust

Nothing is bundled. Each component is fetched from its own publisher, at run time, at a version the tool resolves that day. The repository states plainly that it holds installer logic only: no game files, no NVIDIA binaries, no third-party code is redistributed. That design choice has two consequences.

The first is legal and practical. The MIT licence on this repository covers the installer code. It does not cover ReShade, DXVK, OptiScaler, the renodx-dlss5 add-on or any NVIDIA runtime, each of which carries its own licence and is downloaded from its own publisher. You are accepting those terms when the tool fetches them, not when you clone this repository.

The second is reproducibility. Because versions are resolved at run time rather than pinned, the same button press on two different days can produce two different component versions, and a regression in an upstream part will appear in your game without any change to DLSS5-Autopilot itself. The README does not document a way to pin a component version. If you need a setup you can reproduce exactly, this is the wrong shape of tool.

Anti-cheat, and the cases where this is the wrong tool

The most important limitation is stated by the README itself, in the AUTOPILOT description: a game with anti-cheat it never starts itself, it asks you to. That is a sensible safety measure and it is also an admission that injecting DLLs into a protected process is a bad idea. Any game with kernel-level anti-cheat, and any multiplayer title where a modified render path could be flagged, is outside what this tool should be used for. The tool will not stop you, but it will not protect you either.

The second limitation is the experimental status of AUTOPILOT, which the README labels as such. It tries up to three routes before giving up, and it depends on reading which DLLs a running game loaded. When that read is inconclusive, the loop cannot converge.

The third is the platform boundary. Windows 10 and 11 only, NVIDIA RTX 20 or newer, with no Linux, Steam Deck or macOS path described. Emulators appear in the scan list, but the neural pass in an emulator is still a Windows process. And the video path is a separate feature with its own constraints: the same neural pass runs in a portable MPC-HC for a file, a live YouTube link or a webcam, or over a captured part of the desktop half a second behind, for a browser, an emulator or a game nothing may be injected into. Half a second of latency rules that out for anything interactive.

How it compares with doing the DLL swap by hand

The obvious alternative is not another autopilot. It is manual setup: download ReShade with add-on support, drop in the right nvngx_dlssnr.dll for your card, add motion-vector shaders, and for DirectX 9 add DXVK, arranging each of these per game. That approach has real advantages. You know exactly which version of every component you installed, you can read each project's own documentation before committing, and you are not trusting a third-party resolver to pick a compatible set.

The difference in approach is the route logic. Manual setup requires you to work out for yourself that a 32-bit game needs a 64-bit helper, that a Vulkan title takes bridge with DLSS and feeder without, or that a DirectX 11 game with DLSS has two viable paths. DLSS5-Autopilot encodes that decision tree and reads the executable to place your game in it. It also adds two things manual setup does not have: a pooled results list, where results people choose to share are collected and the tool tells you which route worked most often on a game once five results exist, and per-setting cost reporting, where on the optiscaler and feeder 64-bit D3D11 paths it reads the last session out of the add-on's own log and prints the price of a setting in milliseconds per frame. The pooled list is opt-in and only as good as the people who share; the README does not describe how a shared result is validated.

Maintenance, licence and what uninstall actually promises

The repository is not archived, and the last push was on 2026-09-16. Three releases landed in the days before that: v1.9.0 on 2026-09-15, v1.8.2 on 2026-09-12 and v1.8.1 on 2026-09-10. That release cadence is the main signal about upgrade cost: this is a tool that expects to be re-downloaded often, partly because it resolves component versions at run time and partly because the upstream projects it depends on move.

The licence is MIT, which covers the installer logic in this repository. It does not extend to anything the tool downloads. ReShade, DXVK, OptiScaler, the renodx-dlss5 add-on and NVIDIA's runtime DLLs each carry their own terms, and the README's credits and licensing section is the place to read them. Nothing here is legal advice; if you redistribute a modified game folder, the third-party licences are your problem, not the MIT grant's.

The rollback story is the strongest part of the design and also the part most worth verifying yourself. Uninstall restores every file it replaced and removes only what it wrote, and the README repeats that uninstall removes exactly what was written, restores anything it replaced, and nothing else. The README does not document rollback for a game whose files were changed by something else between install and uninstall, and it does not describe what happens if a launcher repairs or overwrites the game folder in the meantime. Test the round trip on one game you do not care about before trusting it across a library.

Editorial conclusion

Adopt it if you have an RTX 20-series or newer card on Windows 10 or 11, a library you are willing to modify, and the patience to read the log after each attempt. Skip it if your games run anti-cheat, if you want a supported NVIDIA feature, or if you need a documented rollback for every launcher you use. Verify first that the route the tool recommends for your game is one your card supports, that the tool reports a backup of every file it replaces, and that uninstall actually restores that game before you install onto a second title.

Frequently asked questions

Official sources

1. Issues
2. Kizzuwatnaa/DLSS5-Autopilot on GitHub
3. License: MIT
4. README
5. Releases