If you have moved a gaming PC to Linux in 2026 – or you game on a Steam Deck, Bazzite, or any SteamOS-adjacent handheld – you eventually hit the same wall: a game that lives outside Steam. A Blizzard title on Battle.net, an EA release, a GOG classic, or a Windows-only launcher that Valve’s Proton never sees. Lutris is the open-source game manager that fills that gap. It wraps Wine, Proton, GE-Proton, and emulators behind one library, pulls in community-written install scripts, and turns a half-day of manual winecfg wrangling into a few clicks.
This guide is a complete, end-to-end Lutris setup for 2026. We cover prerequisites with exact versions, twelve numbered steps from a clean install to a running Windows game, a full worked example (Battle.net plus a Blizzard title), five common pitfalls, an eight-row troubleshooting table, and advanced tuning. By the end you will have a working multi-store Linux gaming library. Total time: roughly 30–45 minutes, most of it spent waiting on downloads.
Don't miss new tech stories on Google
Add Tech Insider once in the Google app and our stories appear in your news suggestions.
What Is Lutris and Why Use It in 2026?
Lutris is a free, open-source game manager for Linux that has been in active development for more than a decade. GamingOnLinux reported that this cycle opened with Lutris 0.5.19 in February 2025, adding improved Proton handling, and the current stable release is Lutris 0.5.22, which GitHub’s release notes date to 24–25 February 2026 – arriving just hours after 0.5.21 and specifically restoring Proton game launching that had regressed in that prior build. The project’s main repository had grown to 10,101 GitHub stars and 276 open issues as of July 2026, with fresh commits still landing that same month. Unlike a single-store client such as Steam or the Epic Games launcher, Lutris is store-agnostic: it presents one unified library and lets each game use whatever runner it needs underneath.
The core idea is the runner. A runner is the engine that actually executes a game – Wine for Windows software, native Linux for ported titles, an emulator (RetroArch, ScummVM, and others) for retro and console games, or a browser for web games. On top of that, Lutris hosts a community-maintained database of install scripts on lutris.net that automate the messy parts: creating a Wine prefix, installing dependencies, downloading the right components, and applying per-game tweaks. You click “Install,” answer a prompt or two, and the script does the rest.
Lutris connects to a broad set of storefronts and services. In 2026 it integrates with Steam, Epic Games Store, GOG, Battle.net, the EA app, Ubisoft Connect, Humble Bundle, and Amazon Prime Gaming. You authenticate once per source and Lutris imports your owned titles into the library. That makes it the closest thing Linux has to a single front-end for everything you own – comparable in spirit to Playnite on Windows, but built around Wine and Proton rather than native Windows binaries.
Why bother instead of just using Steam’s built-in Proton? Because Proton only covers your Steam library. The moment you want Diablo IV from Battle.net, a DRM-free GOG purchase, or an EA title, you need Wine configured correctly – and Lutris automates exactly that. It pairs naturally with a gaming-focused distro; if you have not chosen one yet, see our Bazzite vs SteamOS vs ChimeraOS comparison. For Epic and GOG specifically, many users run Lutris alongside the Heroic Games Launcher; we explain when to use which later in this guide.
Prerequisites: Versions, Drivers, and Hardware You Need
Before you install Lutris, get the foundation right. The single most common reason games fail to launch is not Lutris itself – it is missing or outdated GPU drivers and an absent Vulkan stack. Lutris leans heavily on Vulkan because DXVK (Direct3D 9/10/11 → Vulkan) and VKD3D-Proton (Direct3D 12 → Vulkan) translate Windows graphics calls into Vulkan at runtime. No working Vulkan, no modern games.
Here are the components and the exact versions current as of June 2026. You do not install most of these by hand – Lutris and GE-Proton bundle them – but knowing the versions helps when you troubleshoot.
| Component | Current version (June 2026) | Role in Lutris |
|---|---|---|
| Lutris | 0.5.22 (stable) | The game manager / front-end |
| GE-Proton | GE-Proton10-34 | Custom Proton build; recommended default runner |
| UMU Launcher | 1.4.0 | Runs GE-Proton outside Steam (umu-run) |
| DXVK | 2.7.1 | Direct3D 9/10/11 → Vulkan translation |
| VKD3D-Proton | 3.0.1 | Direct3D 12 → Vulkan translation |
| Vulkan | 1.3+ recommended | Graphics API every translation layer targets |
| Mesa (AMD/Intel) | 24.x or newer | Open-source GPU driver stack |
| NVIDIA driver | 550+ (555+ preferred) | Proprietary driver with Vulkan support |
On the hardware side, any GPU from the last decade with a working Vulkan driver will run Lutris. Practically, that means a modern AMD card (RDNA or later on Mesa RADV), Intel Arc or integrated Xe, or an NVIDIA GTX 900-series and newer. You want at least 8 GB of RAM (16 GB for AAA titles), an SSD for shader caches and prefixes, and 20–50 GB of free space per large game plus its Wine prefix. A 64-bit distribution is mandatory; 32-bit multilib support must be enabled for many games, which we handle in Step 2.
One important 2026 note: Wine-GE is effectively deprecated. GloriousEggroll’s last dedicated Wine-GE build shipped in early 2024, and development has consolidated into GE-Proton. Lutris adapted by adding the UMU launcher, which lets it run GE-Proton outside of Steam. If older tutorials tell you to download Wine-GE, use GE-Proton instead – that is the path this guide takes.
Step 1 – Install GPU Drivers and Vulkan Support
Start with drivers. AMD and Intel users rely on Mesa, which ships in the kernel and userspace and is usually current on a recently updated distro. You mainly need the 32-bit Vulkan libraries so that 32-bit games can find a driver. NVIDIA users need the proprietary driver (the open kernel modules also work on Turing and newer) version 550 or higher.
Install the Vulkan tools and 32-bit driver bits for your distribution:
# Ubuntu / Debian (enable 32-bit first)
sudo dpkg --add-architecture i386
sudo apt update
sudo apt install vulkan-tools mesa-vulkan-drivers
mesa-vulkan-drivers:i386 libvulkan1 libvulkan1:i386
# Fedora
sudo dnf install vulkan-tools mesa-vulkan-drivers
mesa-vulkan-drivers.i686
# Arch / Manjaro (enable [multilib] in /etc/pacman.conf first)
sudo pacman -S vulkan-tools vulkan-radeon lib32-vulkan-radeon # AMD
# NVIDIA: sudo pacman -S nvidia-utils lib32-nvidia-utils vulkan-icd-loader lib32-vulkan-icd-loaderNow confirm Vulkan actually works. The vulkaninfo command prints the driver and supported API version. If it reports your GPU, you are ready; if it errors out or shows a software “lavapipe” device only, your driver is not installed correctly.
$ vulkaninfo | grep -E "deviceName|apiVersion"
apiVersion = 1.3.295
deviceName = AMD Radeon RX 7800 XT (RADV NAVI32)Seeing your real GPU name and an apiVersion of 1.3 or higher means the Vulkan stack is healthy. NVIDIA users should also verify the kernel module loaded with nvidia-smi. If you just installed a driver, reboot before continuing – a stale module is a classic cause of black screens later.
Step 2 – Install Lutris on Your Distro
You have two install paths: Flatpak (sandboxed, identical everywhere, recommended for most users) or a native package (tighter system integration, slightly less overhead). Flatpak is the path the Lutris team itself recommends for the smoothest experience in 2026, because it bundles a known-good set of dependencies.
To install the Flatpak from Flathub:
# Make sure Flathub is added, then install Lutris
flatpak remote-add --if-not-exists flathub
https://flathub.org/repo/flathub.flatpakrepo
flatpak install flathub net.lutris.Lutris -y
# Launch it
flatpak run net.lutris.LutrisPrefer native packages? Every major distro ships Lutris in its repositories:
# Fedora
sudo dnf install lutris
# Arch / Manjaro
sudo pacman -S lutris
# openSUSE
sudo zypper install lutris
# Ubuntu / Debian
sudo apt install lutrisOne catch unique to Flatpak: the sandbox cannot see files outside your home directory by default. If you keep games on a second drive mounted at, say, /mnt/games, grant Lutris access with an override. This single command prevents the most common “Flatpak Lutris can’t find my drive” complaint:
# Give Flatpak Lutris read/write access to an external games drive
flatpak override --user --filesystem=/mnt/games net.lutris.Lutris
# Optional: let MangoHud work inside the sandbox
flatpak install flathub org.freedesktop.Platform.VulkanLayer.MangoHud -yWhichever route you choose, launch Lutris once so it creates its configuration directory at ~/.config/lutris and its default game directory at ~/Games. The first launch may take a few extra seconds while it initializes. You should land on an empty library with a left sidebar listing “Runners” and “Sources.” That empty window is your starting point for the rest of this guide.
Step 3 – First Launch and Configuring Runners
Open the hamburger menu (top-right) and choose Preferences → Runners. This is the control panel for every engine Lutris can use. The one that matters most for Windows games is Wine. Click “Manage Versions” next to it to see the Wine builds Lutris can download – Lutris ships its own optimized lutris- fork, and you can add others here. Phoronix noted that the 0.5.20 release – already circulating by October 2025, per CachyOS Forum discussions – added a new Wine Wayland driver option right in this panel, alongside a new Azahar emulator runner, so it is worth scrolling the runner list even if you set Lutris up before that update.
Before downloading runners, install the system-level Wine dependencies that the runners expect to find. Lutris’s own documentation maintains a per-distro list; the essentials are the 32- and 64-bit GPU userspace libraries plus a handful of Wine helper packages. On Ubuntu/Debian, for example:
# Core dependencies Wine runners expect (Ubuntu/Debian example)
sudo apt install libgnutls30:i386 libldap-2.5-0:i386
libgpg-error0:i386 libsqlite3-0:i386 libgnutls30
libgl1:i386 libgl1 libfreetype6:i386If you installed Lutris as a Flatpak, you can skip the dependency step entirely – the sandbox bundles everything Wine needs. That is the single biggest convenience argument for the Flatpak build, and it is why we recommend it for newcomers. Native installs are leaner but put the burden of dependency management on you.
While you are in Preferences, open the Global options tab. Enable “Enable Feral GameMode” and, if you installed it, “Enable MangoHud” – we configure both properly in Step 8, but flipping them on now sets sane defaults. Leave Esync and Fsync enabled (they are on by default and almost always help). Your runner foundation is now in place.
Step 4 – Install GE-Proton, DXVK, and VKD3D-Proton
GE-Proton is the secret sauce of modern Linux gaming. It is a community build of Valve’s Proton with extra patches, newer translation layers, and media codecs baked in. Lutris has been able to auto-download GE-Proton since 0.5.18, and 0.5.20 – already available by October 2025, according to CachyOS Forum discussions – laid the groundwork before 0.5.22 went further still by making GloriousEggroll’s Proton builds the default runner out of the box in February 2026, per the project’s GitHub release notes, using the UMU launcher to run it outside of Steam. You can also fetch it manually so it is ready in advance.
To grab the current build (GE-Proton10-34) by hand, download it from the releases page and drop it into Lutris’s runner directory. UMU and Lutris both look in the same place:
# Download and install the latest GE-Proton into the Lutris/UMU runner path
mkdir -p ~/.local/share/lutris/runners/wine
cd /tmp
curl -L -O https://github.com/GloriousEggroll/proton-ge-custom/releases/download/GE-Proton10-34/GE-Proton10-34.tar.gz
tar -xf GE-Proton10-34.tar.gz -C ~/.local/share/lutris/runners/wine/
# Flatpak users point at the sandboxed data dir instead:
# ~/.var/app/net.lutris.Lutris/data/lutris/runners/wine/What about DXVK and VKD3D-Proton? Here is the key fact that trips up newcomers: GE-Proton already bundles them. The current GE-Proton ships recent builds of DXVK (the standalone latest is 2.7.1) and VKD3D-Proton (standalone latest 3.0.1), so you do not install them separately when you use a Proton runner. You only manage DXVK manually when you use a plain Wine runner, where Lutris exposes a DXVK version dropdown in the per-game configuration.
The practical recommendation for 2026: use GE-Proton as your default runner for almost everything, and fall back to a Wine runner with explicit DXVK only when a specific game’s install script calls for it. This keeps your translation layers current automatically every time you update GE-Proton. To check what a given game wants before you install, ProtonDB is invaluable – search the title on protondb.com for community reports and recommended tweaks.
Step 5 – Connect Your Game Sources (Steam, Epic, GOG, and More)
Now populate the library. In the left sidebar under Sources, Lutris lists every storefront it can import from. In 2026 that includes Steam, Epic Games Store, GOG, Battle.net, the EA app, Ubisoft Connect, Humble Bundle, and Amazon Prime Gaming. Phoronix reported that the 0.5.20 release, already out by October 2025 according to CachyOS Forum discussions, introduced a new Steam Family source, and UbuntuHandbook noted that 0.5.22 built on that in February 2026 with fuller Steam Family Sources support plus additional game runners – handy if you share a household Steam library and want those titles importable alongside your own. Each source has its own connection flow – some authenticate through a browser login window, others through their native Windows launcher running inside Wine.
GOG and Epic are the easiest: click the source, log in through the pop-up browser window, and your owned games appear as installable entries. GOG is especially clean because its games are DRM-free, which is one reason many Linux gamers favor it – see our breakdown of Steam vs GOG ownership models. Steam integration simply detects your existing native Steam install and lists those games so you have one unified view.
Battle.net, EA, and Ubisoft are different: they require their Windows launcher, which Lutris installs into a dedicated Wine prefix via a community install script. This is where Lutris shines over rolling your own Wine setup – the script handles the prefix, dependencies, and launcher quirks for you. We walk through the Battle.net case in full as our complete example later.
A workflow tip: you do not have to import everything. Many users keep Steam in the native Steam client, use the Heroic Games Launcher for Epic and GOG because of its cleaner cloud-save handling, and reserve Lutris specifically for Battle.net, EA, and one-off Windows games that need install scripts. Lutris does not force exclusivity – pick the front-end that handles each store best and let Lutris cover the awkward ones.
Step 6 – Install Your First Windows Game with an Install Script
Install scripts are the heart of Lutris. Rather than configure a Wine prefix by hand, you let a community-tested recipe do it. Click the + button (top-left) → Search the Lutris website for installers, type a game’s name, and Lutris queries the online installer database. Each result shows which runner and script version it uses; pick the one with the most recent updates and the highest community confidence.
When you click Install, a wizard walks you through choices: install location, which version of the game (Steam, GOG, retail), and any optional tweaks. The script then creates a fresh Wine prefix, downloads the runner if needed, installs dependencies through a winetricks-style mechanism, and places launch shortcuts. A typical run looks like this in the install log:
Creating Wine prefix in ~/Games/diablo-iv
Using runner: wine (GE-Proton10-34 via umu)
Installing dependencies: vcrun2022, dxvk (bundled), corefonts
Downloading Battle.net setup... Use Scan and Repair before reinstalling a 100GB game, not a 100% game. The text refers to reinstalling a "100GB game," not a percentage, and the claim "100%" is a misinterpretation of the size specification found in the guide.exe in prefix
Install script completed. Launch entry created: "Battle.net".You can also install directly from the command line if you know the installer’s slug. This is handy for scripting a fresh setup or reinstalling after a wipe:
# Install by slug from the Lutris installer database
lutris -i battlenet
# Launch an installed game by its Lutris ID
lutris lutris:rungame/diablo-ivIf an install script is missing or broken, do not panic – you can install almost anything manually as a custom game (Step 9). But for the major launchers, an official or well-maintained script almost always exists. After installation, the game appears in your library with a banner; double-click to launch. The first launch is often slow because DXVK compiles its shader cache; subsequent launches are much faster.
Step 7 – Configure Per-Game Settings: Prefix, DXVK, and Environment Variables
Right-click any game and choose Configure to open its three-tab settings panel: Game options (executable, prefix path, arguments), Runner options (Wine/Proton version, DXVK, Esync/Fsync, DXVK HUD), and System options (environment variables, GameMode, MangoHud, CPU/GPU tweaks). This per-game granularity is what lets you fix one stubborn title without touching everything else.
The Wine prefix is the most important concept here. Each game gets its own isolated “C: drive” – a directory (under ~/Games by default) that holds a virtual Windows filesystem, registry, and installed dependencies. Isolating prefixes per game means a dependency that one title needs cannot break another. If a game misbehaves, deleting and rebuilding its prefix is often the fastest fix and harms nothing else.
Environment variables are how you apply advanced tweaks. In System options → Environment variables, add key/value pairs. The most useful ones for diagnostics and performance:
# Show an on-screen DXVK overlay (fps, draw calls) to confirm Vulkan is active
DXVK_HUD=fps,version,gpuload
# Force a specific GPU on a hybrid (laptop) system - PRIME render offload
DRI_PRIME=1 # AMD/Intel
__NV_PRIME_RENDER_OFFLOAD=1 # NVIDIA
__GLX_VENDOR_LIBRARY_NAME=nvidia
# Cap shader compile stutter by pre-warming the cache
DXVK_STATE_CACHE=1
DXVK_ASYNC=1 # only on builds that support itIf you set DXVK_HUD=fps and launch a game, the frame counter appearing in the corner is your proof that DXVK and Vulkan are doing their job. No overlay usually means the game fell back to slow WineD3D rendering – a sign your runner or driver needs attention. Use this overlay as your first diagnostic whenever performance feels wrong.
Step 8 – Enable GameMode and MangoHud for Performance and Monitoring
Two utilities belong in every serious Lutris setup. Feral GameMode temporarily applies performance-oriented system settings – CPU governor to “performance,” I/O priority, and GPU power profile – while a game runs, then reverts them on exit. MangoHud is a configurable Vulkan/OpenGL overlay that shows FPS, frame times, CPU/GPU load, temperatures, and power draw. Together they let you push performance and verify the results.
Install both at the system level (native installs) or rely on the Flatpak extension from Step 2:
# Native install
sudo apt install gamemode mangohud # Ubuntu/Debian
sudo dnf install gamemode mangohud # Fedora
sudo pacman -S gamemode lib32-gamemode mangohud lib32-mangohud # Arch
# Verify GameMode can activate
gamemoded -tIn Lutris, open a game’s System options and toggle “Enable Feral GameMode” and “Enable MangoHud”. You can also enable them globally in Preferences so every game inherits them. For finer control over the overlay, create ~/.config/MangoHud/MangoHud.conf and list the metrics you want – the project’s documentation covers every option. A sensible starting config:
# ~/.config/MangoHud/MangoHud.conf
fps
frametime=1
cpu_temp
gpu_temp
gpu_load_change
ram
vram
position=top-left
font_size=20GameMode’s impact is largest on laptops and handhelds, where the default CPU governor is conservative; Feral’s own benchmarks show measurable gains in CPU-bound scenes. On a desktop already pinned to a performance governor the difference is smaller, but there is no downside to leaving it on. MangoHud, meanwhile, costs almost nothing and turns “it feels laggy” into “frame times spike to 40 ms during shader compilation” – actionable data.
Step 9 – Add Non-Steam and Custom Games Manually
Not every game has an install script, and sometimes you already have an installer .exe or a DRM-free GOG offline backup. Lutris handles these through a manual entry. Click + → Add locally installed game, then fill in the runner (Wine), the executable path, and a Wine prefix directory. If you point it at a setup executable, Lutris runs it inside the prefix so you can complete a normal Windows installer.
For a DRM-free Windows game, the manual flow is: create the entry with a fresh prefix, run the installer .exe through it, then edit the entry to point the executable at the installed game’s launcher binary. This is the same workflow you would use for indie games from itch.io, retro Windows titles, or anything without a storefront. It is more hands-on than an install script but gives you total control.
You can also import native Linux games and emulators. Lutris supports runners for RetroArch, ScummVM, DOSBox, and dozens of console emulators, so a single library can hold your modern Windows games next to retro consoles. If emulation is your main goal on a handheld, our EmuDeck tutorial covers a more specialized toolchain, but Lutris remains the better choice when you want emulators and PC games in one unified front-end.
Step 10 – Optimize Performance: Esync, Fsync, Shader Cache, and FSR
With games installed, tune for smooth frame delivery. The big three levers in Lutris are synchronization primitives, shader caching, and upscaling. Esync and Fsync reduce CPU overhead from Wine’s thread synchronization; Fsync is faster but needs a kernel with the right support (every mainstream 2026 kernel has it). Both are on by default in GE-Proton – leave them on unless a specific game regresses.
Shader stutter is the most common complaint on first launch. DXVK and VKD3D-Proton compile shaders on demand, and the first time through a level you may see hitches. The fix is the persistent state cache, which saves compiled shaders to disk so later runs are smooth. Make sure it is enabled and pointed at fast storage:
# Enable and locate the DXVK/VKD3D state cache (per-game env vars)
DXVK_STATE_CACHE=1
VKD3D_SHADER_CACHE_PATH=/home/youruser/.cache/vkd3d
DXVK_STATE_CACHE_PATH=/home/youruser/.cache/dxvk
# Confirm the cache files grow after a play session
ls -lh ~/.cache/dxvk/GE-Proton also bundles AMD FSR support, which can upscale a game rendered at a lower internal resolution for a big performance win on weaker GPUs and handhelds. Enable it per game in the runner options, or set the environment variable WINE_FULLSCREEN_FSR=1. On a Steam Deck or similar device this is often the difference between a choppy 35 FPS and a smooth 60 FPS in demanding titles.
Finally, match your expectations to your hardware. A handheld is not a desktop; if you are gaming on one, our Steam Deck vs ROG Ally comparison sets realistic performance baselines. Use MangoHud to find your actual bottleneck – GPU-bound means lower the resolution or enable FSR; CPU-bound means check Esync/Fsync and GameMode before blaming the GPU.
Step 11 – Configure Controllers and Steam Input
Controllers mostly “just work” on Linux thanks to the kernel’s built-in drivers for Xbox and PlayStation pads, but games launched outside Steam do not get Steam Input’s translation layer. That matters because many Windows games only understand XInput (Xbox-style) controllers. A PlayStation DualSense or an older DirectInput pad may not be detected by a game launched from Lutris unless you bridge it.
The cleanest solution is to add your Lutris game as a non-Steam shortcut in Steam and launch it through Steam so it inherits Steam Input, or to run a userspace translator. For most modern Xbox-layout controllers, no extra work is needed – plug in and play. Verify detection before a long session:
# List connected input devices and confirm your pad appears
ls /dev/input/by-id/ | grep -i -E "gamepad|controller|joystick"
# Test buttons and axes interactively (install evtest first)
evtest # then select your controller from the listIf a game ignores your controller, the usual culprits are: the pad is in the wrong mode (some support both XInput and DirectInput via a switch), Steam is running and grabbing the device exclusively, or the game needs its controller config regenerated. Closing Steam, or conversely launching through Steam Input, resolves the large majority of these cases. On handhelds running custom firmware, controller mapping is typically pre-solved by the distro.
Step 12 – Back Up and Maintain Your Lutris Setup
A working Lutris setup represents real time investment – prefixes, configs, and tuned scripts. Back it up. The two directories that matter are your configuration (~/.config/lutris, or the Flatpak equivalent under ~/.var/app/net.lutris.Lutris/) and your games directory (~/Games). Wine prefixes are large but reproducible; configs are small but tedious to rebuild.
# Back up Lutris configuration and per-game settings (native install)
tar -czf lutris-config-backup.tar.gz
~/.config/lutris ~/.local/share/lutris
# Flatpak install paths
tar -czf lutris-flatpak-backup.tar.gz
~/.var/app/net.lutris.Lutris/config
~/.var/app/net.lutris.Lutris/dataFor maintenance, keep GE-Proton current – new builds land roughly monthly and routinely fix newly released games. Update Lutris itself through your package manager or flatpak update; the 0.5.22 release in February 2026 was itself a maintenance-focused update, and the packaging trail shows how actively it is still being patched – Debian Tracker logged 0.5.22-1 landing in the archive by March 2026, and Fedora Packages shipped 0.5.22-4, rebuilt against Python 3.15.0b4, in July 2026, so Lutris keeps running cleanly on distros that track the newest Python builds. When a game that used to work breaks after an update, the first diagnostic is to roll its runner back to the previous GE-Proton version (Lutris keeps multiple installed) rather than reinstalling the game. This pinpoints whether a runner regression or the game itself caused the break.
Periodically prune old GE-Proton builds and orphaned prefixes to reclaim disk space – each prefix can be several gigabytes. Lutris’s “Remove” dialog offers to delete a game’s files including its prefix, which is the safe way to clean up. With backups in place and a monthly update habit, your library stays healthy with minimal effort.
Complete Working Example: Battle.net and a Blizzard Game End-to-End
Let us tie everything together with the canonical Lutris use case: installing Battle.net so you can play a Blizzard title that Steam’s Proton can never touch. This is the scenario that sells most people on Lutris, and it exercises every concept above – install scripts, prefixes, runners, and optimization.
The full walkthrough:
- Verify prerequisites. Run
vulkaninfo | grep deviceNameand confirm your real GPU appears (Step 1). Confirm GE-Proton10-34 is installed (Step 4). - Find the installer. In Lutris, click + → search “Battle.net.” Choose the official installer with recent updates. Click Install.
- Run the wizard. Accept the default install location (
~/Games/battlenet) or pick your games drive. The script creates a prefix, fetches GE-Proton via UMU, and installs dependencies likevcrunand core fonts. - Let it download the launcher. The script downloads the Battle.net setup executable and runs it inside the prefix. Complete the normal Battle.net installer when its window appears.
- Log in. Battle.net launches inside Wine. Sign in with your Blizzard account. Your owned games appear in its library.
- Install the game. Pick a title you own, choose the install location inside the same prefix, and let Battle.net download it.
- Tune it. Right-click the Lutris entry → Configure → enable GameMode and MangoHud (Step 8), add
DXVK_HUD=fpsto confirm Vulkan (Step 7), and enable the state cache (Step 10). - Launch and verify. Start the game from Lutris. The MangoHud overlay confirms FPS and the DXVK HUD confirms Vulkan rendering. First launch compiles shaders; expect smoother runs afterward.
If the launcher opens but the game shows a black screen, that is almost always a shader-cache or runner mismatch – try the previous GE-Proton build and check the title’s page on ProtonDB for game-specific flags. If the launcher itself will not open, the prefix likely needs a dependency the script missed; rerun the installer or add it via the runner’s winetricks integration. With those two fallbacks, the Battle.net workflow is reliable enough that many Linux users run Blizzard games this way daily.
That is the complete project: from a clean Lutris install to a running Windows-only game, using install scripts, an isolated prefix, GE-Proton, and performance tooling. Every other store – EA, Ubisoft Connect – follows the same pattern, just with a different launcher installed into its own prefix.
5 Common Pitfalls and How to Avoid Them
Most Lutris frustration comes from a handful of avoidable mistakes. Internalize these five and you will skip the threads that consume most beginners’ first weekend.
- Skipping the Vulkan and 32-bit driver step. The number-one cause of “game won’t launch” is a missing 32-bit Vulkan library. Many games are 32-bit even in 2026. Always run the Step 1 driver install and confirm with
vulkaninfobefore blaming Lutris. - Using Wine-GE instead of GE-Proton. Old tutorials reference Wine-GE, which stopped receiving dedicated builds in 2024. Use GE-Proton10-34 via UMU. Chasing a deprecated runner wastes hours.
- Forgetting Flatpak filesystem permissions. If you installed the Flatpak and keep games on a second drive, Lutris cannot see it until you run
flatpak override --filesystem=. The symptom is games that “install” but then vanish. - Installing DXVK manually on a Proton runner. GE-Proton bundles DXVK and VKD3D-Proton. Overriding them by hand usually downgrades you and breaks D3D12 games. Only manage DXVK on plain Wine runners.
- Mixing one prefix across many games. Dumping several games into a single shared prefix creates dependency conflicts that are miserable to debug. Give each game its own prefix – that isolation is the whole point.
A bonus sixth: do not run Lutris as root or with sudo. It corrupts file ownership in your home directory and breaks future launches. If you see permission errors after a misguided sudo lutris, fix ownership with sudo chown -R $USER:$USER ~/.config/lutris ~/Games.
Troubleshooting Lutris: 8 Common Errors and Fixes
When something breaks, work the table below top to bottom. Most issues map to one of these eight patterns, and the fix is usually faster than a reinstall. Always check the title’s ProtonDB page first for game-specific flags.
| Symptom | Likely cause | Fix |
|---|---|---|
| Game won’t launch, no window | Missing Vulkan / 32-bit driver | Install 32-bit Vulkan libs (Step 1); verify with vulkaninfo |
| Black screen after launcher | Shader cache or runner mismatch | Switch to previous GE-Proton build; enable DXVK_STATE_CACHE |
| “No Vulkan support” error | Software (lavapipe) fallback only | Install proper GPU driver; reboot to load the module |
| Stutter on first playthrough | On-demand shader compilation | Enable persistent state cache; let shaders pre-compile |
| Flatpak can’t find game drive | Sandbox filesystem permission | flatpak override --filesystem=/path net.lutris.Lutris |
| Controller not detected | No Steam Input outside Steam | Add as non-Steam shortcut, or use XInput mode |
| D3D12 game crashes on start | Outdated VKD3D-Proton | Update GE-Proton (bundles VKD3D-Proton 3.0.1) |
| Permission denied errors | Ran Lutris with sudo earlier | chown -R $USER:$USER ~/.config/lutris ~/Games |
When the table is not enough, run Lutris from a terminal (lutris -d for debug output) and read the log as you launch the failing game. The error that scrolls by right at the crash is your real clue. Copy that line into the title’s ProtonDB comments or the Lutris Discord search – odds are someone hit the same wall and posted the fix. Debug-mode logs turn vague “it doesn’t work” reports into specific, solvable problems.
Advanced Tips for Power Users
Once the basics are solid, a few advanced techniques separate a functional setup from a great one. Custom Wine builds: beyond GE-Proton, you can drop any Wine build into the runners directory – Kron4ek’s vanilla builds, TKG custom builds, or a self-compiled Wine with specific patches. Lutris detects them automatically in the version dropdown, which is invaluable for games that need a niche patch.
Gamescope: Valve’s micro-compositor (the technology behind Steam Deck’s Gaming Mode) can wrap any Lutris game to handle resolution scaling, frame limiting, and HDR cleanly. Add it as a command prefix in System options: gamescope -W 1920 -H 1080 -f --. It is especially useful for games that handle alt-tab or multi-monitor setups badly, forcing them into a well-behaved nested window.
Per-game scripting: Lutris lets you run pre-launch and post-exit scripts. Use a pre-launch script to set CPU affinity, mount a RAM disk for shader caches, or kill a conflicting process; use a post-exit script to clean up. Library organization: tag games into categories (installed, favorites, by store) so a large multi-source library stays navigable. And for streaming a Lutris game to another device, pair it with our Moonlight game streaming setup – Lutris games stream exactly like any other application once running.
Finally, learn the command-line interface. lutris -l lists installed games with their IDs, lutris lutris:rungame/<id> launches one, and lutris -i <slug> installs from the database. These commands let you build desktop shortcuts, bind games to hotkeys, or script an entire library restore after a fresh OS install – turning Lutris into infrastructure rather than just an app.
Lutris vs Heroic vs Bottles: Which Should You Use?
Lutris is not the only Wine front-end on Linux. The two most common companions – or alternatives – are Heroic Games Launcher and Bottles. They overlap but each has a clear strength, and many users run two of them together rather than picking one.
| Feature | Lutris | Heroic | Bottles |
|---|---|---|---|
| Primary focus | Universal game manager | Epic / GOG / Amazon launcher | Wine prefix manager |
| Store integrations | 8 (Steam, Epic, GOG, Battle.net, EA, Ubisoft, Humble, Amazon) | 3 (Epic, GOG, Amazon) | None (manual) |
| Install scripts | Yes (community DB) | No | No (programs/dependencies) |
| Default runner | Wine + GE-Proton (UMU) | Wine / Proton | Wine / Soda / Caffe |
| Best for | Multi-store libraries, Battle.net/EA | Clean Epic/GOG with cloud saves | Running arbitrary Windows apps |
| Emulator support | Yes (many runners) | No | No |
The practical verdict: use Lutris as your universal manager and the only reliable way to run Battle.net, EA, and Ubisoft titles on Linux. Add Heroic if your main libraries are Epic and GOG, because its dedicated UI and cloud-save handling are cleaner for those two stores – our Heroic setup guide walks through it. Reach for Bottles when your goal is running a non-game Windows application (Adobe tools, a Windows-only utility) in a tidy, isolated bottle. They are complementary, not mutually exclusive.
Frequently Asked Questions
Is Lutris free?
Yes. Lutris is completely free and open-source software, released under the GPL, with no paid tier, ads, or account requirement to use the manager itself. Development is funded through community donations and memberships. You still need to own the games you install – Lutris is a manager, not a source of pirated content, and its install scripts download from legitimate stores using your own credentials.
Does Lutris work on Steam Deck?
Yes. Lutris runs well on Steam Deck and other SteamOS-based handhelds, where it is the standard tool for installing non-Steam games like Battle.net titles. Install the Flatpak from Discover in Desktop Mode, then add your Lutris games to Steam as non-Steam shortcuts so they appear in Gaming Mode. Performance is solid because the Deck’s hardware is the same target GE-Proton optimizes for. Enable FSR (Step 10) for demanding titles.
What is the difference between Lutris and Steam’s Proton?
Steam’s Proton runs only your Steam games, automatically and invisibly inside the Steam client. Lutris extends that same Wine/Proton technology to everything else – Battle.net, EA, GOG, Epic, and standalone Windows games – and adds install scripts, per-game configuration, and emulator support. They are not competitors; most Linux gamers use Steam’s Proton for Steam games and Lutris for everything outside Steam.
Should I install Lutris via Flatpak or my package manager?
For most users in 2026, Flatpak. It bundles a known-good dependency set, updates independently of your distro, and avoids the 32-bit library hunt that trips up native installs. The only tradeoffs are sandbox filesystem permissions (one flatpak override command for external drives) and a sliver of overhead. Choose the native package if you want maximum integration, are comfortable managing Wine dependencies, or run a minimal/immutable setup where you prefer one model.
Why won’t my game launch even though the install succeeded?
The most common reasons, in order: missing 32-bit Vulkan drivers (run Step 1), a runner mismatch (try the previous GE-Proton build), or a missing dependency the script skipped. Launch Lutris with lutris -d from a terminal to see the exact error at crash time, then search that error plus your game on ProtonDB. Nine times out of ten the fix is a driver package or a single environment variable, not a reinstall.
Can Lutris run anti-cheat games?
Some, not all. Games using BattlEye or Easy Anti-Cheat work only if the developer has explicitly enabled Linux/Proton support – many titles have, but several major competitive ones still block it at the kernel level, where Linux support is impossible by design. Always check the game’s current status on ProtonDB or an anti-cheat compatibility tracker before buying. This is a developer decision, not a Lutris limitation.
How often should I update GE-Proton?
Check monthly. GloriousEggroll releases new GE-Proton builds roughly every few weeks, and they frequently add fixes for newly launched games. Keep at least the previous build installed too, because occasionally a new release regresses a game that worked before – Lutris lets you pin any installed version per game, so you can update freely while keeping a known-good fallback for your favorites.
Does Lutris support NVIDIA graphics cards?
Yes, fully. Install the proprietary NVIDIA driver version 550 or newer (555+ preferred for Proton), which includes the Vulkan support DXVK and VKD3D-Proton require. The open kernel modules work on Turing (RTX 20-series) and newer. After installing, reboot and confirm with nvidia-smi and vulkaninfo. On hybrid laptops, use the PRIME render-offload environment variables from Step 7 to force games onto the discrete GPU.
With Lutris 0.5.22 (released 24–25 February 2026), GE-Proton10-34, and a healthy Vulkan stack, Linux gaming in 2026 is no longer a compromise – it is a genuinely better front-end for a multi-store library than anything on Windows, backed by a project that had climbed to 10,101 GitHub stars with commits still landing as of July 2026, and packaged widely enough that Fedora 45 shipped 0.5.22-5 in September 2026, per Fedora Packages. Follow the twelve steps above, keep your runners current, and the Battle.net-on-Linux dream that used to take a weekend now takes a coffee break. The era of “it doesn’t run on Linux” is, for the overwhelming majority of single-player games, over.
