1. Introduction – What Lutris is and why you should use it.
2. Prerequisites – GPU drivers and Vulkan support (NVIDIA vs AMD/Intel).
3. Installation – Methods for Mint/Ubuntu, Fedora, Arch, Flatpak.
4. First Steps – Interface, preferences, runners.
5. Installing Windows Games and Applications
   • 5.1 With scripts from the Lutris library
   • 5.2 Manual installation with .exe
   • 5.3 Configuring the final executable
6. Advanced Configurations – Runner options, DXVK, VKD3D, Esync/Fsync, Lutris runtime.
7. Store and Launcher Integration – Steam, GOG, Epic, Ubisoft, Battle.net.
8. Optimization and Performance – MangoHUD, Gamescope, FSR, environment variables.
9. Peripherals and Controllers – Gamepads, wheels, HOTAS, specific setups.
10. Backup and Maintenance – Prefixes, migration, cleaning.
11. Troubleshooting – Common errors, logs, debug checklist.
12. Practical Examples – Installing an app and a launcher.
13. FAQ – Frequently asked questions.
14. Conclusions – Final tips and useful resources.

1. INTRODUCTION – What Lutris is and why you should use it

If you use Linux, you’ve probably noticed that the world of gaming and Windows applications isn’t always straightforward. Some programs and games don’t have native versions, and that’s where Lutris comes in — an open-source software that acts as a central platform to manage games and applications.

👉 In short, Lutris is a universal library: it brings together native Linux titles, Windows software through Wine, emulators, and launchers like Steam, GOG, and Epic Games Store. Its main goal is to remove technical complexity, allowing anyone to install and launch a game or app with just a few clicks, without having to manually configure Wine and its dependencies.

Why you should use it

• Simplified management: instead of fiddling with dozens of commands, just select the right script and Lutris configures everything for you.
• Compatibility: supports a wide range of games, from modern ones with DirectX 11/12 to old classics.
• Centralization: all your Linux, Windows, and store-bought games are in one single place.
• Customization: each game/app has its own isolated “prefix,” avoiding conflicts and allowing dedicated optimizations.

Who benefits from Lutris

• Anyone who wants to play on Linux without worrying about manual Wine configuration.
• Anyone who bought games on different stores and wants to find them in a single interface.
• Linux users who need to run Windows applications for work or study that don’t have a native alternative.

2. PREREQUISITES – GPU Drivers and Vulkan Support (NVIDIA vs AMD/Intel)

Before installing and using Lutris, it’s essential to make sure your Linux system is ready to handle Windows games and applications. The key requirement is having the right graphics drivers and Vulkan support — the library that translates DirectX into instructions your GPU can understand.

Why they matter

• Without updated drivers, games may fail to launch or perform very poorly.
• Vulkan is the foundation of DXVK and VKD3D, two crucial components that translate DirectX APIs (used on Windows) into Vulkan, enabling modern games to run on Linux.
• A wrong configuration here means issues later on, as every following step depends on this setup.

Differences between NVIDIA and AMD/Intel

NVIDIA

• Requires proprietary drivers to achieve maximum performance.
• On Linux Mint and Ubuntu, this is straightforward: just open the Driver Manager, which detects your card and suggests the recommended driver.
• After installation, it’s also a good idea to add the package vulkan-tools to verify that everything is working properly.

AMD/Intel

• Drivers are already included in Mesa, the open-source graphics stack that is actively maintained.
• In this case, you just need to keep the system updated (sudo apt update && sudo apt upgrade on Mint/Ubuntu).
• Installing the packages mesa-vulkan-drivers and vulkan-tools ensures full compatibility.

How to check if Vulkan is active

After installing the right packages, you can verify with:

vulkaninfo | head -n 20

If you see output with information about your GPU and Vulkan versions, you’re good to go.

Another useful command is:

glxinfo -B

(requires mesa-utils). This will show whether rendering is active and confirm that you’re using the correct drivers.

Practical tip

If you have both an NVIDIA and an AMD GPU in the same PC (hybrid setups, common in laptops), it’s usually best to let the system handle the dedicated GPU with the proprietary NVIDIA driver, while using Mesa for the integrated Intel/AMD part. In many cases, Mint/Ubuntu already manage this well.

🔗 Want to learn more about choosing the right distro for your hardware and usage? Check out this article: 8 lightweight Linux distros to revive your old PC.

3. INSTALLATION – Methods for Mint/Ubuntu, Fedora, Arch, Flatpak

In this section, we’ll install Lutris on the most commonly used distros, using alternative methods (Flatpak and system packages). At the end, you’ll also find the commands to verify, update, and remove the installation.

Which method to choose

• Flatpak (recommended): installation from Flathub, regular updates, isolated environment.
  • Pro: usually the most up-to-date version, fewer dependency conflicts.
  • Con: data paths are under ~/.var/... instead of the standard folders.
• System package (repo/PPA): native integration with your distro.
  • Pro: standard paths, integration with your package manager.
  • Con: sometimes not the very latest release.

Linux Mint / Ubuntu

Option A – Flatpak (recommended)

(Mint usually comes with Flatpak pre-installed. On Ubuntu, install it if missing)

sudo apt update && sudo apt install -y flatpak
flatpak remote-add --if-not-exists flathub https://flathub.org/repo/flathub.flatpakrepo

Install and launch Lutris

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

Option B – Native package (official PPA)

sudo add-apt-repository -y ppa:lutris-team/lutris
sudo apt update
sudo apt install -y lutris

Quick check

which lutris || flatpak info net.lutris.Lutris

If you see the executable path or Flatpak package info, the installation was successful.

Fedora

Option A – System package

sudo dnf install -y lutris

Option B – Flatpak

(Fedora already has Flatpak enabled, just add Flathub if missing)

flatpak remote-add --if-not-exists flathub https://flathub.org/repo/flathub.flatpakrepo
flatpak install -y flathub net.lutris.Lutris

Quick check

lutris --version || flatpak info net.lutris.Lutris

Arch / Manjaro

Option A – System package

sudo pacman -Syu --noconfirm lutris

Option B – Flatpak

flatpak remote-add --if-not-exists flathub https://flathub.org/repo/flathub.flatpakrepo
flatpak install -y flathub net.lutris.Lutris

Quick check

lutris --version || flatpak info net.lutris.Lutris

Where files and folders are stored

• Flatpak: configs and cache are under ~/.var/app/net.lutris.Lutris/.
• Native package: configs in ~/.config/lutris/, data in ~/.local/share/lutris/.
  (Games/prefixes will be covered in the next chapter.)

Updating

• Flatpak: flatpak update
• Mint/Ubuntu: sudo apt update && sudo apt upgrade
• Fedora: sudo dnf upgrade --refresh
• Arch/Manjaro: sudo pacman -Syu

Uninstalling

• Flatpak: flatpak uninstall net.lutris.Lutris
• Mint/Ubuntu: sudo apt remove lutris && sudo apt autoremove # optional cleanup
• Fedora: sudo dnf remove lutris
• Arch/Manjaro: sudo pacman -R lutris

⚠️ User folders (~/.config/lutris/, ~/.local/share/lutris/ or ~/.var/app/net.lutris.Lutris/) remain on disk to preserve your data. Remove them manually only if you want a full cleanup.

4. FIRST STEPS – Interface, Preferences, Runners

In this section, we’ll get familiar with the app: where to click, what to configure, and which components to install to run Windows games and applications with minimal effort.

4.1 Interface: what you see and what it does

Top bar

• + (Add): opens the menu to insert new games/apps. From here you can:
  • install via official Lutris scripts,
  • launch a Windows .exe installer,
  • import already configured games or ROMs,
  • manually add a locally installed title.
• Search / Filter: quickly find titles in your library.
• Refresh: reloads the view, useful after adding games or modifying runners.
• Three dots (options menu): access to Preferences, general settings, and other features.
• Window controls: minimize, maximize, close.

Left column (sidebar)

• Library: shows all installed or linked titles.
• Categories / Platforms: quick filters to distinguish Linux-native titles, Wine, emulators, etc.
• Sources: integrations with stores/launchers such as Steam, GOG, Epic Games Store, Ubisoft Connect, EA App.
• Runners: section that groups available engines (Wine, Linux, Steam, Flatpak). Managed via Tools → Manage Runners.

Central area (grid/list)

• Each tile represents a title. Right-click to access Configure, Launch, View Logs, Browse Files.
• Double-click to directly launch a game/app.
• You can choose between list view or grid view, assign custom tags, and use Favorites to keep your most-used titles handy.

Other useful elements

• Import/Export: from the menu, you can export a title as an archive (useful for backup or migration) and import existing configurations.
• Covers/Icons: right-click → Download media or manually upload an image to visually organize your library.

4.2 Preferences: global settings to configure right away

To access them, open the menu ⋮ (three dots in the top-right corner) and select Preferences. Here you’ll find all the main sections.

Preferences – Main sections

1. Interface

• Minimize Lutris to tray when launching a game.
• Hide text under icons.
• Enable/disable dark theme.
• Enable Discord integration (Rich Presence).

2. Runners

• Manage available engines: Wine, Proton-GE, various emulators.
• Install or update new versions.

3. Sources

• Enable the libraries you want to appear in Lutris: Steam, GOG, Epic Games Store, Ubisoft Connect, EA App, etc.
• Changes require restarting the client to take effect.

4. Accounts

• Link your Steam account (or other supported accounts).
• Once connected, your games will appear in the Lutris library.

5. Hardware Information

• Shows a summary of your system: CPU, RAM, GPU, drivers, Vulkan version, etc.
• Useful for troubleshooting and when sharing details while asking for support.

6. Global Options

• Default installation folder: choose a convenient path (e.g. ~/Games).
• Lutris Runtime: keep it enabled for basic compatibility; you can disable it globally or only for specific titles.
• Prefer system libraries: helpful in case of conflicts.
• Gamescope: if enabled, allows forcing resolutions and frame pacing.
• GameMode: optimizes system resources when you run a game.
• MangoHUD: displays an overlay with FPS and system stats.

Flatpak note

If you’re using the Flatpak version, keep installations under your HOME directory (e.g. ~/Games).
If installing on an external drive, remember to set the proper permissions using Flatseal.

4.3 Runners: installing and managing the “engines”

Runners are the engines Lutris uses to run your titles. For Windows software you’ll mainly use Wine or optimized variants (Wine-GE / Proton-GE).

• Open the menu ⋮ (three dots in the top-right corner) → Preferences → Runners.
• Find Wine in the list and click the download icon to install the recommended version(s).
  (A stable release + a recent GE build is usually a good combo).
• (Optional) Also install Proton-GE if available, as it can help with modern games.
• Once installed, you can choose which version to use for each title under Runner Options.

Best practices

• Pin the version: if a specific version works perfectly for a game, don’t update it immediately for that title.
• Keep 2–3 versions installed (e.g. stable Wine, recent Wine-GE, one older release): switching between them is often the quickest fix.
• Update runners periodically: many compatibility improvements arrive through runner updates.

4.4 Configure Panel (per-game): quick overview

Right-click on a title → Configure. You’ll find several tabs:

Game Information

• Name / Sort name: the name displayed in your library.
• Runner: the engine used (e.g., Steam, Wine, etc.).
• Release year / Identifier: informational fields.
• Folder: file location; you can move it if needed.

Game Options

• Application ID: for Steam titles, this is filled in automatically.
• Arguments: additional parameters to pass to the game (e.g., -novid to skip intros).
• DRM-free mode: launches the binary without opening Steam (works only if the game supports it).
• Game executable path: for non-Steam games, specify the correct .exe or executable here.

Runner Options

• Launch Steam in Big Picture mode: useful for TV/console-like setups.
• Launch Steam with LSI: alternative Steam integration mode.
• Arguments: parameters to pass to the runner itself (not to the game).
• Custom runner executable: lets you use an external Wine/Steam runner instead of the one managed by Lutris.

System Options

• Default installation folder: usually ~/Games.
• Disable Lutris Runtime: if a game has issues with built-in libraries, force it to use system libraries instead.
• Prefer system libraries: same purpose, improves compatibility with your distro.
• Gamescope: wrapper to improve scaling and frame pacing; here you can adjust resolution, window/fullscreen mode, FSR, and FPS limits.
• Display / CPU: extra options like MangoHUD, GameMode, number of CPU cores to use, etc. (visible if you enable Advanced Options).

Pro tip

Enable Show advanced options (top-right) to unlock all entries. In this panel, you can solve most issues: switch runners, enable DXVK/VKD3D, add environment variables, or force specific configurations for each game.

4.5 Note for hybrid laptops (NVIDIA/AMD + integrated GPU)

• On many NVIDIA-based distros: set Command prefix to prime-run.
• Generic alternative (AMD/Intel or PRIME): env DRI_PRIME=1 before the command.
• (Flatpak) If the game is on an external drive, remember to set permissions with Flatseal.

👉 In Lutris the field is called Command prefix (not “Prefix command”).

4.6 First test run

1. In the Lutris home screen, click + → Add locally installed game (test only).
   • Name: Test
   • Runner: Wine
2. Open Configure → Runner options and check that the dropdown Wine version shows installed versions.
3. In Game options, check the main fields (Executable/Game binary path, Working directory, Prefix).
4. Remove the entry when done (right-click → Remove).

4.7 Where data is stored

• Installations and prefixes (default): in the folder set under Global options → Default installation folder (recommended ~/Games/Lutris).
• Lutris configs: ~/.config/lutris/
• Lutris data (cache, runtime, state): ~/.local/share/lutris/
• Flatpak: same contents under ~/.var/app/net.lutris.Lutris/
  (e.g. config in ~/.var/app/net.lutris.Lutris/config/lutris/).

4.8 Final checklist

• Did you choose a default folder for installations/prefixes?
• Did you link the stores you need (if relevant)?
• Did you install at least one version of Wine (stable) and one GE build?
• Can you see the list of Wine versions in the game panel (even for a test game)?

5. INSTALLING Windows Games and Applications

In this section, we’ll cover two methods for adding titles (games/apps) in Lutris and how to point to the correct executable after installation.
Golden rule: always start with the installation scripts. Switch to manual install only if the script doesn’t exist or fails for your specific case.

5.1 Using Lutris Library Scripts (recommended)

These are preconfigured profiles created by the community. They automatically select the runner, options (DXVK/VKD3D, Esync/Fsync), dependencies, and file paths.

Steps

• Open the official site Lutris.net and search for your game/app.
• Click Install on the game page: the Lutris client will open and guide you through the setup.
• Confirm the proposed runner (often Wine-GE) and the suggested components.
• Choose the installation folder. If the script involves a launcher (Epic, Battle.net, Ubisoft), log in when prompted.
• Once completed, the game will appear in your library. Right-click → Configure to check the executable, prefix, and options.

Advantages

• Quick and repeatable setup.
• Often better compatibility for popular titles.
• Scripts are maintained and updated by the community.

Tips

• If something doesn’t launch: try another Wine version in Runner Options or toggle DXVK/VKD3D.
• Some scripts install the launcher first, and then the games inside it (normal sequence).

5.2 Manual Installation with .exe (when no script is available)

A universal method for .exe installers or portable apps.

Steps

• In Lutris, click + → Add Game.
• Game name: choose a clear name; Runner = Wine.
• Game options:
  • Executable → point to your Setup.exe (or a portable .exe if no installer is provided).
  • Wine prefix → create a dedicated prefix (e.g. ~/Games/GameName).
  • Architecture → keep 64-bit; use 32-bit only for very old software.
• Runner options:
  • Wine version → start with a recent Wine-GE or stable build.
  • DXVK (DX9/10/11) / VKD3D (DX12) → enable only what’s required.
  • Esync/Fsync → enable for better performance; disable if you notice instability.
• System options (if needed): set environment variables (e.g. MANGOHUD=1, DXVK_HUD=1) or use the gamescope wrapper for scaling and frame pacing.
• Save & Launch → the installer will run; complete it as you would on Windows.

After installation

• The program will be placed in the prefix: drive_c/Program Files/...
• You’ll need to remap the final executable (see section 5.3) — don’t leave it on Setup.exe.

Tips

• Use one prefix per game to avoid conflicts.
• If Microsoft components are required (VC runtimes, .NET), open Winetricks from the Runner Options tab and install only what’s needed (vcrun2019, dotnet48, corefonts, etc.).

5.3 Configuring the Final Executable (post-setup)

This is the step many people forget: shortcuts often still point to the setup file instead of the actual program.

Steps

• Right-click the game → Configure → Game Options.
• In Executable, browse the prefix until you reach the real .exe. Example: ~/Games/GameName/drive_c/Program Files/AppName/AppName.exe
• (Optional) Working directory → set it to the executable’s folder if not detected automatically.
• Save and launch.

Quick checks & fixes

• If it doesn’t launch: View Logs and search for keywords (dxvk, vulkan, vcrun, xinput).
• Try another Wine version and toggle DXVK/VKD3D, Esync/Fsync.
• Disable Lutris Runtime just for that title if you suspect conflicts.

🔗 Recommended read: https://incastro.altervista.org/en/no-more-dual-boot-run-windows-apps-on-linux-with-winboat/

6. ADVANCED CONFIGURATIONS – Runner options, DXVK, VKD3D, Esync/Fsync, Lutris runtime

This section covers the advanced options in Lutris, often crucial for stability and performance.
⚠️ The available entries depend on the chosen runner (Wine/Wine-GE/Proton-GE or Steam).

6.1 The Runner Options panel – overview

When you open Configure → Runner Options, you may find two different scenarios:

Runner = Wine / Wine-GE / Proton-GE (non-Steam)

• Wine version: select the version (stable, GE, Proton-GE).
• Enable DXVK / VKD3D: translates DirectX APIs into Vulkan (DX9–11 with DXVK, DX12 with VKD3D).
• Esync / Fsync: optimizations to reduce latency.
• Enable Lutris Runtime: extra libraries for compatibility.
• Other toggles: WineD3D, Surface Flinger, Virtual Monitor, etc.

Runner = Steam (Linux)

• Available options:
  • Launch Steam in Big Picture mode
  • Launch Steam with LSI
  • Arguments (launch options)
  • Custom executable for the runner
    ⚠️ Here you don’t manage DXVK/VKD3D or Proton from Lutris: they are configured from Steam → Game Properties → Compatibility.

6.2 DXVK and VKD3D (Wine runner only)

• DXVK: converts DirectX 9/10/11 to Vulkan, required for most modern games.
• VKD3D: converts DirectX 12 to Vulkan.
• If a DX11 game doesn’t work with VKD3D, enable DXVK. If it’s DX12, enable VKD3D.
• In some cases, disabling DXVK or using more recent versions fixes crashes or graphic glitches.

6.3 Esync and Fsync (Wine runner only)

• Esync (Eventfd Synchronization): improves thread handling in Wine, reduces latency.
• Fsync (Futex Synchronization): newer version, requires a compatible Linux kernel; offers better performance.
  👉 Rule of thumb: use Fsync if available, otherwise Esync. Disable them only if you notice instability.

6.4 Lutris Runtime

The Lutris Runtime is a package of libraries (DLLs, graphics, compatibility) provided to unify the experience across different distros.

• Advantage: reduces differences between Ubuntu/Mint, Fedora, Arch.
• Disadvantage: in rare cases, it may conflict with system libraries.
  👉 If a game gives strange errors, try disabling it only for that title (System options → Disable Lutris Runtime).

6.5 Other useful settings

• WineD3D: fallback when Vulkan doesn’t work (poor performance, use only as a last resort).
• Command prefix / wrapper: to launch external utilities (e.g. gamescope, prime-run).
• Environment variables: useful examples:
  • DXVK_HUD=1 → show DXVK overlay
  • __GL_THREADED_OPTIMIZATIONS=1 → NVIDIA optimization
  • MANGOHUD=1 → performance overlay
• Surface Flinger / Virtual Monitor: useful in case of display or multi-monitor issues.

6.6 Recommended Testing Procedure

1. Start with a base configuration: Wine-GE, DXVK/VKD3D ON, Esync.
2. If it crashes or has glitches, switch Wine version (from GE to stable or vice versa).
3. Toggle DXVK / VKD3D ON/OFF.
4. Disable Lutris Runtime if you suspect conflicts.
5. On hybrid laptops, use prime-run or DRI_PRIME=1 in the Command prefix.
6. Always check View Logs for diagnosis (search for “vulkan”, “dxvk”, “err”, “warn”).

7. INTEGRATION with Stores and Launchers – Steam, GOG, Epic, Ubisoft, Battle.net

One of Lutris’ strengths is that it’s not limited to standalone .exe games: it can also manage full launchers and connect to your digital stores. This way, your entire library is in one place with the same configuration options.

7.1 Where to Enable Integrations

Open Preferences → Sources:

• Steam – shows your Steam games directly in Lutris, with the option to force different runners than Proton.
• GOG – syncs your purchased library via GOG Galaxy (through API).
• Epic Games Store – access via direct login; games are managed through the official Epic script.
• Ubisoft Connect – installed as a Windows launcher via script.
• Battle.net – also through scripts; after login you can install WoW, Diablo, etc.

⚠️ Note: many launchers require Wine-GE and DXVK enabled to work correctly.

7.2 Steam + Lutris

• If you already have native Linux Steam, you can link it to Lutris: native games will launch normally.
• For Windows games on Steam, you can choose whether to use Steam Proton or force them to launch via Lutris/Wine-GE.
• Advantage: more control over prefixes and Wine versions, especially for titles that don’t run properly with standard Proton.

7.3 GOG

• GOG Galaxy does not natively exist on Linux, but Lutris allows integration.
• Just link your GOG account in the preferences and your library will be visible.
• Games are then installed through dedicated Lutris scripts (very well maintained by the community).

7.4 Epic Games Store

• Installable with a dedicated script from lutris.net (“Epic Games Store”).
• After installation, it appears as a launcher in Lutris.
• Log in with your account and download games as you would on Windows.
• Note: sometimes the Epic Launcher requires runtime fixes or specific Wine-GE versions.

7.5 Ubisoft Connect

• There is no official Linux support, but Lutris provides scripts.
• Once installed, the launcher manages downloads, updates, and launching Ubisoft titles.
• Tip: create a dedicated prefix just for this launcher.

7.6 Battle.net

• The official Lutris script installs Battle.net with Wine-GE.
• Log in → install your Blizzard games (World of Warcraft, Diablo, Overwatch).
• Often you’ll need to enable DXVK and test different Wine-GE versions for stability.

7.7 Best practices for launchers

• Separate prefix for each launcher → lower risk of conflicts.
• After installing the launcher, go into Configure → Game Options and check that the Executable points to the correct file (Battle.net.exe, UbisoftConnect.exe, etc.).
• Use View Logs if a launcher does not start: errors often indicate missing libraries (vcrun, dotnet).
• Keep in mind that some launcher updates may break compatibility: in that case, check the Lutris forums for updated fixes.

🔗 Recommended reading:https://incastro.altervista.org/en/how-to-install-applications-on-linux-mint/

8. OPTIMIZATIONS AND PERFORMANCE – MangoHUD, Gamescope, FSR, environment variables

This section collects tools and tips to measure, optimize, and stabilize the performance of games/apps on Lutris. The goal is to have a simple method to understand what’s happening and apply targeted improvements.

8.1 MangoHUD: measure FPS, frametime and resources

What it is: a lightweight overlay that shows FPS, frametime, CPU/GPU/RAM usage, temperature, etc.

Quick installation

• Mint/Ubuntu:

sudo apt install mangohud

• Fedora:

sudo dnf install mangohud

• Arch/Manjaro:

sudo pacman -S mangohud

Enabling in Lutris

In Configure → System Options → Environment variables add:

MANGOHUD=1

Start the game: the overlay will appear.

Optional config

File:

~/.config/MangoHud/MangoHud.conf

(create it if it doesn’t exist).
Minimal example:

fps
full
frametime
gpu_temp
cpu_temp
gpu_mem
cpu_load

To hide/show the overlay: Shift+F12 (default; customizable in the config).

8.2 Gamescope: frame pacing, scaling, “controlled” window

What it is: a micro-compositor designed for gaming. It allows you to run a game in a “controlled” window and apply scaling, FPS limits, tear-free fullscreen, and excellent frame pacing.

Installation

• Mint/Ubuntu: available from PPA/Flatpak or some derivative repos; alternatively, use the package provided by your distro.
• Fedora: sudo dnf install gamescope
• Arch/Manjaro: sudo pacman -S gamescope

Usage with Lutris (Command prefix)

In Configure → System Options → Command prefix enter for example:

gamescope -f -w 1280 -h 720 -W 1920 -H 1080 --adaptive-sync --

• -w / -h: internal game resolution
• -W / -H: external resolution (output)
• -f: fullscreen
• --adaptive-sync: adaptive sync (if supported)

When to use it

• If you want to downscale a demanding game to 720p internally and upscale it to 1080p externally, while keeping the UI sharp.
• If you experience stuttering: gamescope often improves frame pacing.

8.3 FSR (upscaling) in practice

• If the game has native FSR/DLSS/XeSS, use the in-game option: it’s the best way.
• Otherwise, upscaling via Gamescope is a good alternative (lower internal resolution and upscale externally).
• For DX9/10/11/12 titles under Wine, the best balance is usually found by trying:
  1. Lower internal resolution,
  2. Scaling with gamescope,
  3. Optional in-game sharpening (if available).

💡 Some recent versions of Wine-GE/Proton-GE support integrated FSR: you can enable it by adding in System Options → Environment variables:

WINE_FULLSCREEN_FSR=1
WINE_FULLSCREEN_FSR_MODE=ultra

• FSR=1 → enables upscaling.
• MODE=ultra → best quality (you can also try quality, balanced, performance).

👉 Not all titles react the same way: try different combinations and measure the results.

8.4 Useful Environment Variables (per-game)

Add them in Configure → System Options → Environment variables of the single title.

• MANGOHUD=1 → enables MangoHUD overlay.
• DXVK_HUD=1 → shows the DXVK HUD (API and status). Useful to check if DXVK is being used.
• __GL_THREADED_OPTIMIZATIONS=1 → on NVIDIA can improve CPU-bound performance in some titles.
• vblank_mode=0 → in some cases disables VSync in drivers (fallback; use with caution).
• mesa_glthread=true → for OpenGL on Mesa drivers, may boost performance on weak CPUs.

⚠️ Set them per-game, not globally: this way you avoid side effects on other titles.

8.5 Recommended Testing Method (10 minutes)

1. Baseline: start with MangoHUD enabled and record FPS/frametime at native resolution.
2. Scaling: try Gamescope with reduced internal resolution (e.g., 900p → 1080p).
3. Sync: toggle VSync/Adaptive-Sync; check for tearing/stuttering.
4. CPU-bound: if FPS don’t change when lowering resolution, try
   __GL_THREADED_OPTIMIZATIONS=1 (NVIDIA) or mesa_glthread=true (OpenGL Mesa).
5. One change at a time: after each tweak, measure again with MangoHUD.

8.6 Notes on Wayland vs X11

• Most games via Lutris run fine under XWayland (Wayland).
• If you notice issues (input lag, tearing, screen capture problems), try an X11 session or use Gamescope.

9. PERIPHERALS & CONTROLLERS – Gamepads, Wheels, HOTAS, Special Configurations

This section helps you connect and configure controllers (Xbox, PlayStation, 8BitDo…), wheels, and HOTAS in Lutris, with practical tips to avoid the most common issues.

9.1 Gamepad: What Linux Supports Best

• XInput (recommended): the “modern” standard (Xbox controller). It’s what Windows games expect. With Wine/Lutris, it usually works “plug-and-play.”
• DirectInput: older standard. Some newer titles don’t recognize it properly; if you have issues, try XInput mode (almost all modern controllers support it).
• SDL (gamecontroller): abstraction layer used by many games/launchers on Linux, useful for consistent mappings.

💡 Quick tip: if your pad supports multiple modes (e.g., 8BitDo: XInput, DInput, Switch), choose XInput for maximum compatibility.

9.2 Xbox / 8BitDo / XInput-Compatible

• USB: usually recognized right away.
• Bluetooth: pair it from the system panel, then reconnect it before launching the game. On 8BitDo, check the switch or button combo for XInput mode.
• In Lutris: right-click your game → Configure → System Options, and enable Gamepad if available.

9.3 DualShock 4 / DualSense (PS4/PS5)

• On many distros they’re handled by kernel drivers (hid-sony / hid-playstation).
• For maximum compatibility in Windows games, use XInput mapping via Steam Input (if you use Steam) or try Bluetooth + SDL mode.
• If a game doesn’t “see” the pad: enable Gamepad in System Options and try different in-game profiles (PS vs Xbox layout).

9.4 Wheels (Logitech, Thrustmaster…) & HOTAS

• Many wheels expose more axes/buttons via evdev/SDL. Some have dedicated tools on Linux (e.g., oversteer for Logitech).
• For HOTAS (e.g., Thrustmaster, VKB, Virpil): often mapped in-game. If the Windows title expects XInput, consider external mappers or compatibility profiles.
• In Lutris, if the game doesn’t detect input:
  • Try an X11 session (some titles have issues on Wayland),
  • Disable conflicting overlays (apps that “grab” input),
  • Check udev permissions (devices must be user-accessible).

9.5 Steam Input with Lutris: When It’s Worth It

• If you launch a Steam game through Lutris, you can leverage Steam Input to remap pads not natively supported by XInput.
• Advantages: ready profiles, per-game remapping, support for gyro, back paddles, custom deadzones.
• Disadvantages: it adds another layer. If you notice lag or conflicts, try without Steam Input.

9.6 Bluetooth: Stable Pairing & Low Latency

• Keep BlueZ (Bluetooth stack) updated and prefer modern controllers with XInput mode.
• Avoid cheap dongles: a poor Bluetooth adapter can introduce lag and disconnects.
• On laptops, disable aggressive power saving for the BT adapter if you notice random “drops.”

9.7 Useful Variables & Technical Tips

• In System Options → Environment variables you can add:
  • SDL_GAMECONTROLLER_IGNORE_DEVICES= / SDL_GAMECONTROLLERCONFIG= for advanced mappings,
  • SDL_JOYSTICK_HIDAPI=1 to force HIDAPI on some pads.
• Some old Windows games look for xinput1_3.dll: modern Wine versions provide it. Avoid old stubs like x360ce unless absolutely necessary.

9.8 Quick Troubleshooting

• Game doesn’t detect the pad: enable Gamepad in Lutris; try USB instead of BT; switch mode (XInput ↔ DInput).
• Wrong layout (A/B swapped): check in-game settings or Steam Input profiles; in Lutris you can force XInput.
• Vibration/gyro not working: not all titles expose them via Wine; try Steam Input or alternative profiles.
• Wheel/HOTAS not recognized: try X11, reduce connected USB devices, check udev permissions, and test without overlays.

🔗 Managing Wi-Fi/Bluetooth cards on Linux (useful for stable controller pairing): https://incastro.altervista.org/en/linux-wifi-bluetooth-cards-vs-usb-adapters/

10. BACKUP AND MAINTENANCE – Prefixes, migration, cleanup

This section gives you a simple and safe method to back up your games/apps installed with Lutris, move them to another PC, and perform periodic cleaning without breaking anything.

10.1 What you need to save (quick map)

• Lutris config: ~/.config/lutris/
• Lutris data (cache, runtime, states): ~/.local/share/lutris/
• Prefixes and installs: the folder chosen in Preferences → Default install location (e.g. ~/Games/Lutris/).
• Flatpak: same contents but under ~/.var/app/net.lutris.Lutris/ (e.g. ~/.var/app/net.lutris.Lutris/config/lutris/).

💡 Tip: keep one prefix per title (e.g. ~/Games/Lutris/<Title>): backups become modular and migrations much easier.

10.2 Quick backup (for a single game/app)

1. Close Lutris (important: avoid files in use).
2. Compress the entire prefix folder of the title: tar -czf GameTitle-prefix.tgz -C ~/Games/Lutris GameTitle
3. (Optional) Also save a Lutris export: right-click the title → Export → generates a .tar.gz file with metadata and scripts.

Restore

• Extract the folder in the same location (or an equivalent one) and in Lutris check under Configure → Game Options that both Executable and Wine prefix paths point to the restored folder.

10.3 Full backup (entire library)

1. Close Lutris.
2. Copy the three key areas with rsync (preserves permissions and links): rsync -a --info=progress2 ~/.config/lutris/ /backup/path/lutris-config/ rsync -a --info=progress2 ~/.local/share/lutris/ /backup/path/lutris-share/ rsync -a --info=progress2 ~/Games/Lutris/ /backup/path/lutris-games/ Flatpak: replace paths with ~/.var/app/net.lutris.Lutris/...

💡 Tip: use an external drive formatted in ext4 to avoid issues with permissions/symlinks. If you must use NTFS/exFAT, see the note at the end of the chapter.

10.4 Migration to a new PC

1. Install Lutris and drivers/Vulkan on the new PC (see chapters 2–3).
2. Copy the three areas (config, share, games/prefixes) into the equivalent locations.
3. Start Lutris: titles should appear automatically. If not:
   • Use Import/drag-and-drop of the exported archive (see part 10.2).
   • Or open Configure on a title and reset Executable and Wine prefix if paths changed.
4. Runner versions: if a game required a specific Wine-GE, reinstall it under Tools → Manage Runners and select it in the game’s Runner Options.

10.5 Periodic cleanup (safe)

• Unused prefixes: delete folders of removed games. If unsure, start Lutris to check what’s missing.
• Cache & logs: in ~/.local/share/lutris/ you can clear caches that grew too large (if in doubt, move temporarily and test).
• Old runners: in Manage Runners remove versions you don’t use, but keep at least the “stable” one (useful for version pinning).
• Shader cache: sometimes it’s worth regenerating (delete a game’s DXVK cache to fix glitches after driver updates).
• External drives: check integrity (smartctl, fsck) and run periodic checks (sha256) on your backup archives.

Example checksum generation:

sha256sum GameTitle-prefix.tgz > GameTitle-prefix.tgz.sha256

10.6 File system and permissions: what to consider

• ext4/btrfs/xfs: recommended for prefixes (full permissions/attributes).
• NTFS/exFAT: fine for transporting backups; avoid running games directly from here (permissions and symlinks can cause issues).
• Flatpak: if you want to install games on an external drive, grant the app permissions (e.g., with Flatseal) for the chosen location.

10.7 Safety checklist before backup

• Lutris closed (and no game running).
• Enough free space.
• Verify paths in Preferences → Default install location.
• Keep note of the Wine version you use (screenshot or list), so you can reinstall them identically on the new PC.
• After restoring, open 1–2 test games and check logs with View Logs.

11. TROUBLESHOOTING – Common errors, logs, debug checklist

This section gives you a quick and practical path to identify problems and solve them without getting lost.
The idea is: reproduce, observe, change one thing at a time, measure.

11.1 Where to look at logs (and what to search)

• In Lutris: right-click the title → View Logs.
• If you need more verbosity: launch Lutris from terminal (lutris -d) or run the executable with custom logs.
• Useful keywords to search for:
  • vulkan, dxvk, d3d12, d3d11, wined3d → graphics/API issues.
  • err: / fixme: / warn: → Wine messages: check last 50 lines.
  • vcrun, dotnet, msxml, xact → missing Microsoft dependencies (use targeted Winetricks).
  • xinput, gamepad, hid → peripherals not detected or wrong mapping.

11.2 Debug checklist (in order of probability)

1. Wine version
   • Try another Wine version (stable ↔ GE, newer ↔ older). Often this is the fix.
2. DXVK / VKD3D
   • DX9/10/11 → DXVK ON.
   • DX12 → VKD3D ON.
   • If you see black screen/glitches, try turning OFF or update the packages.
3. Esync / Fsync
   • Keep them ON for performance; if you notice crashes or micro-freezes, try disabling.
4. Lutris Runtime
   • If you suspect library conflicts, disable it per title.
5. Clean prefix
   • Create a new prefix and reinstall only what you need (avoid leftover bloat from old attempts).
6. Driver/Vulkan
   • Confirm with vulkaninfo that Vulkan responds; update drivers:
     • NVIDIA via Driver Manager
     • Mesa for AMD/Intel.
7. Wayland vs X11
   • If using Wayland, try an X11 session or use gamescope as wrapper.
8. Permissions/peripherals
   • For strange HOTAS/joystick behavior, check udev, try USB instead of BT, remove conflicting overlays.

11.3 Common errors and fixes

• Black screen at startup
  • Check DXVK/VKD3D; update drivers; try another Wine version.
  • Make sure the Executable points to the correct .exe (not the setup.exe).
• Crash after logo
  • Missing Microsoft runtimes: open Winetricks and install vcrun20xx, dotnet48, corefonts (only what the title requires).
  • Temporarily disable overlays/external monitoring.
• Input not recognized (pad/wheel)
  • Enable Gamepad in System Options; change mode (XInput ↔ DInput); try without Steam Input.
• No audio or crackling
  • Change audio driver in Winecfg (e.g. PulseAudio/ALSA), check sampling rate.
  • Disable auto-surround if the game sets it automatically and the system doesn’t support it.
• Sudden poor performance
  • Clear the game’s DXVK shader cache; check that you’re using the dedicated GPU (hybrid laptops: prime-run).
  • Check thermals/throttling, try __GL_THREADED_OPTIMIZATIONS=1 (NVIDIA) or mesa_glthread=true (OpenGL Mesa).

11.4 Winetricks: when and how to use it

• Open Configure → Runner Options → Winetricks.
• Install only what you need (e.g. vcrun2019, dotnet48, msxml6, xact, corefonts).
• After installation, restart the title and check logs. Avoid random packages: more ≠ better compatibility.

11.5 Method to stay sane

• Change one thing at a time, note the result (even in a text file).
• If something works, pin it (lock the Wine version).
• If nothing works: create a new prefix + fresh Lutris script; restart from scratch.

11.6 Useful tools

• MangoHUD: observe FPS/frametime, compare before/after.
• Gamescope: stabilize frame pacing, scaling, clean fullscreen.
• Protontricks/Winetricks: targeted dependencies.
• System Monitor: check RAM/CPU/IO during drops.

11.7 When to ask for help (and what to provide)

• Lutris version (Flatpak or native) and Wine version used.
• Distro + GPU driver (NVIDIA/AMD/Intel) and vulkaninfo output (first lines).
• Lutris logs (last 100 lines with the error).
• What you’ve already tried (DXVK ON/OFF, different Wine versions, new prefix, …).

📌 Extra tip
👉https://incastro.altervista.org/en/how-to-close-a-frozen-program-on-linux-without-rebooting-your-pc/

12. PRACTICAL EXAMPLES – Installing an app and a launcher

In this chapter we’ll do two concrete examples:
A) install a Windows app not present in the Lutris library,
B) install a launcher (Epic Games Store) via script.

Note: the examples apply to Linux Mint/Ubuntu, Fedora and Arch/Manjaro. Lutris windows may vary slightly depending on the version, but the concepts remain the same.

12.1 Example A – Windows app not listed (e.g. IrfanView / Notepad++)

Goal: add a “classic” Windows app that comes with a .exe installer.

Steps

1. Download the installer from the official site (e.g. iviewXXX_setup.exe or npp.X.Y.Installer.exe).
2. Open Lutris → + → Add Game.
3. Game info:
   • Name: “IrfanView” (or the app name).
   • Runner: Wine.
4. Game Options:
   • Executable: select your Setup.exe.
   • Wine prefix: create a dedicated prefix, e.g. ~/Games/Lutris/IrfanView.
   • Architecture: keep 64-bit (if the app is only 32-bit, choose 32-bit).
5. Runner Options:
   • Wine version: start with a recent Wine-GE.
   • DXVK/VKD3D: OFF (usually not needed for 2D apps).
   • Esync/Fsync: ON (doesn’t hurt; OFF if glitches appear).
6. System Options (optional):
   • MANGOHUD=0 (useless for 2D apps),
   • add prime-run if you are on a hybrid NVIDIA laptop.
7. Save → Launch: the app setup starts. Complete installation as on Windows.
8. Remap the executable (fundamental): right click on the title → Configure → Game Options → Executable → point to the real installed .exe, e.g.: ~/Games/Lutris/IrfanView/drive_c/Program Files/IrfanView/i_view64.exe
9. Test: launch the app; check saving paths and file associations. If needed, open Winetricks and install specific packages (e.g. corefonts, vcrun20xx).

Quick troubleshooting

• White window or unreadable characters → try corefonts in Winetricks.
• Crash at startup → try another Wine version (stable/GE) and/or a new clean prefix.

12.2 Example B – Launcher: Epic Games Store with Lutris script

Goal: install the Epic launcher and then your games from there.

Steps

1. Go to lutris.net and search for “Epic Games Store”.
2. Click Install: the Lutris client will open with the guided procedure.
3. Confirm runner and suggested options (usually Wine-GE + DXVK).
4. Choose the installation folder (recommended: a dedicated prefix, e.g. ~/Games/Lutris/EpicLauncher).
5. After installation, launch Epic Games Launcher from the Lutris library and log in with your account.
6. Install Epic games just like on Windows (choose folders inside the prefix, or external paths if allowed).
7. (Optional) For heavy games, set in System Options → Command prefix with gamescope to improve frame pacing and scaling.

Useful notes

• Epic updates: sometimes break compatibility; in that case try another Wine-GE, disable Lutris Runtime for that title or check the logs.
• Cloud saves: depends on the game; some sync, others don’t. Consider manual backups of the prefix.

Quick troubleshooting

• Launcher won’t start → check logs (keywords: dxvk, vulkan, cef); try DXVK ON/OFF and another Wine-GE.
• Login keeps closing → update runner, relaunch with a new prefix; check system date/time (token/OAuth).
• Slow downloads → disable VPN/overlay, check DNS.

12.3 Tips

• Use one prefix per launcher (Epic, Ubisoft, Battle.net): reduces conflicts and simplifies backups.
• If a game works from the launcher but you want a dedicated icon: duplicate the entry in Lutris and point directly to the game’s .exe inside the prefix.
• For 2D programs (Office-like, light graphic tools) DXVK is not needed: fewer layers = fewer problems.

13. FAQ – Frequently Asked Questions

This section collects the most common questions that often pop up in forums and groups, with concise and practical answers.

13.1 Does Lutris replace Wine?

No. Lutris is a manager: it organizes versions of Wine (and variants such as Wine-GE/Proton-GE), applies scripts, and saves you from manual configuration. Wine remains the “engine”.

13.2 Is it better to use Lutris or Steam’s Proton?

• If the game is on Steam → try Proton first (more integrated and updated).
• If the game is non-Steam, from GOG/Epic/Ubisoft or an app → Lutris is the right choice.
• In some cases you can use both: install the launcher via Lutris, but run the game with Proton.

13.3 How many prefixes should I have?

Better one per game/app. This way:

• You avoid DLL/runtime conflicts.
• Backups become modular.
• If one title breaks, it won’t ruin the others.

13.4 What’s the difference between Stable Wine and Wine-GE?

• Stable Wine: maximum reliability, slower updates.
• Wine-GE (GloriousEggroll): fork with fresh patches, useful for modern games.
• Keeping 2–3 versions installed is the most practical approach.

13.5 Do I need 32-bit?

Yes, but modern distros already handle it with multilib packages. You need them for 32-bit games/apps.
In the prerequisites guide (Chapter 2) you’ll find the required packages for each distro.

13.6 Does it work with non-gaming apps?

Yes. You can install Office suites, graphics tools, utilities. Not always perfect, but many work fine.
Remember: DXVK/VKD3D are only needed for 3D/DirectX graphics.

13.7 Can I use NTFS/exFAT drives for games?

Better not: they’re fine for backup/transport, but not for direct execution (permissions and symlink issues). Use ext4/btrfs on the game drive.

13.8 Why doesn’t my game start anymore after an update?

• The launcher version changed (e.g., Epic).
• You need a new Wine-GE.
• The DXVK cache is corrupted (try deleting it).
• In extreme cases: create a new prefix and reinstall.

13.9 Should I always enable Esync/Fsync?

In general, yes: they improve performance by reducing overhead.
But if you notice instability, try them OFF.

13.10 Is it better to use Flatpak or the native package?

• Flatpak: more up-to-date, isolated, fewer conflicts.
• Native: full integration with the distro, cleaner paths.
  Choose based on your priorities; functionality is the same.

13.11 I have a laptop with hybrid GPU, how do I force the dedicated one?

• NVIDIA: in System Options → Command prefix add prime-run.
• AMD/Intel: use env DRI_PRIME=1.
  Or launch the game with gamescope and PRIME options.

13.12 Is there an alternative to Lutris?

• Bottles: more focused on apps, modern GUI.
• Heroic Games Launcher: great for Epic/GOG.
• Many users run multiple tools in parallel.

14. CONCLUSIONS – Final tips and useful resources

You’ve seen how Lutris allows you to bring together in one place native Linux games, Windows titles through Wine, and launchers like Steam/GOG/Epic.
The key to success is a mix of order (separate prefixes), method (one change at a time), and tools (DXVK/VKD3D, Esync/Fsync, MangoHUD, gamescope).
Below you’ll find a practical recap and some extra advice.

14.1 Recap in 8 steps

1. Drivers & Vulkan first of all (see Ch. 2).
2. Install Lutris as you prefer (Flatpak or native package) and choose clean folders (Ch. 3).
3. Set up runners: keep 2–3 Wine versions (stable + GE) and “pin” the one that works (Ch. 4–6).
4. Prefer scripts: faster and already tested (Ch. 5.1).
5. Manual only when needed: always remember to remap the final executable (Ch. 5.2–5.3).
6. Integrate launchers with dedicated prefixes (Steam/GOG/Epic/Ubisoft/Battle.net) (Ch. 7).
7. Optimize with MangoHUD + gamescope and a few targeted environment variables (Ch. 8).
8. Backup & maintenance: rsync of the three key paths, checksums, and orderly migrations (Ch. 10).

14.2 Practical “field” tips

• Don’t update everything at once if you have a game running perfectly: note the Wine version and keep it for that title.
• One prefix per game/launcher: avoid “all-in-one,” it reduces conflicts and clutter.
• Keep notes of changes: a simple notes.txt inside the prefix with the Wine version used, DXVK/VKD3D toggles, and applied fixes can save you hours.
• Wayland? Great, but if you notice strange input issues or tearing, try X11 or use gamescope.
• Community: when asking for help, attach logs (last 100 lines), Wine version, distro & drivers: you’ll get faster and more accurate answers.

14.3 What to read/keep handy

• lutris.net pages of your favorite titles (updated scripts).
• ProtonDB to get an idea of the state of Windows games on Linux (also useful if you use Lutris).
• This guide: save it as a PDF and update your notes with the fixes you discover along the way.

Disclaimer

This guide is the result of research, practical tests, and a collection of information available online.
It is not official documentation of Lutris, Wine, or any of the other applications mentioned.

Some procedures, paths, or options may change over time due to software updates or differences between Linux distributions.

The author assumes no responsibility for possible malfunctions, data loss, or other issues arising from the use of the information provided.
Use the instructions at your own risk and, if possible, always perform a backup before making important changes.