Recol/DLSS-Updater: replacing the upscaler DLLs in every game you own

What the tool actually does

The pitch is a single sentence. Update every DLSS, XeSS or FSR DLL across all the games on your system, from one place.

The overview expands it into a mechanism. DLSS Updater scans the games installed on your system, detects the upscaling and frame generation DLLs they ship with, and replaces them with newer versions, with automatic backups so you can always roll back. It runs on Windows and Linux and understands games from every major launcher.

The mechanism is worth understanding because it explains both the value and the risk. A game ships with its own copy of the runtime, often a version that was current when the game was built and is now behind. That runtime is a DLL sitting in the game's directory, and it is what the game's engine actually loads. Replacing the file with a newer build of the same library upgrades the game without touching the game's own code, which is the same trick that makes frame generation and upscaling work in titles that shipped before the technology existed.

The safety mechanism is the backup. Every binary is backed up before it is touched, and any DLL can be restored in one click from the Backups view. That is the right default for a tool that writes into other people's software directories, and the fact that it is mentioned in the feature list rather than buried is a good sign.

Launcher coverage, and the Windows and Linux split

The detection table is more informative than it looks, because each row has a platform column and a notes column.

Steam is supported on both, including Proton games on Linux. The Epic Games Launcher, GOG Galaxy, Ubisoft Connect and EA Play are supported on both with no notes. Battle.net is supported on both but carries a warning, that you should keep the launcher open before updating, which is not required for custom folders. Xbox Game Pass on PC is Windows only. And custom folders are supported on both, so you can point the scanner at any game location manually.

The Battle.net note is the kind of detail that only appears in documentation written by someone who has done it. Some launchers keep the game files in a place that is only readable while the launcher itself is running, so the scan or the copy fails with the launcher closed.

The Linux column has its own section. The scanner looks in the Steam Proton prefixes under `~/.steam/steam/steamapps/compatdata/`, supports Wine prefixes from Lutris and standalone Wine, detects the Steam path automatically, and can enable the DLSS Debug Overlay.

That last item matters for anyone evaluating this on Linux, because the debug overlay is how you confirm that the runtime you replaced is the one being loaded, rather than the one the game shipped with.

The technology list, and the hardware that limits it

The DLL updating section is a long list, and the honest reading of it requires the caveats that come with each entry.

On the NVIDIA side, there is DLSS Super Resolution, plus Ray Reconstruction, Frame Generation and Streamline, which covers Reflex Low Latency, DirectSR and NIS. Then there is DLSS 5 Neural Rendering, which runs alongside Super Resolution rather than replacing it, is limited to the RTX 50 series, and comes with a DLL of about 158 megabytes, so the first download takes a while.

On the Intel side, XeSS, XeSS Frame Generation and XeLL. On the AMD side, FSR covering upscaling, frame generation and ray regeneration, plus an FSR 4 upgrade for games that ship only FSR 3.1, which is limited to RDNA 3 and RDNA 4 cards and is skipped on other GPUs where FSR 4 cannot run. And DirectStorage, which is Windows only.

So the tool will happily update a binary that your hardware cannot use the advanced features of. The FSR 4 case is the one to read twice, since an FSR 4 upgrade on an RDNA 2 card is a file replacement that changes nothing, and the FSR 4 entry is skipped in that case.

There is also a control over what a bulk run means. The caret beside the update action opens a menu of technologies, you untick the ones you want left alone, and the run skips them. The caret shows a count whenever the run is narrower than everything, and the choice applies to that run only before reverting to your saved preferences, so a one-off restricted update does not become a permanent setting.

Presets, per game overrides and the blacklist

The preset feature is the one that goes beyond replacing files. You can apply global or per-game SR, RR and FG preset overrides on Windows with NVIDIA, and per-title Proton launch options on Linux, and the overrides cover the DLSS Super Resolution, Ray Reconstruction and Frame Generation settings, plus the FSR 4 and XeSS DLL upgrades.

That is a different kind of feature from a file copy. A preset changes the quality and latency trade-off the runtime uses, and a per-game override means the same runtime behaves differently in one title than in another, which is what a player who wants maximum sharpness in a competitive shooter and maximum frame rate in a single player game actually wants.

The blacklist is the other control. You can skip, or force, any title with your own per-game blacklist, layered on top of the community list, and the README's table of contents also has separate sections for blacklisted games and for anti-cheat, which tells you the maintainers treat both as first class concerns rather than footnotes.

The smart images feature is the smaller one, optional Steam Web API matching for banners, plus custom banner and name overrides that survive rescans. The persistence of the overrides is the point, since a rescan that wiped them would be a small but constant annoyance.

The dependency list explains the constraints

The `pyproject.toml` is unusually well annotated, and the comments are worth reading because they explain decisions that would otherwise look arbitrary.

The package is `dlss-updater` at version 5.1.1, licensed AGPL-3.0-only, and it requires Python 3.14 or newer with a comment saying it is optimized for free-threaded Python, that is, the GIL disabled. That is a strong statement about the target environment.

`flet` and `flet-desktop` are both pinned to exactly 1.0.2, and the comment explains why. The client and server pair must match exactly, because flet's own desktop extra pins flet-desktop to the same version, and a mismatched pair is unsupported. The comment also records that flet-desktop-light was removed in 0.83.0 and that flet-desktop now defaults to the light flavour on Linux automatically.

Other dependencies carry their own reasoning. `platformdirs` is there because it replaces the unmaintained appdirs, abandoned in 2020, with a near-identical API. `rapidfuzz` provides fast fuzzy string matching for game search, which is how the tool matches a directory on disk to a title in a store database. `nvidia-ml-py` is for NVML GPU detection, used for architecture and DLSS preset hints, and is explicitly best-effort, returning False on non-NVIDIA systems. `pefile` and `psutil` do the file and process work. And `msgspec` is paired with `tomli-w`, because msgspec bundles no TOML writer and the config file is persisted through `msgspec.toml.encode`.

The classifiers say Development Status 5, Production/Stable, with the environment as Win32 and X11 applications and the intended audience as end users on the desktop. That combination, a free-threaded Python and a pinned GUI framework, tells you this is a desktop application that has to behave well on a user's machine, not a script.

Packaging for three very different installers

The repository carries a packaging story for each platform, and they are not variations of the same thing.

There is a PyInstaller spec per target, `DLSS_Updater.spec`, `DLSS_Updater_Linux.spec` and `DLSS_Updater_MSI.spec`, with a `pyinstaller_hooks/` directory and a `hooks/` directory for the build. There is a `DLSS-Updater.nuspec`, which is the NuGet package definition that `winget install "DLSS Updater"` consumes. There is `build_msi.ps1` for the Windows Installer, `build_flatpak.sh` and `build_flathub.sh` and `publish_flatpak_repo.sh` for the Linux side, and the Flatpak and Flathub metadata under `flatpak/` and `flathub/` with the application id `io.github.recol.dlss-updater`.

The Windows installer path explains the self-update behaviour. On Windows the app can download, verify and install a new version and then restart itself, which is what the version badge becoming an update button relies on. On Linux it cannot, because a sandboxed application cannot install packages, so the Flatpak bundle is downloaded and the user is pointed at `flatpak update` or their software centre instead. The project states that restriction plainly rather than pretending the behaviour is the same everywhere.

Two files in the root are for provenance. `VERIFICATION.TXT` is a verification artefact for the released binaries, and `release_notes.txt` holds the notes that the self-updater shows.

Where this is the wrong tool

The first wrong case is a machine whose games already ship current runtimes. A publisher that updates the DLL in its own patch means there is nothing for a third party tool to do, and running a bulk replacement over games that are fine adds risk for no gain.

The second is hardware that cannot use what you are installing. A machine with an RDNA 2 GPU will not benefit from an FSR 4 upgrade, and a machine without an RTX 50 card will not run DLSS 5 Neural Rendering, so the tool can replace a file and change nothing measurable.

The third is a title on the blacklist, whether the community list or your own, which the tool honours.

The fourth is an organisation that cannot accept an AGPL application writing into its licensed software. The licence is AGPL-3.0-only, and the tool is a desktop application that people install, which is the least constrained way to use one, but a managed environment with its own patching policy will have opinions about a third party tool rewriting binaries inside game directories.

On the state of the project, the releases are frequent, with 5.0.3 on 2026-09-18, 5.1.0 on 2026-09-29 and 5.1.1 on 2026-10-09, and the last push to the repository on 2026-10-15 with the repository not archived. The tree also has a `benchmarks/` directory, a `tools/` directory, a `sync_to_wsl.sh` script for moving between Windows and a WSL install, and a `.python-version` file pinning the interpreter.

Editorial conclusion

Adopt DLSS Updater if you own games that ship with an out-of-date upscaler and you want a single place to update them, with backups you can roll back, instead of waiting for each publisher to ship a patch. Do not adopt it if your games already ship current runtimes, and read the hardware caveats first, because DLSS 5 Neural Rendering needs an RTX 50 series card and an FSR 4 upgrade needs RDNA 3 or 4, so a bulk update can do nothing on the machine you are sitting at. Verify first that the titles you care about are not on the blacklist, that the launcher holds the game files unlocked, since Battle.net in particular is documented as needing to stay open, and that you understand the licence, since it is AGPL-3.0-only and it modifies files inside other vendors' software.

Frequently asked questions

Official sources

1. Issues
2. License: AGPL-3.0
3. README
4. Recol/DLSS-Updater on GitHub
5. Releases