Kizzuwatnaa/DLSS5-Autopilot

Puts DLSS 5 neural rendering into games that never shipped it. It finds your games, reads each one, picks the route that fits the game and your card, downloads every part from its publisher, and can take all of it back out. One .exe, nothing to install, no admin, and nothing is bundled.

Download the latest release · Windows 10/11 · NVIDIA RTX 20 or newer

The library shows every game it found - Steam, Epic, GOG, EA, Ubisoft, Battle.net, Rockstar, Xbox, folders and 19 emulators - with its cover and one line: installed, working, needs a look, update, anti-cheat. Open a game and press install: the tool has already read the executable and the folder, and picked one of eight routes for DirectX 8 through 12, Vulkan, OpenGL, 32-bit, emulators and RTX Remix mods. settings shows only what that route reads, and uninstall puts back every file it replaced.

Play, close the game, and the answer comes up by itself, or press did it work?: the tool watches the games it installed into, reads ReShade's log, the add-on's, OptiScaler's and Windows' own crash record, and says whether the model ran - and when it did not, which part stopped and what to do next. When another route could change that answer, it offers try route. autopilot does the whole loop for you: install, start the game, read what loaded, and move on to the next route if ours is not in it (experimental). Results other people shared show on the game's page before you install.

The dlss page lists every game that ships NVIDIA's DLSS files - super resolution, frame generation, ray reconstruction - with the version each one has against NVIDIA's newest, for games DLSS 5 was never installed into too. update swaps in the new build, and the game's own file stays beside it for restore original.

The same neural pass runs on a video file, a live YouTube link, a webcam or a captured part of the screen, in a portable MPC-HC the tool sets up. The remix page finds the games in your library that have an RTX Remix mod and switches DLSS 5 on inside the mod's own renderer. The vr page puts the pass where a headset looks, through ReShade's OpenXR layer - and says plainly what is still unproven there. Video, YouTube, webcam · RTX Remix · VR

This repository holds installer logic only. No game files, no NVIDIA binaries, no third-party code is redistributed - everything is fetched at run time from the original publishers. Credits and licensing.

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. The community wired it into other games through ReShade add-ons and an OptiScaler fork, and re-targeted the runtime so RTX 40, 30 and 20 run it too. This tool automates that setup. Unofficial; the tool resolves the current version of every part each time it runs.

1. Run dlss5-autopilot.exe and press find my games. It reads Steam, Epic, GOG, EA, Ubisoft, Battle.net, Rockstar, Amazon, itch, Heroic, Xbox/Game Pass, D:\Games\* folders and 19 emulators. Anything else: add a game beside scan, then pick the folder its .exe is in. With read the library when the tool opens on (the view menu) - the default - later runs open straight on that library; scan → rescan picks up games installed or removed since the last scan, and full rescan reads every launcher, game folder and emulator location again, as the first scan does.
2. Pick the game. Each one shows its cover (Steam's own library art; for other stores, Epic's catalog art or Steam's store art found by the game's name; the executable's icon when there is none) and one line: installed, working, needs a look, update, anti-cheat - and, once other people have shared results for it, how many of them it worked for. Type anywhere to search; the arrow keys and Enter work too. Right-click a game to hide it, open its folder, pick your own cover, background or logo, or take DLSS 5 back out; view shows hidden games again and sorts the library.
3. The game's page says what was read - 32/64-bit, graphics API, where it came from - and the route it will take. Press install. Then play, press the key the tool named, and afterwards did it work? reads the game's logs and reports what happened. settings opens every choice that applies to that route, in place; a setting that does nothing on the route is not shown. Or press autopilot instead: it installs, starts the game itself, reads which DLLs the running game loaded, and tries the next route when ours are not in it. Experimental.

The log is in a drawer at the bottom: drag its edge to give it more room, or pop out to read it in a window of its own. Esc closes whatever is open, then goes back; Backspace goes back; Ctrl+H goes to games.

uninstall - on the game's page, beside open folder, and in a game's right-click menu in the library - removes exactly what was written, restores anything it replaced, and nothing else.

The route dropdown in the game's settings lists every route the game allows, marks the recommended one and marks what your card cannot run (not for this pc). Once other people have shared results for the game, its page shows how each route did for them.

The graphics API comes from the executable's import table, with one exception: 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, because engines keep that import long after they stop drawing with it. When the table names no graphics DLL at all (the engine loads its renderer at run time), the tool reads the DLL names inside the exe, the imports of the DLLs beside it and the names inside the largest of them, and ranks them as the import table would: a Direct3D name anywhere outranks OpenGL or Vulkan, because an engine that can drive several backends names all of them and draws with Direct3D on Windows. A Unity game (UnityPlayer.dll beside the exe) is Direct3D 11 unless started with -force-d3d12, -force-vulkan or -force-glcore. An import table can also lie

• R.U.S.E. links D3D11 and renders with Direct3D 9 - so the game's settings have a graphics api dropdown (auto / DirectX 9 / 10 / 11 / 12 / Vulkan / OpenGL); the choice is remembered for that folder.

Four things that override the diagram. A Remix mod present means remix, always - ReShade crashes a Remix game before it draws.

On NVIDIA driver 616.64 and newer, the native, bridge and feeder routes reach the driver's NGX runtime through the renodx-dlss5 add-on, which faults there in a good number of games. The tool pins that add-on to 4.55 on those routes, which gets most games through and not all. For a game with no DLSS of its own - the feeder's case - the recommendation moves to standalone-dlssnr where that route is offered (64-bit, D3D11 or D3D12): it does not load the add-on at all. A game that ships its own DLSS is not moved - native or optiscaler on D3D12, the bridge on D3D11 - because those routes run the game's own DLSS quality mode and standalone ignores it; the pre-install warning names the driver either way. The renodx-dlss route reaches the same runtime through ShortFuse's own add-on, which has no such pin and no report either way on these drivers. Rolling the driver back to 616.56 is the other answer.

Shared results move the recommendation too, for a game with fewer than five results of its own: once two offered routes each have 20 results from games with the same graphics API and the same DLSS, FSR, XeSS or none, and their ranges do not overlap. The reason is printed in the log when the game's page opens.

And an online game with anti-cheat (BattlEye, EAC, Vanguard, EA Javelin, HoYoverse, GameGuard, XIGNCODE3, Denuvo Anti-Cheat, PunkBuster, FACEIT, Ricochet, ACE) is marked in the library and asks for confirmation before an install: ReShade add-ons and anti-cheat do not coexist, and a ban is on the person who chooses to install anyway.

Three options, all off by default:

• Frame generation, any RTX card (optiscaler route, D3D12). OptiScaler ships AMD's FSR 3.1 frame-generation libraries; the tool turns them on with the upscaler it already runs as the input. One generated frame per rendered one - 2x - on RTX 20 through 50. Turn the game's own frame generation off; expect added latency; the HUD is the part that varies by game.
• Multi-frame generation on RTX 40 (ReShade routes, D3D12 and Vulkan). dashdogy's RTX40MFG-Unlock raises the multiplier of a DLSS Frame Generation the game already has to 3x/4x, in memory, with the Ada temporal correction; the tool places it with Ultimate ASI Loader under a proxy name the executable imports. Offered only on an RTX 40 and only when nvngx_dlssg.dll or sl.dlss_g.dll is in the folder. Research software: higher multipliers and Vulkan can freeze or crash. The multiplier is chosen in ReShade's DLSS MFG tab.
• Frame generation files you downloaded (optiscaler route, D3D12). For DLSS Frame Generation on RTX 30 (dlssg_for_sm86) or RTX 20/30 (DLSS Enabler) through a project this tool cannot download - frame generation files -> add your own... takes the version.dll you downloaded (for dlssg_for_sm86, with its dlssg_sm86.ini beside it; a proxy from its alternatives folder keeps its own name - copy the ini beside it first). The install places them beside the game and records them, OptiScaler never takes the name those files need, and uninstall takes them out again. The tool only uses the copy you give it; forget frame generation files deletes that copy. Not run in a game here; experimental.

The first works in any D3D12 game on the optiscaler route; the second only raises a multiplier the game already has; the third uses files you bring. NVIDIA's own multi-frame generation stays an RTX 50 feature.

A game ships the DLSS build it was released with and keeps it for as long as the studio does not patch one in. Newer builds of NVIDIA's runtimes sharpen the picture and cut the shimmer in the same game, on the same card, and the tool can put a newer one in:

All three come from NVIDIA's own repository, read at its release tag, and the download is checked for being a 64-bit Windows DLL before anything is overwritten. The game's own file is backed up and comes back on uninstall. The ray-reconstruction dropdown starts on keep the game's own. The nvngx_dlss dropdown starts on auto - NVIDIA's own newest build - and the keep the game's own nvngx_dlss switch - on by default - is what decides whether a game that has its own DLSS keeps it.

The parts a game was set up with are recorded, and check versions reads that record against what the publishers offer now: a game whose DLSS - or ReShade, or the neural-rendering runtime, or OptiScaler - has moved on is marked update, with how many of its parts need installing again - a newer build, or the same version in a package that changed. A game whose update or "verify files" removed files the tool wrote is marked update as well. Pressing update on the game's page fetches the newest of everything and keeps your settings and backups.

A swap is worth knowing two things about: a launcher that verifies its files puts its own copy back, and in an online game an anti-cheat can treat a changed file as tampering. For anything you play online, leave these on "keep the game's own".

The dlss page on the left keeps the same three files current for every game in the library, including games DLSS 5 was never installed into. It lists each 64-bit game that ships one of them, with the version it has and NVIDIA's newest (3.7.20 -> 310.9.1), and marks the games that are behind. The tool reads the games a few seconds after it starts, and again when the page is opened if the last read is a day old or the library has games it has not read; check again reads them now. update on a row replaces that game's files; update all does every game that is behind, except games with an anti-cheat and games that are running. The game's own file stays beside the new one as <name>.dlss5-dlss-original, the swaps are recorded in dlss5-dlss-update.json in the game folder, and restore original puts the game's own files back. Once the page has read a game, that game's own page shows a line such as dlss 3.7.20 -> 310.9.1 update while it is behind, and pressing it runs the same update.

The page and a DLSS 5 install share these files:

• a file the DLSS 5 install swapped reads set by the dlss 5 install and is changed from the game's settings, not from this page;
• a DLSS 5 install over a file updated on the page keeps the update as the file it restores, so uninstalling DLSS 5 leaves the update in place;
• restore original while DLSS 5 is installed on top hands the game's own file to the DLSS 5 install, and uninstalling DLSS 5 then puts it back; if the file changed since the update, the page asks you to uninstall DLSS 5 first.

Not offered: 32-bit games. A game that is running is refused until it is closed - Windows does not let a file a program has open be replaced. A game with an anti-cheat is updated only after a question that names the anti-cheat; for a game you play online, do not update it. When a launcher puts its own file back, the page leaves that file alone and lists it as the game's again. When restore or an update finds a file in the way that is neither the game's own nor a build the page wrote, it keeps it beside the runtime as <name>.dlss5-dlss-displaced-<time> instead of deleting it.

Neural rendering itself is not in NVIDIA's SDK. nvngx_dlssnr.dll comes from the community build that matches your card, which is what the next section is about.

nvngx_dlssnr.dll is compiled per architecture. NVIDIA's build is FP8 for RTX 50; the community re-targeted it for older cards. The tool detects the card, picks the matching build, then opens the file and checks its CUDA fatbin records against the card before installing it.

Neural rendering runs inside NVIDIA's nvngx_dlssnr.dll, so a Radeon or an Arc card has no runtime for it to use. Two projects run the network on Radeon through HIP (RDNA 3 / RDNA 4 with HIP 7, Direct3D 12) and their users report both working, at a heavy cost. Neither can be installed from here: the open one keeps the runtime DLL and its weights in a Discord channel rather than in its releases, and the other is closed source. The tool says so when it finds an AMD card, and this becomes a route the day either of them publishes the whole thing.

Swapping the DLL alone does nothing on any card: a game has to ask for neural rendering, and outside NBA 2K27 none do. That request is what the add-on or OptiScaler makes.

The keys below are the defaults. A keyboard without an Insert or a Home key has no way into the overlay at all, so the overlay key setting in a game's settings rebinds both ReShade's and OptiScaler's, and every instruction the tool prints then names the key that was chosen. Pause and Scroll Lock are there for a board with no navigation cluster at all.

Everywhere: MSAA/SSAA off. Set resolution and display mode before turning neural rendering on - the feature is built for one back-buffer size, and a rebuild mid-session is where crashes live. Prefer borderless over exclusive fullscreen for the same reason. "No .fx files found" in ReShade's overlay is normal on the add-on routes; the add-on tab is what matters.

• work area (the slider; on the optiscaler route its ini and log call the same dial model resolution): 75 % is about half the cost of 100 %, 50 % a quarter. The frame keeps full detail; only the model's contribution is computed small.

• feeder build: newest release, newest pre-release, or any exact release when the newest breaks a game. Builds before 0.8 pair with add-on 4.55 and the tool pins it. OpenGL games are pinned to 4.60 (4.70 stalls on GL).

• motion vectors (feeder): LumeniteFX Kernel by default; VORT Motion (optical flow) on OpenGL, where LumeniteFX reads nothing - the tool installs whichever is chosen and puts it above the feed.

• profile: save the dials under a name; Quality / Balanced / Performance are built in.

• read the library when the tool opens (the library's view menu): off means no scan at all - rescan and add a game still work. The scan never walks a whole disk (launcher registries, XboxGames, folders named Games and the like, emulator locations) and skips removable drives. What it finds is kept in %LOCALAPPDATA%\dlss5-autopilot\library.json, so later launches show the list at once; a game that has changed on disk since is read again. rescan asks the launchers what is installed and reads only the games it has not seen; full rescan walks everything, emulators included.

• sidebar pages (the library's view menu): video, remix and vr can come off the sidebar and go back on; a right-click on one of them in the sidebar hides it too.

• aim for _ fps (optiscaler, and the feeder's 64-bit D3D11 path - the same places the work-area slider applies): put in the frame rate you want and the tool works out the work area to reach it, from what the last runs of that game actually measured. It says how confident it is and never applies anything on its own.

• What the work area costs. After each session on those same two routes, whether or not a target is set:

  === what the work area costs here ===
  > in this game, on this card:
  >    50%     1.8 ms of model
  >    75%     4.0 ms of model
  >   100%     7.2 ms of model   (this session)
  > this route writes down what the model cost but not your frame rate, so there is no fps here - only the cost of the dial itself.
  

  Frame time splits into a part the dial does not touch and a part that grows with the area. On the OptiScaler route the model's own cost is in its log, so one session is enough - with no fps column. On the feeder route it takes two sessions at work areas at least five points apart, and each row then gains the frame rate it implies. On the feeder the milliseconds are everything that grows with the work area - the model and the feed together - because that route logs no model cost of its own.

• overlay key: ReShade opens its panel on Home and OptiScaler on Insert. A keyboard with neither can bind another key here, once, for every game - Home, Insert, End, Delete, Page Up, Page Down, Backspace, F9 to F12, Pause or Scroll Lock. On the standalone route, F10 is the add-on's own before/after key, so picking F10 there gives one key two jobs and the tool says so.

• nvngx_dlss and ray reconstruction: the game's own DLSS runtimes, replaceable with newer builds - see Keeping a game's DLSS up to date.

• what will happen? lists what an install would write, back up and remove, without writing anything.

• before / after puts the last two ReShade screenshots side by side.

• check versions: games you set up earlier are checked against what their publishers offer now - DLSS, ReShade, the neural-rendering runtime, OptiScaler - and the game is marked update with how many of its parts need installing again.

• The tool updates itself: a new release downloads in the background, its SHA-256 is checked against the SHA256SUMS.txt GitHub published, and the window offers a one-click restart. "auto_update": false in %LOCALAPPDATA%\dlss5-autopilot\settings.json keeps it manual.

The feed does not care what draws the frame. The video page (on the left bar) fetches a portable MPC-HC into a folder of your choice, sets its renderer to D3D11 and installs DLSS 5 into it like a game. Open a file, paste a YouTube link (played live via yt-dlp, or downloaded first), render a clip through DLSS 5 offline with pick a video and render it, or point a webcam at it. F6 toggles the effect while playing. Neural rendering redraws the whole window, menus included; expect text to look hand-drawn.

Anything on your screen. The screen row captures part of the desktop (Desktop Duplication on the GPU, NVENC, 30 fps) and plays it through DLSS 5 about half a second behind: a browser playing YouTube or Twitch, an emulator, a video call, a game with anti-cheat. Two methods: screen - with one monitor the left 62 % of the screen is captured and the player is parked on the right, on top; with two monitors the whole screen is captured and the player goes to the other one. window - one window from the list is captured on its own, wherever it is and whatever covers it, so the player can go fullscreen over it. Nothing is injected into the source; the delay makes this for watching, not for playing.

A Remix mod rebuilds an old DirectX 8/9 game with path tracing. Once one is installed its runtime sits in a .trex folder beside the game; press rescan, the game appears with remix chosen, and install does three things: the matching nvngx_dlssnr.dll into .trex, one line in rtx.conf, and - only if you turn on swap the Remix runtime - a DLSS 5-capable community runtime in place of one that has no neural pass (original backed up; experimental, it can undo a mod's own fixes).

The remix page on the left bar names the games in your library that have a mod, and lists every project the tool knows about; for the two that publish a complete install as a plain zip on their own releases page - GTA IV and NFS Underground 2 - the list offers download & install when the game is in your library. Nothing is mirrored; every other project is a link.

A VR game on OpenXR draws the headset's two eye images through the OpenXR runtime; the window on your desktop is only a mirror of it. A proxy DLL or the Vulkan layer reaches that mirror, so the headset sees nothing. ReShade's OpenXR layer is the one that reaches what the eyes get, and the vr page in the window is where that lives:

• whether a layer is registered for your user, and whether it is ours or ReShade's own installer's;
• which games in your library carry openxr_loader.dll, the only evidence read from disk that a game goes through OpenXR at all;
• the button that takes our registration out again.

Installing it is part of a game's install: tick VR headset (OpenXR layer) in a 64-bit game's settings. The registration is per user, not per game. Games that only offer OpenVR/SteamVR are not reached by this layer.

Nobody here has a headset, so whether the feeder, the bridge and the DLSS 5 add-on behave inside an OpenXR swapchain is unproven - the page says so, and a report from somebody with a headset is the only thing that can change it. The whole of it, in detail

did it work? reads ReShade.log, dlss5-feed.log, OptiScaler.log, dlss5-bridge.log, the DXVK and Remix logs, what the game had loaded while the tool watched it run, and - when the game left no log at all - Windows' own Application Error record, and names the cause. The watcher reads the same logs, and Windows' crash record, when a game closes.

Bugs: report a bug (on a game's result, or in the help menu) asks two questions - did the game start, and what happened - and then opens a GitHub issue already filled in with version, card, driver, game, route, the last diagnosis, the log tails and, when Windows recorded one, the faulting module of the crash. Nothing is sent by itself - you see it in the browser and decide.

share the result does the same for the compatibility list: the game's name and executable, the route and build, the graphics API, whether the game ships DLSS, FSR or XeSS, the card and driver, this tool's version, whether it worked, the one-line verdict the diagnosis reached, and - where the session was measured - the work area it ran at, the milliseconds a frame spent on what grows with that area, and the frame rate. On OptiScaler that is the model's own cost; on the feeder it is the model and the feed together. No paths, no user name, nothing else. Where the logs cannot show whether DLSS 5 ran - a route that logs no frames - it asks you, and the result says the answer was yours. Those results are added up into one file the tool reads before an install; once a game has five results, the next person with it is told which route worked most often, and whether the one they picked did worse. The issue is closed as soon as it is read - it is a record, not a bug report - and still counts.

Every shared result, by game, card, driver and build: the compatibility list (also in the tool's help menu).

dlss5-autopilot.exe "D:\Games\Game"                 install
dlss5-autopilot.exe "D:\Games\Game" --check         detect only, write nothing
dlss5-autopilot.exe "D:\Games\Game" --remove        uninstall
dlss5-autopilot.exe "D:\Games\Game" --route feeder  native, upstream, optiscaler, renodx, bridge, feeder, standalone, remix
dlss5-autopilot.exe "D:\Games\Game" --route remix --remix-swap   replace a Remix runtime that has no neural pass
dlss5-autopilot.exe "D:\Games\Game" --dxvk          run the game on Vulkan through DXVK (--no-dxvk turns the automatic choice off)
dlss5-autopilot.exe "D:\Games\Game" --vr            register ReShade's OpenXR layer as well (VR, OpenXR games; unverified with a headset)
dlss5-autopilot.exe "D:\Games\Game" --no-gpu-pref   leave Windows' graphics setting alone (two-GPU machines)
dlss5-autopilot.exe "D:\Games\Game" --route optiscaler --opti-build y4my4my4m   another OptiScaler build than Dagherbou's (untested)
dlss5-autopilot.exe "D:\Games\Game" --route optiscaler --opti-build wilsjo2     ...the neural pass before the upscaler, 1-3 passes (untested)
dlss5-autopilot.exe "D:\Games\Game" --route optiscaler --opti-build wilsjo2-mfg   ...the same with RTX 40 multi-frame generation (RTX 40 only, untested)
dlss5-autopilot.exe "D:\Games\Game" --route optiscaler --opti-build janblade     ...Janblade's fork of wilsjo2's, the same placement (untested)
dlss5-autopilot.exe "D:\Games\Game" --route optiscaler --own-fg "D:\Downloads\version.dll"   your dlssg_for_sm86 / DLSS Enabler files, D3D12 (after the first time its name: sm86, sm86-winmm, enabler...; experimental)
dlss5-autopilot.exe --video ["D:\DLSS5 Player"]     set up the video player

• Every release is built by GitHub, not uploaded by a person. A version tag runs release.yml on GitHub's runner, which builds the exe from the commit you can read, writes SHA256SUMS.txt and attaches a signed provenance attestation. certutil -hashfile dlss5-autopilot.exe SHA256 against the release page; gh attestation verify dlss5-autopilot.exe --repo Kizzuwatnaa/DLSS5-Autopilot.
• Or skip the exe: plain Python, standard library and tkinter only, no PyPI packages. git clone and python dlss5_autopilot.py.
• It writes only into the game folders you install into or update DLSS in (plus, for Vulkan games, one per-user registry value it announces first and removes with the last Vulkan game), keeps its cache, its log, its settings, the scanned library, cover pictures, the dlss page's last read and sightings.json - the path of the executable that ran and the DLLs it had loaded, for a game it installed into - in %LOCALAPPDATA%\dlss5-autopilot, never asks for administrator rights, and has no telemetry and no account. The one thing it can send is a game's name to Steam's store search to find a cover, and only after you said yes to that (see Network access).
• Network access, and nothing else: reshade.me, raw.githubusercontent.com, api.github.com, github.com, objects.githubusercontent.com, codeload.github.com. Download URLs and version pins are in core/sources.py; the video player's, the update check's and the shared-results list's are in core/video.py, core/update.py and core/community.py. Covers for games outside Steam come from Epic's image servers (the https address Epic's own catalog cache names for the game, usually cdn1.epicgames.com) and from store.steampowered.com, api.steampowered.com, shared.fastly.steamstatic.com and cdn.cloudflare.steamstatic.com (every other store): the store search sends the game's name, the other requests an app number or an image address. The URLs are in core/covers.py. None of it happens until you answer yes to the question the library asks the first time a game has no cover; view → look up covers online switches it off again, and the icon is shown instead.
• Antivirus warnings. Defender's cloud heuristics (Wacatac.B!ml, Ulthar.A!ml - the !ml is a confidence score, not a match) can delete a new release in its first hours, before enough PCs have run it; the same file is left alone a day later. Every release is submitted to Microsoft as a false positive when it is published; if it happens to you, Windows Security → Protection history → Restore → Allow, or run from source. SmartScreen's Windows protected your PC is the missing paid certificate, not the file: More info → Run anyway. Report false positives: https://www.microsoft.com/en-us/wdsi/filesubmission.

Free code signing provided by SignPath.io, certificate by SignPath Foundation. Signing happens inside the GitHub Actions release workflow, on GitHub-hosted runners; SignPath verifies that a build came out of that workflow before it signs it, so a signed dlss5-autopilot.exe is exactly what the tagged commit builds.

• Team roles. Author, reviewer and approver: Kizzuwatnaa (project owner). Changes proposed by others are reviewed by the owner before they are merged; only the owner approves a signing request.
• Privacy policy. This program will not transfer any information to other networked systems unless specifically requested by the user. It downloads the components it installs from the publishers listed under Network access. No telemetry, no account. Covers are looked up online only after the person answers yes to the library's question (and while look up covers online in its view menu stays on); then the name of a game with no Steam, Epic or Xbox art is sent to Steam's store search. The components it installs are third-party software with their own terms, linked below.

This tool is a downloader and configurator. It bundles nothing; each component stays under its own licence, fetched from its own publisher.

The DLSS 5 add-ons and the neural-rendering runtime are closed-source with no published licence. They are not in this repository, not in the release archive, and not redistributed here; the tool downloads them from a public community mirror exactly as a person would by hand. If you are not comfortable with that, do not use this tool. The three NVIDIA runtimes are taken from NVIDIA's own repository under NVIDIA's SDK licence; the mirror's builds of the same three stay in the list behind them, so a build picked by hand can still come from the mirror. Remix mods are never mirrored. Nothing here is affiliated with or endorsed by NVIDIA, ReShade, RenoDX, OptiScaler, RTX Remix or any project above. The installer's own code is MIT - see LICENSE; what that does and does not cover is in NOTICE. Rights holders: open an issue and it will be addressed.

Thanks to perseval-BLR/dlss5-classic-games for the OpenGL findings.

build.bat                      needs Python 3.10+ and pyinstaller; the release build is GitHub's
python test_all.py             the whole suite
python test_install.py         end-to-end install + uninstall in temp folders
python test_clean_machine.py   empty cache, no local files

dlss5_autopilot.py    entry point (GUI + CLI)
core/games.py         library scanning     core/emulators.py   emulator profiles
core/library.py       the library, kept between launches
core/pe.py            PE parsing, API detection, exe ranking
core/gpu.py           card, driver, CUDA architecture, build tiers
core/dlss.py          which route fits the game and the card
core/sources.py       every download URL and version pin
core/net.py           download, cache, extract
core/covers.py        covers for games outside Steam: Epic, Xbox, Steam's store
core/installer.py     install engine, route switching, uninstall
core/optiscaler.py    the OptiScaler route      core/remix*.py    the Remix route
core/vulkan.py        ReShade as a Vulkan layer  core/dxvk.py      D3D9/D3D11 -> Vulkan
core/refw.py          REFramework               core/anticheat.py anti-cheat markers
core/reshade_ini.py   ReShade.ini and presets    core/feedcfg.py   feeder / bridge cfg
core/diagnose/        logs -> verdict, bug-report body
core/wincrash.py      Windows' own Application Error record
core/autotune.py      the work area to reach a frame rate, from what it cost
core/community.py     what other people found in this game
core/autopilot.py     install, start the game, read what loaded, try the next
core/watch.py         which processes are up, and which DLLs are in them
core/lookout.py       the watcher: installed games starting and closing
core/verdicts.py      which answers another route could change
core/reportui.py      the two questions a bug report needs answered
core/components.py    are the installed parts still current?
core/update.py / selfupdate.py    update check, verified swap-in
core/video.py         MPC-HC, YouTube, offline processing, webcam
core/ui/              interface: shell (window, log drawer, dialogs), kit
                      (controls), library, game page and settings, video,
                      remix, the tray icon, game art and colours

_tools/upstream_watch.py     what moved upstream, and what they say they fixed
_tools/replay_report.py      a bug report's own logs, through the diagnosis
_tools/gui_scale_check.py    the window measured at other display scalings
_tools/walkthrough.py        the window itself, driven through every route
_tools/detect_check.py       what every game in a library detects as
docs/releases/               the notes for every release, named after its tag