Steam, GOG, Epic Games Store, Battle.net, the EA app, Ubisoft Connect, Humble Bundle, and Amazon Prime Gaming: PC gamers who buy from more than one storefront now juggle a rotating cast of clients just to remember what they own and where. On Linux, until recently, that problem was worse, because several of those clients had no native build at all. Lutris solves it by sitting on top of Wine, Proton, and more than a dozen emulator runners, then wrapping the entire mess in one open-source library that can log into every storefront at once. This tutorial walks through a complete Lutris installation on Ubuntu, Fedora, Arch, and Flatpak, using the current v0.5.22 release and the project’s real 2026 GitHub numbers, from checking GPU drivers to scripting backups from the terminal.

What Is Lutris? A Look at Linux’s Open Gaming Platform

Lutris is an open-source game launcher and library manager built specifically for Linux. It does not run games itself the way an emulator does. Instead, it drives other tools underneath it, Wine and Valve’s Proton for Windows titles, plus runners like DOSBox, ScummVM, MAME, and Dolphin for older platforms, and presents everything inside one searchable library. The project describes itself on its own homepage as an “Open Gaming Platform,” and Flathub’s listing calls it a “video game preservation platform,” which is a fair summary of what it has grown into since it started.

The Lutris GitHub organization has run the project since 2013, and the codebase is written in Python. As of this writing, the repository shows 10,101 stars, 859 forks, and 276 open issues, with commits pushed as recently as July 14, 2026, a sign the project is still under active daily development even though its most recent tagged release, v0.5.22, shipped back in February. Lutris is licensed under GPL-3.0, so the source is free to inspect, fork, or audit, which matters if you want to know exactly what a tool touches on your system before handing it your GOG and Epic Games credentials.

The Flatpak build, distributed under the app ID net.lutris.Lutris on Flathub, weighs in around 318 MiB for the app itself, and Flathub’s own listing reports tens of thousands of monthly downloads, and that is only one of the eight install paths covered later in this guide. If you have spent any time in our gaming coverage, Lutris sits in the same practical toolbox as the emulators and Linux gaming distributions we have already covered, it is simply the piece that handles native PC storefronts and Windows-only titles instead of retro consoles.

Crucially, Lutris does not host, crack, or distribute any game files itself. It is closer to a remote control for tools you already have installed, or are about to install, than it is to a store. Every game you add still comes from a storefront you legitimately own it on, and every Wine or Proton build it downloads comes from that runner’s own public GitHub releases. That distinction matters for anyone evaluating whether a tool like this is safe to run against real Steam, GOG, or Epic credentials, and it is a large part of why the project has stayed in Arch’s official repositories and on Flathub without issue since 2013.

Why Gamers Are Switching to Lutris in 2026

The single biggest shift behind Lutris in 2026 is what happened to Wine-GE. GloriousEggroll’s dedicated Wine-GE builds, once the standard compatibility layer for non-Steam Windows games on Linux, have had no new release since early 2024, with development effort consolidated into GE-Proton instead. Lutris adapted by shipping the umu launcher, a small compatibility shim that lets GE-Proton run outside of Steam. As of version 0.5.20, GE-Proton launched via umu became the default runner for Windows games, and Lutris stopped exposing manual VKD3D, D3D Extras, and DXVK-NVAPI toggles on Proton specifically, because Proton now applies all of that itself. That single change removed one of the most common sources of configuration confusion for new users.

The table below reflects the three most recent tagged releases, pulled directly from the project’s GitHub release notes rather than secondary summaries, since third-party aggregators have previously misdated Lutris changes.

VersionReleasedWhat Changed
v0.5.22Feb 25, 2026Python <3.14 compatibility fix, added mypy typing annotations, updated release targets
v0.5.20Feb 16, 2026GE-Proton via umu becomes the default runner; VKD3D/D3D Extras/DXVK-NVAPI toggles hidden on Proton; Wine runner gains a Wayland-driver option; BIOS file location for libretro moved into Preferences
v0.5.18Dec 2, 2024Auto-downloads the latest GE-Proton build, dark theme by default, fancy search tags like installed:yes and source:gog, new “Uncategorized” sidebar view

Beyond the runner changes, the appeal is simpler than any single release note: one login screen per storefront instead of eight separate applications, each with its own update cycle, tray icon, and background process. For anyone who has switched between a Steam desktop client, the Epic Games Store, GOG Galaxy, and a Battle.net launcher in the same afternoon, cutting that down to a single window is the actual feature that keeps people using Lutris.

The install-script ecosystem reinforces that same convenience. Rather than every user individually figuring out which Winetricks components a given Windows game needs, the community writes and moderates a script once on lutris.net, and everyone after that just clicks Install. It is the same crowdsourced-compatibility idea behind Valve’s ProtonDB, applied to installation instead of post-launch compatibility ratings, and it is a big part of why Lutris continues to grow even though its formal Wine and GE-Proton internals change relatively slowly between releases.

Prerequisites: What You Need Before You Install Lutris

Lutris itself is lightweight, but it is only as good as the graphics stack underneath it. The single most common reason a game fails to launch is not Lutris misconfiguration, it is missing or outdated GPU drivers and an incomplete Vulkan stack, since both DXVK and VKD3D-Proton translate Windows graphics calls into Vulkan calls at runtime. Confirm the following before you touch an installer.

RequirementMinimumWhy It Matters
Linux distributionUbuntu, Fedora, Arch/Manjaro, openSUSE, Solus, Clear Linux, or SteamOSOfficial packages or Flatpak availability covers all of these
NVIDIA driverProprietary driver, version 550 or newerDXVK and VKD3D-Proton need a current Vulkan 1.3 implementation
AMD/Intel driverCurrent Mesa, plus 32-bit Vulkan libraries32-bit games need the multilib Vulkan ICD installed alongside the 64-bit one
Disk space~318 MB for the Flatpak app aloneEach Wine prefix and each GE-Proton build adds several gigabytes on top
Storefront accountsValid login for each service you plan to addSteam, GOG, Epic, Battle.net, the EA app, Ubisoft Connect, Humble Bundle, Amazon Prime Gaming

If you are installing from source or a non-Flatpak package, you also need Python 3 and GTK libraries on the system, though every packaged install method below pulls those in automatically as dependencies.

Step 1: Verify Your GPU Drivers and Vulkan Support

Start here even if you are confident your drivers are current. On NVIDIA, confirm the installed driver version directly:

nvidia-smi --query-gpu=driver_version --format=csv

You want to see 550.xx or higher in the output. On any GPU vendor, confirm Vulkan itself is reachable:

vulkaninfo --summary

A healthy system prints something close to this, with your own GPU name and driver version in place of the example below:

==========
VULKANINFO
==========

Vulkan Instance Version: 1.3.280

GPU0:
	apiVersion         = 1.3.280
	driverVersion      = 550.120.03
	deviceType         = PHYSICAL_DEVICE_TYPE_DISCRETE_GPU
	deviceName         = NVIDIA GeForce RTX 4080

If the command is not found, install your distribution’s vulkan-tools package (or the equivalent) before continuing. Finally, double-check your OpenGL baseline, since some older or fallback runners still depend on it:

glxinfo | grep "OpenGL version"

If any of these three checks come back empty or show a driver you do not recognize, fix that first. Every later step in this guide assumes a working Vulkan stack, and most “Lutris won’t launch my game” reports trace back to skipping this step.

Step 2: Install Lutris on Ubuntu, Debian, and Linux Mint

Ubuntu, Elementary OS, and Linux Mint users install directly from the .deb package published on the project’s GitHub releases page, rather than through a PPA:

cd ~/Downloads
wget https://github.com/lutris/lutris/releases/download/v0.5.22/lutris_0.5.22_all.deb
sudo apt update
sudo apt install ./lutris_0.5.22_all.deb

Debian users have a dedicated repository maintained on the openSUSE Build Service, since Debian’s own repos do not package Lutris directly. Add the signed repo, then install normally:

echo -e "Types: deb\nURIs: https://download.opensuse.org/repositories/home:/strycore:/lutris/Debian_13/\nSuites: ./\nComponents: \nSigned-By: /etc/apt/keyrings/lutris.gpg" | sudo tee /etc/apt/sources.list.d/lutris.sources > /dev/null
wget -q -O- https://download.opensuse.org/repositories/home:/strycore:/lutris/Debian_13/Release.key | sudo gpg --dearmor -o /etc/apt/keyrings/lutris.gpg
sudo apt update
sudo apt install lutris

A successful install ends with apt reporting the package unpacked and configured with no errors. Launch it from your application menu, or type lutris in a terminal to confirm the binary resolved correctly.

Step 3: Install Lutris on Fedora

Fedora carries Lutris in its official repositories, so the install is a single command with no extra repo configuration:

sudo dnf install lutris

dnf will pull in Python, GTK, and the other runtime dependencies automatically. If you plan to run 32-bit Windows games through Wine, also confirm the 32-bit Mesa and Vulkan packages are present, since Fedora’s default install is 64-bit only on many editions:

sudo dnf install mesa-vulkan-drivers.i686

Step 4: Install Lutris on Arch Linux and Manjaro

Lutris lives in Arch’s official Extra repository, which means Arch and Manjaro users do not need the AUR at all, despite what some older tutorials still claim:

sudo pacman -S lutris

Because Arch ships rolling releases, this typically installs the newest tagged version, v0.5.22 at the time of writing, within days of it appearing on GitHub. If you specifically want a development snapshot ahead of the next tag, the AUR does host a lutris-git package that builds from the latest commit, though that is a power-user option, not a requirement.

Step 5: Install Lutris via Flatpak (Works on Any Distro)

If you would rather skip distro-specific packaging entirely, or you are on SteamOS, Solus, Clear Linux, or anything else not covered above, the Flatpak build works identically everywhere Flatpak itself runs:

flatpak install flathub --user -y net.lutris.Lutris

A beta channel is also available if you want to track pre-release builds:

flatpak install flathub-beta --user -y net.lutris.Lutris

The tradeoff with Flatpak is sandboxing. By default, the app can only see your home directory, so if your game library lives on a second drive mounted elsewhere, grant it access explicitly:

flatpak override --user --filesystem=/mnt/games net.lutris.Lutris

Solus users can skip Flatpak and use the native package manager instead (sudo eopkg install lutris), and Clear Linux users have their own bundle command (sudo swupd bundle-add lutris). Steam Deck owners should install through the Discover store while in Desktop Mode, which is effectively the same Flatpak build under the hood.

Open Lutris for the first time and you land on an empty library with a sidebar listing every supported source. Lutris itself does not require its own account to browse the interface, but linking a storefront does require signing in through that storefront’s own authentication flow, typically an embedded browser window, so your credentials go directly to Steam, GOG, or Epic and not through a Lutris-hosted server.

Click a source in the sidebar, such as GOG or Epic Games Store, and Lutris opens that service’s real login page. After you authenticate, it pulls your owned titles into the library automatically and tags each entry with its source, which is also what powers the search filters mentioned earlier, like source:gog or installed:yes. Repeat this for every storefront you use. There is no limit on how many you can link simultaneously, and the whole point of the tool is that you do not need to log out of one to add another.

Step 7: Install Wine, Proton, and GE-Proton Runners

Windows games need a compatibility layer, and Lutris manages this through its built-in Wine Manager rather than requiring you to install anything through your system package manager first, although the official FAQ still recommends installing a base Wine package from your distro’s repos so system dependencies are satisfied before Lutris downloads its own builds on top.

Open Preferences, then the Runners tab, and you will see Wine, GE-Proton (via umu), DOSBox, ScummVM, MAME, Dolphin, and several other emulation runners listed, each with a version manager. For Windows games specifically, GE-Proton is the recommended choice in 2026, since it bundles DXVK, VKD3D-Proton, and FAudio patches that Valve’s own upstream Proton does not include, and because it has been the Lutris default since v0.5.20. Downloaded runners are stored locally and can be confirmed from a terminal:

ls ~/.local/share/lutris/runners/wine/

The official Lutris FAQ includes an important caveat worth repeating verbatim, since it sets expectations correctly for anyone coming from Steam’s Proton integration: “Proton was not designed to run games outside of Steam, and the results may vary.” Most titles work fine, but Lutris is running Proton in a context Valve never officially tested, so treat per-game quirks as normal rather than a sign something is broken.

Step 8: Add Your Steam, GOG, Epic Games, and Battle.net Libraries

Steam is a slightly different case from the other storefronts, because Lutris can either launch your existing native Steam client and its Linux-native or Proton-run titles, or it can manage a game as a Wine-run Windows build if you specifically want to bypass Steam’s own Proton version. Most users simply let Steam continue to manage its own library and use Lutris for everything else.

For GOG, Epic Games Store, and Amazon Prime Gaming, once you have signed in during Step 6, owned titles appear in your library automatically, and clicking Install triggers that storefront’s own installer inside a Wine prefix Lutris creates and manages for you. Battle.net and Ubisoft Connect work slightly differently: Lutris installs the Battle.net or Ubisoft Connect client itself inside a prefix first, the same way you would on a fresh Windows machine, and you then sign in and install individual games from inside that client, exactly as you would on Windows. Humble Bundle games, since many ship as standalone installers rather than through a client, typically use direct install scripts pointed at the file you download from your Humble Bundle library page.

One detail worth planning around before you link a dozen accounts in one sitting: each service authenticates independently, and each keeps its own session length and refresh behavior, so a Battle.net or Ubisoft Connect prefix may occasionally ask you to sign in again after weeks of inactivity, exactly as the native Windows client would. That is normal storefront session expiry, not a Lutris bug, and re-authenticating takes the same few seconds it would on any other platform.

Step 9: Install a Windows-Only Game With a Community Script

For games that need special handling, custom DLL overrides, specific Wine versions, or extra Winetricks components, Lutris relies on community-submitted install scripts hosted and moderated on lutris.net. These are written in YAML or JSON and reference a small set of documented keys and tasks, such as create_prefix, wineexec, and winetricks. A simplified example, illustrating the structure rather than any single real published script, looks like this:

installer:
- task:
    name: create_prefix
    prefix: "$GAMEDIR"
    arch: win64
- task:
    name: winetricks
    prefix: "$GAMEDIR"
    app: vcrun2019
- task:
    name: wineexec
    executable: setup.exe
    prefix: "$GAMEDIR"

game:
  exe: $GAMEDIR/drive_c/Program Files/ExampleGame/game.exe
  prefix: $GAMEDIR

In practice, you rarely write one of these from scratch. Search the game’s title from inside Lutris, and if a community script exists, it downloads and runs automatically; you only need to babysit the Windows-style installer wizard it launches inside the prefix. If no script exists yet, Lutris still lets you add the game manually by pointing it at an executable inside a prefix you create yourself through the same Wine Manager covered in Step 7.

Step 10: Configure Controllers and Input

Controller support runs through Wine’s own input handling, and a few practical rules make the difference between a pad that works immediately and one that silently fails to respond. First, for multi-mode pads such as 8BitDo controllers that can switch between input protocols, set the pad to XInput mode specifically, since Wine’s compatibility with XInput is considerably more consistent than with DirectInput. Second, Bluetooth pads must be paired and connected before you launch the game, not after; launching first and connecting the controller afterward frequently produces a “phantom” state where the OS sees the device but the game does not.

To confirm the kernel sees your controller correctly before troubleshooting inside a specific game, check it directly at the input level:

evtest
# select your controller's /dev/input/eventX from the numbered list

If a controller behaves correctly in Lutris’s own runner but not inside a specific Wine game, tools like SDL2 Gamepad Tool or AntimicroX help diagnose and remap the underlying SDL_GAMECONTROLLERCONFIG mapping, which is the layer most Wine and Proton titles actually read from.

Step 11: Tune Performance With DXVK, VKD3D, and FSR

Since v0.5.20, Lutris no longer exposes manual DXVK, VKD3D, and DXVK-NVAPI toggles when you are running a game on Proton, because Proton bundles and manages all three itself. Those toggles still exist for the plain Wine runner, under each game’s Configure screen, System options tab. This is where per-game environment variables and debug overlays live. A common pair to set while benchmarking:

DXVK_HUD=fps,memory
VKD3D_CONFIG=dxr

DXVK_HUD=fps,memory overlays a live frame-rate and VRAM counter in the corner of the game window, which is the fastest way to confirm a change actually helped before you commit to it. AMD FSR upscaling, where a game supports it natively, is exposed as an in-game graphics option rather than a Lutris or Wine setting, so check that game’s own video menu first rather than looking for it in Lutris’s configuration screens.

Step 12: Back Up Your Library and Automate With the CLI

Everything Lutris manages, your library metadata, Wine prefixes, and any custom install scripts, lives under one directory: ~/.local/share/lutris. Back this up before a distro reinstall or a major system change, and you preserve every configured game without re-running installers:

tar -czvf lutris-backup-$(date +%F).tar.gz ~/.local/share/lutris

Lutris also exposes a command-line interface for scripting, useful if you want to launch a specific game from a custom application menu, a script, or a Steam Deck non-Steam-game shortcut rather than opening the full GUI:

lutris --list-games
lutris --list-runners
lutris lutris:rungameid/12345

The numeric ID in the last command corresponds to the game’s internal ID inside your own library, visible in the --list-games output, so this is specific to your machine rather than a universal identifier.

Lutris as an Emulation Frontend: DOSBox, ScummVM, MAME, and Dolphin

Most of this guide focuses on Windows storefront games, since that is what draws the largest share of searches, but Lutris’s runner system covers retro emulation just as thoroughly. The same Preferences > Runners screen used to manage GE-Proton in Step 7 also lists DOSBox for MS-DOS software, ScummVM for classic point-and-click adventures, MAME for arcade boards, and Dolphin for GameCube and Wii titles, each downloadable and version-managed the same way. If you already run any of these as standalone applications, covered in our dedicated RetroArch and Dolphin tutorials, Lutris does not replace them, it gives you the option to fold them into the same library view as your Steam and GOG games instead of switching between separate applications.

This is also where Lutris’s install-script system pulls double duty. A script for a DOSBox game configures the emulator’s `.conf` file and mounts the right virtual drive automatically, the same way a Windows game script creates a prefix and runs an installer. The practical benefit is consistency: whether you are launching a 2026 GOG release or a 1993 DOS title, the launch button, the controller mapping screen, and the search bar behave identically, because they are all just different runners inside the same interface rather than different programs with different conventions.

Complete Working Example: From Zero to a Launched Game

To tie every step above into one concrete path, here is the full sequence for a freshly installed distro, using the Flatpak method since it is the most universal, ending with a GOG game launched entirely from the terminal:

# 1. Confirm the graphics stack
vulkaninfo --summary

# 2. Install Lutris
flatpak install flathub --user -y net.lutris.Lutris

# 3. Launch it once to complete first-run setup and link GOG in the GUI
flatpak run net.lutris.Lutris

# 4. After linking a store and installing a game through the GUI,
#    confirm it registered correctly
lutris --list-games

# 5. Launch that game directly from the terminal going forward
lutris lutris:rungameid/1

Steps 3 and the in-app GOG install still require the GUI, since storefront authentication happens in an embedded browser window and cannot reasonably be scripted, but everything before and after that point is fully terminal-driven, which is exactly what you want if you are wiring Lutris into a custom Steam Deck shortcut, a kiosk-style gaming PC, or a scripted fresh-install checklist.

Lutris vs Heroic Games Launcher vs Bottles: Feature Comparison

Lutris is not the only tool in this space, and it is worth knowing exactly where it overlaps with its two closest rivals rather than assuming one replaces the other. Heroic Games Launcher covers Epic, GOG, and Amazon Prime Gaming across Linux, Windows, and macOS, but does not touch Battle.net, Ubisoft Connect, or emulation. Bottles is not a store client at all, it is a Wine-prefix isolation manager, useful for running individual Windows applications and games in cleanly separated environments, but it will not import your Steam or GOG library for you.

ToolGitHub StarsLicenseStore CoverageEmulation Runners
Lutris10,101GPL-3.0Steam, GOG, Epic, Battle.net, EA app, Ubisoft Connect, Humble Bundle, Amazon Prime GamingYes, DOSBox, ScummVM, MAME, Dolphin, and more
Heroic Games Launcher11,831GPL-3.0Epic, GOG, Amazon Prime GamingNo
Bottles8,613GPL-3.0None, prefix manager onlyNo

At an identical Wine or Proton runner version, in-game frame rates are equivalent across all three tools, since none of them touch rendering directly, they only orchestrate the compatibility layer underneath. The practical choice comes down to scope: pick Lutris if you want the broadest single library across the most storefronts plus retro emulation, pick Heroic if Epic and GOG are your only non-Steam sources and you also need macOS or Windows support, and pick Bottles if you specifically want isolated per-application Wine prefixes rather than a unified game library at all.

The Riot Vanguard Problem: What Lutris Still Cannot Run

Install scripts for League of Legends exist on lutris.net and will install the client without errors, which leads some searches to assume the game is fully playable through Lutris. It is not, and this is worth being direct about rather than overselling the install script. Riot’s kernel-level anti-cheat, Vanguard, blocks Wine and virtualization entirely at the driver level. Riot’s own developer blog, published in April 2024, explained the reasoning directly: Linux does not currently offer a way to attest boot state or kernel modules to Vanguard’s satisfaction, and Riot cited roughly 800 daily Linux and Wine users as too small a population to justify building that support, according to GamingOnLinux’s coverage of the announcement.

This is a structural limitation rather than a bug Lutris or Wine can patch around, and it is the same category of blocker that affects other kernel-anti-cheat titles under Wine generally, not something specific to how Lutris configures a prefix. The community resource League of Linux tracks the current status if this changes. If a specific game you care about uses a kernel-level anti-cheat, check that game’s own stated Linux policy before spending time on an install script, rather than assuming Lutris can work around it.

6 Common Pitfalls When Setting Up Lutris

  • Assuming the AUR is required on Arch. Lutris has been in the official Extra repository for years; installing from the AUR instead just adds unnecessary build time and a second, redundant package source.
  • Skipping the 32-bit Vulkan libraries. Many Windows games are still 32-bit binaries even in 2026. A 64-bit-only Vulkan install will fail silently on exactly these titles while working fine on 64-bit ones, which makes the root cause harder to spot.
  • Connecting a Bluetooth controller after launching the game. Pair and connect first. Reconnecting mid-session frequently requires a full game restart to be recognized.
  • Expecting DXVK/VKD3D toggles on Proton. Since v0.5.20 those settings only appear for the plain Wine runner. If you are on GE-Proton and cannot find the toggle, that is expected behavior, not a missing feature.
  • Treating the Flatpak sandbox like a normal install. Games or drives outside your home directory need an explicit flatpak override --filesystem grant, or Lutris simply will not see them.
  • Assuming any anti-cheat game will “probably work.” Kernel-level anti-cheat is a hard block, not a compatibility gap Lutris configuration can close. Check the specific game before investing setup time.

Troubleshooting: 10 Lutris Errors and How to Fix Them

SymptomLikely CauseFix
Game won’t launch, no error shownMissing 32-bit Vulkan/Mesa librariesInstall your distro’s multilib or .i686 graphics package
Black screen immediately after launchDXVK failed to initializeConfirm your GPU driver meets the Vulkan 1.3 minimum from Step 1
Controller not detected in-gameBluetooth pad connected after the game startedPair and connect the pad first, then launch
“No space left on device” mid-installWine prefix plus GE-Proton build exceeded free disk spaceFree space, or relocate the prefix to a larger drive
Game installs but can’t find the executableInstaller script assumed a default Program Files pathEdit the exe path manually under Configure > Game options
GOG or Epic login window stays blankMissing WebKitGTK dependency (non-Flatpak installs)Install your distro’s webkit2gtk package
Audio stutters or is missingAudio driver inside the Wine prefix is misconfiguredReconfigure audio via Winetricks inside that specific prefix
Anti-cheat game refuses to startKernel-level anti-cheat (Vanguard and similar) blocks Wine outrightNo workaround exists; verify the game’s Linux policy first
Flatpak build can’t see an external driveSandboxed filesystem permissionsflatpak override --user --filesystem=/path net.lutris.Lutris
Runner download stuck or stalls repeatedlyGitHub or GE-Proton mirror rate limiting, or a dropped connectionRetry later, or download the runner build manually into ~/.local/share/lutris/runners/wine/

Advanced Tips for Power Users

Once the basics are running reliably, a few habits separate a smooth long-term Lutris setup from one that needs constant fiddling. Keep more than one GE-Proton version downloaded rather than only the latest, since a small number of games regress on newer builds and having an older version one click away in the runner list saves a troubleshooting session later. Use the fancy search tags mentioned earlier, installed:yes, source:gog, and similar, to keep a large mixed library navigable instead of scrolling through everything at once; the search box’s filter button can build these for you without memorizing the exact syntax.

On Steam Deck or any SteamOS-based handheld, add Lutris itself as a non-Steam game from Desktop Mode so it appears in Game Mode with full controller and touchscreen input, rather than only being reachable from the desktop interface. This is the same integration pattern Bazzite uses when it bundles Lutris alongside Steam out of the box. If you are chasing maximum performance on a specific title, combine the DXVK_HUD overlay from Step 11 with a per-game environment variable override rather than a global one, since a debug overlay left on globally clutters every game you launch afterward, including ones where you no longer need it.

Finally, because the entire library configuration lives in one directory, treat ~/.local/share/lutris the same way you would treat a browser profile: back it up on a schedule, not just before a reinstall, since a corrupted config after a bad shutdown is far more common than a full disk failure.

How to Remove or Reinstall Lutris

Because your library metadata, Wine prefixes, and install scripts all live under the single ~/.local/share/lutris directory covered in Step 12, removing or reinstalling Lutris cleanly is mostly a question of whether you want to keep that directory or wipe it. To remove the package but keep your configured games and prefixes intact for a future reinstall, uninstall only the application itself:

# Debian/Ubuntu
sudo apt remove lutris

# Fedora
sudo dnf remove lutris

# Arch/Manjaro
sudo pacman -R lutris

# Flatpak
flatpak uninstall net.lutris.Lutris

Reinstalling with any of the Step 2 through Step 5 methods afterward picks the existing library back up automatically, since none of those commands touch ~/.local/share/lutris. For a genuinely clean slate, for example if a prefix is corrupted beyond repair and you would rather start over than debug it, remove that data directory as well after uninstalling the package:

rm -rf ~/.local/share/lutris ~/.config/lutris

This deletes every Wine prefix Lutris created, so any game installed exclusively through Lutris will need to be reinstalled from its storefront afterward. It does not touch the original installers or your storefront accounts themselves, only the local Lutris-managed copies, which is why the backup step covered earlier is worth doing before you reach for this command rather than after something breaks.

Security and Account Safety on Lutris

Because Lutris links directly to Steam, GOG, Epic, Battle.net, and other accounts, it is worth understanding exactly what it does and does not touch. Authentication for every storefront happens through that storefront’s own login page, opened inside an embedded browser window, not through a Lutris-hosted service, so your password is never typed into a Lutris-controlled form. Being open-source under GPL-3.0 means the authentication flow is auditable rather than a black box, which is a meaningful difference from closed-source third-party “universal launchers” that ask you to enter credentials directly into their own interface.

The main practical security consideration is scope creep in what you grant the Flatpak sandbox. Only add flatpak override --filesystem permissions for directories that actually contain your games, rather than broadly granting home-directory-wide or root filesystem access out of convenience. And if you use two-factor authentication on any linked storefront, which we would recommend regardless of which launcher you use, expect the embedded browser window to prompt for it exactly as your regular browser would, since it is going through the same real authentication endpoint.

Frequently Asked Questions

Is Lutris free?

Yes. Lutris is free and open-source under the GPL-3.0 license, with the source code publicly available on GitHub. There is no paid tier, subscription, or premium version.

Is Lutris safe to use?

Lutris itself is open-source, so its code is publicly auditable, and it authenticates you directly through each storefront’s own login page rather than handling your passwords internally. The main risk to manage yourself is community install scripts, since they are user-submitted; stick to scripts with clear community moderation history on lutris.net and review what a script does before running it if you are cautious.

Does Lutris work on Steam Deck?

Yes. Install it through the Discover store in Desktop Mode, then add it as a non-Steam game so it launches from Game Mode with full controller support.

Can Lutris run League of Legends?

The client installs, but the game itself will not get past Riot’s Vanguard anti-cheat, which blocks Wine and virtualization at the kernel level. This is a Riot policy decision, not a Lutris or Wine limitation that a future update is likely to fix.

What is the difference between Lutris and Heroic Games Launcher?

Lutris covers more storefronts, including Battle.net, Ubisoft Connect, and Humble Bundle, and adds emulation runners for retro platforms. Heroic Games Launcher covers only Epic, GOG, and Amazon Prime Gaming, but also runs natively on Windows and macOS, not just Linux, which matters if you want one launcher across multiple operating systems.

Do I need Wine installed separately before using Lutris?

Not strictly, Lutris downloads and manages its own Wine and GE-Proton builds through its built-in Wine Manager. That said, the official FAQ recommends installing a base Wine package from your distro’s own repositories first, so underlying system dependencies are already satisfied.

Does using Lutris put my Steam, GOG, or Epic account at risk?

Authentication happens through each service’s own official login page inside an embedded browser window, the same flow you would go through in a regular browser, including any two-factor prompts. Lutris does not store your password itself.

Where does Lutris store my games and settings?

Library metadata, Wine prefixes, and custom install scripts all live under ~/.local/share/lutris. Back up that single directory before a reinstall or major system change to preserve your entire configured library.

Can I use Lutris on Windows or macOS?

No. Lutris is Linux-only. Windows users already run native installers directly, and macOS users looking for an Epic/GOG/Amazon unifier should look at Heroic Games Launcher instead, which supports all three desktop operating systems.

What happens to my installed games if I uninstall Lutris?

Uninstalling just the Lutris package leaves your library data and Wine prefixes untouched under ~/.local/share/lutris, so reinstalling picks everything back up. Only deleting that directory directly removes the underlying prefixes and forces a reinstall of each game from its original storefront.