UMU: The Ultimate Tool for Unifying Your Games on Linux

  • UMU replicates the Steam runtime to run Proton outside of Steam with the same guarantees.
  • umu-run unifies variables and fixes by applying protonfixes according to GAMEID and STORE from a common database.
  • Flexible installation: classic build, uv, and nixpkgs packages with advanced options.
PablinuxUpdated on

10 minutes

UMU Launcher

UMU Launcher It has become one of those tools that, without making much noise, changes the way you play on Linux. Far from being a typical graphical launcher, its mission is Unify how Windows games run with Proton outside of Steam, so that any client or script can take advantage of the same environment that Valve uses without depending on Steam itself.

To understand it quickly: UMU copy the Steam Runtime container model (the same one used by Proton and Steam Linux Runtime) with some tweaks, so that Proton works identically just like you would within Steam, but from any compatible launcher like Lutris, Heroic or Bottles, and even from a simple terminal command. And yes, you don't need to have Steam installed to use it.

What is UMU Launcher and where does its name come from?

UMU is, in essence, an adaptation of the Steam Linux Runtime "sniper" and the Steam Runtime Tools, with its own entry point and utilities for third parties to integrate it. The name "umu" is not accidental: it refers to a Polynesian volcanic stone oven heated, on which whatever you put on top is "cooked." The metaphor fits with Valve's container tool called "pressure-vessel": UMU would be that "stove" on which the pressure vessel is placed to prepare the environment where Proton "cooks" your games.

When Steam starts a game with Proton, it launches a chain of processes where it normally appears steam-launch-wrapper (a mere runner which forwards environment variables) and, crucially, the SteamLinuxRuntime_sniper with its _v2-entry-point that assembles the container and loads Proton. UMU replicates that logic: the script _v2-entry-point it is renamed to umu, it adds umu-run to replace steam-launch-wrapper and the necessary details are adjusted to Use Proton outside of Steam maintaining the environment expectations that Proton needs (environment variables included).

How it works: environment variables, container, and umu-run

The key is in start the game inside the same type of container that Steam uses, with the correct variables for Proton. UMU allows you to invoke umu-run indicating the game executable, the arguments and, optionally, the WINEPREFIX, the Proton version and the store from which the game comes to apply specific fixes.

Main parameters and variables of umu-run What should be known:

  • WINE PREFIX: WINE prefix path. If you do not specify it, UMU creates it by default in $HOME/Games/umu/GAMEID. If you do not define GAMEID, the default prefix will be $HOME/Games/umu/umu-default.
  • GAMEID: can be an arbitrary value or a valid ID in the umu-database. If you don't define it, is used umu-default (without automatic fixes).
  • PROTONPATH: full path to the Proton version you want to use. Also supports the value GE-Proton all with automatically download the latest build from GE-Proton. If you do not indicate it, UMU-Proton (a stable build from Valve with UMU support) is the default option.
  • Shop: the game's store or "storefront" (for example, eg, gog, etc.). UMU combines STORE + GAMEID to search for specific fixes in its database.
  • PROTON_VERB: Proton verb to use. If you don't set it, use "waitforexitandrun".
  • UMU_LOG: Enables UMU debug logs. Useful for diagnose problems.
  • UMU_ZENITY: if active, display pop-ups with Zenity when downloading large files.
  • UMU_RUNTIME_UPDATE y UMU_NO_PROTON: additional options for runtime management or scenarios where you don’t want UMU to manage Proton.

Furthermore, UMU automatically downloads and uses the necessary Steam Runtime for the chosen Proton version, and place its files in $HOME/.local/share/umu. With that, the runtime container is ready and The game runs as if it were native to Steam, just outside of Steam.

Advantages: Why this unification matters

UMU's approach makes it easier for all pitchers speak the same "language" when running games with Proton. This offers several clear advantages for users and developers:

  • No Steam requirements: You no longer need the Steam client or binaries to use Proton.
  • Unified fixes base- Game-specific fixes (protonfixes) are shared across the community and across different launchers.
  • Parity with Steam: Games start with Proton inside the same type of container that Steam uses, replicating its environment.
  • Centralized maintenance: if something changes, it is updated in Proton GE and/or protonfixes or in a unified Proton build, positively affecting everyone.

Today protonfixes packages a local folder of «gamefixes», but the project itself suggests that could evolve to online download so that any tool you use umu-run get the fixes you need centrally.

ProtonFixes and the UMU Database: How Fixes Are Applied

UMU proposes a simple flow so that a launcher identifies the game, its store and the fix that corresponds, and automatically applies it before running it with Proton. The process, as described, consists of these steps:

  1. Create a database with game titles, their IDs in different stores and the umu-ID correlated.
  2. The pitcher searches the base for the game data and retrieves the umu-ID, which happens to umu-run together with STORE, Proton, WINEPREFIX, executable and arguments.
  3. When starting the game with umu-run, protonfixes detects STORE + umu-ID, finds the appropriate fix script and applies it before execution.
  4. protonfixes organizes scripts into folders per store. The same game maintains the same umu-ID across multiple stores; it may have store-specific scripts or link to an existing fix if you share needs.

An example they give is Borderlands 3 on the Epic Games Store (EGS). EGS uses «codenames» like "Catnip". The launcher detects that the store is eg and the codename is catnip, consults the database, associates it with "Borderlands 3" and the umu-ID corresponding (for example, umu-12345), and that ID is passed to umu-run. This is how the correct fixes are guaranteed even when the store does not use the game's brand name.

References for use: options and examples

UMU includes standard documentation man page all with umu-run, with forms of use such as umu-run , umu-run ] o umu-run winetricks , plus --config <FILE> y --helpAmong their examples they propose practical cases on the table:

  • Run a game In a direct way.
  • Run a game with a specific protonfix.
  • Using a configuration file to parameterize the execution.
  • Create a WINEPREFIX UMU and launch it with Proton.
  • Select Proton automatically (and create the prefix if necessary).
  • Define a valid Proton verb explicitly.
  • Enable debug logs to diagnose faults.
  • Force a specific Proton version by name.
  • Use the latest build of GE-Proton automatically.
  • Execute winetricks verbs from umu-run.
  • Disable the protonfixes application if you need it.

As related utilities, the reference documentation Winetricks, zenithHe himself umu(5) and documentation of the container runtime from Steam. It also links to repos of Proton, umu-protonfixes and umu-database, for anyone who wants to go deeper or contribute.

Building and installing: from make to nixpkgs

For those who prefer to compile or package, UMU documents that the build requires bash, make, scdoc and tools Python (build, hatchling, installer, pip). In addition, they ask for cargo with minimum MSRV equal to the latest stable version of its direct dependencies.

The recommended flow is: download the code, enter the directory, execute configure.sh --prefix to set the installation prefix (for example /usr/local o /app if you are going to package in Flatpak), run make and if all goes well you will have the artifacts in ./builddir. Then you can run make install to install.

For user installation, UMU places the executable in $HOME/.local/bin. Be sure to add that directory to your PATH (for example, exporting it in $HOME/.bash_profile) if you want to invoke it without a full path.

Alternatively, they propose using uv to create a virtual environment and quickly configure UMUThe guide suggests generate a script in the project directory, create the virtualenv with uv, install the dependencies and run the script via uv.

En NixOS/nixpkgs, UMU is available as pkgs.umu-launcher since 25.05 (unstable branch at the indicated time). They also detail how to use flakes if you need a more recent snapshot than the channel's, and they even provide Examples for NixOS and Home-Manager. If you work with older channels (such as nixos-24.11), suggest combining multiple channels or pull your flake.

Packaging parameters that you can override in nixpkgs:

  • extraPkgs: add extra packages to the FHS environment (default) pkgs: []).
  • extraLibraries: add extra libraries to the FHS environment (by default) pkgs: []).
  • withMultiArch: Include 32-bit libraries in the FHS environment (by default) true).

If you use flake, you can configure optional dependencies such as:

  • withTruststore: enables the use of the system trust store (default true).
  • withDeltaUpdates: activate dependencies for Proton's "delta updates" (default true).

They also show ways to apply the overlay via specialArgs or directly into flake.nix, plus an example of overriding package arguments.

Steam Runtime, Logs, and Debugging

UMU relies on the Container-based Steam Runtime (the same one they use native Linux games y Proton 8.0+). To diagnose problems in that environment, the runtime itself supports useful environment variables when launched with the Steam client, which also serve as a reference when working with the container:

  • STEAM_LINUX_RUNTIME_LOG=1: enables logs that appear in SteamLinuxRuntime_sniper/var/slr-*.log (with the AppID in the name). slr-latest.log is a symlink to the last generated.
  • STEAM_LINUX_RUNTIME_VERBOSE=1: more verbosity in the output (to files if there is LOG=1 or to the same place as the output of steam but).
  • PRESSURE_VESSEL_SHELL=instead: instead of starting the game, opens an interactive shell inside the container for inspection.

Valve documents assumptions about supported distributions, debugging tips, and maintains release notes and known runtime issues. If you develop games and are interested in target that environment, check out its SDK and technical information for developers. The entire runtime integrates third party software with its open licenses and the source code is available in versioned directories (see VERSIONS.txt to see the correspondences).

Recent updates and hotfixes

In a recent change, the maintainers released a HOTFIX that reverts changes to the reaper because They broke UMU within GameScope sessions in FlatpakThe list indicates:

  • Reversion of "umu_run: complete the implementation of reaper in umu".
  • Reversion of "umu_run: run steammode workaround on the main process".
  • Reversion of "umu_run: use hardcoded display values ​​for now".
  • Updated release notes (bump release notes).

This type of hotfix shows that the project reacts quickly to regressions in specific environments such as Flatpak + gamescope, something key for users of Steam deck or desktops that use that stack.

Project status: first official version and real objective

The version has been highlighted 1.1.1 , the first official release of the Unified Linux Wine Game Launcher by Thomas "GloriousEggroll" Crider and the Open Wine Components community. They emphasize that It is not a graphical launcher like Steam/Heroic/Lutris, but one common layer that those launchers can use to run Proton games outside of Steam with the same fidelity that within Steam.

They indicate that should work within Flatpak and Snap, and provide packaging instructions for both formats in its repository. The goal is that any app can launch titles from stores like Epic, GOG or Amazon with the same quality that on Steam, benefiting from protonfixes and the unified database for ever better compatibility.

Links and recommended documentation

To go deeper, the documentation links to resources such as Steam Runtime Sniper release notes, known issues from the runtime and how to report bugs, in addition to the document on container-runtime. It is also worth checking:

The project is maintained by Open Wine Components with the help of more contributors. If you want to collaborate, they recommend installing ruff from your distribution and enable ruff server in your editor to maintain a consistent style in your code.

UMU positions itself as technical glue between Proton and the launchers, with a standardized runtime and shared fixes base; this allows the community to move forward faster and with less friction, and users gain stability and simplicity by running their games outside of Steam with the same quality.