NixOS Wiki

Steam: Difference between revisions

← Older edit
VisualWikitext
imported>Fitzgibbon
Updated 32-bit OpenGL package requirements for latest steam build (2019-11-15).
Added workaround for missing game icons under GNOME
 
(97 intermediate revisions by 54 users not shown)
Line 1: Line 1:
This page is intended to explain how to run Steam, Steam games as well as proprietary DRM-free games under NixOS.
<languages/>
<translate>
<!--T:1-->
[https://store.steampowered.com/ Steam] is a digital distribution platform for video games, offering a vast library for purchase, download, and management. On NixOS, Steam is generally easy to install and use, often working "out-of-the-box". It supports running many Windows games on Linux through its compatibility layer, Proton.<ref>https://store.steampowered.com/</ref>
</translate>


== Prerequisites ==
<translate>
If you are using 64-bit system and plan to also run 32-bit code (some games are 32-bit only) - add <syntaxhighlight lang="nix" inline>hardware.opengl.driSupport32Bit = true</syntaxhighlight> and <syntaxhighlight lang="nix" inline>hardware.pulseaudio.support32Bit = true</syntaxhighlight> (in case you are using pulseaudio) to your configuration.
== Installation == <!--T:2-->
</translate>


Example snippet of <code>configuration.nix</code>:
<translate>
<syntaxHighlight lang=nix>
==== Shell ==== <!--T:3-->
  ...
</translate>
  hardware.opengl.driSupport32Bit = true;
  hardware.opengl.extraPackages32 = with pkgs.pkgsi686Linux; [ libva ];
  hardware.pulseaudio.support32Bit = true;
  ...
</syntaxHighlight>


== Installation ==
<translate>
Several installation options exist.  
<!--T:4-->
To temporarily use Steam-related tools like <code>steam-run</code> (for FHS environments) or <code>steamcmd</code> (for server management or tools like steam-tui setup) in a shell environment, you can run:
</translate>
<syntaxhighlight lang="bash">
nix-shell -p steam-run # For FHS environment
nix-shell -p steamcmd  # For steamcmd
</syntaxhighlight>
<translate>
<!--T:5-->
This provides the tools in your current shell without adding them to your system configuration. For <code>steamcmd</code> to work correctly for some tasks (like initializing for steam-tui), you might need to run it once to generate necessary files, as shown in the `steam-tui` section.
</translate>


=== Pure steam client ===
<translate>
If you need Steam client, install it with<syntaxhighlight lang="nix" inline>steam</syntaxhighlight> package.
==== System setup ==== <!--T:6-->
Example snippet of <code>configuration.nix</code>:
</translate>
<syntaxHighlight lang=nix>
  environment.systemPackages = with pkgs; [
  ...
  steam
  ];
  ...
</syntaxHighlight>


=== Native steam client ===
<translate>
If you want Steam client to use NixOS libraries instead of Steam-provided, you need to set an override. Note, that this may be broken.
<!--T:7-->
Example snippet of <code>configuration.nix</code>:
To install the [[Steam]] package and enable all the system options necessary to allow it to run, add the following to your <code>/etc/nixos/configuration.nix</code>:
<syntaxHighlight lang=nix>
</translate>
   environment.systemPackages = with pkgs; [
<syntaxhighlight lang="nix">
   ...
# Example for /etc/nixos/configuration.nix
   (steam.override { nativeOnly = true; })
programs.steam = {
];
   enable = true;
  ...
   remotePlay.openFirewall = true; # Open ports in the firewall for Steam Remote Play
</syntaxHighlight>
   dedicatedServer.openFirewall = true; # Open ports in the firewall for Source Dedicated Server
};


=== FHS environment only (aka GOG/Humble) ===
# Optional: If you encounter amdgpu issues with newer kernels (e.g., 6.10+ reported issues),
This will only make partial installation - provide the script, which creates the typical environment expected by proprietary games and software on regular Linux, allowing to run such software without patching. Useful if you plan to run GOG or HumbleBundle games.
# you might consider using the LTS kernel or a known stable version.
# boot.kernelPackages = pkgs.linuxPackages_lts; # Example for LTS
</syntaxhighlight>
<translate>
<!--T:8-->
[https://news.ycombinator.com/item?id=41549030 Anecdata on kernel 6.10 issues]
</translate>


First option is to install either<syntaxhighlight lang="nix" inline>steam-run</syntaxhighlight> or <syntaxhighlight lang="nix" inline>steam-run-native</syntaxhighlight>. The native version may work better for DRM-free standalone games.
{{note|Enabling [[steam]] installs several unfree packages. If you are using <code>allowUnfreePredicate</code> you will need to ensure that your configurations permit all of them.
<syntaxhighlight lang="nix">
{
  nixpkgs.config.allowUnfreePredicate = pkg: builtins.elem (lib.getName pkg) [
    "steam"
    "steam-unwrapped"
  ];
}
</syntaxhighlight>
}}


Example snippet of <code>configuration.nix</code>:
<translate>
<syntaxHighlight lang=nix>
== Configuration == <!--T:9-->
  ...
</translate>
  environment.systemPackages = with pkgs; [
  ...
  steam-run-native
  ];
  ...
</syntaxHighlight>


Other option, in case you need more flexibility, is to directly reference to the part of steam metapackage instead. In fact, <code>steam-run-native</code> above is just a wrapper linking to <code>steam.run</code>.
<translate>
<!--T:10-->
Basic Steam features can be enabled directly within the <code>programs.steam</code> attribute set:
</translate>
<syntaxhighlight lang="nix">
programs.steam = {
  enable = true; # Master switch, already covered in installation
  remotePlay.openFirewall = true;  # For Steam Remote Play
  dedicatedServer.openFirewall = true; # For Source Dedicated Server hosting
  # Other general flags if available can be set here.
};
# Tip: For improved gaming performance, you can also enable GameMode:
# programs.gamemode.enable = true;
</syntaxhighlight>
<translate>
<!--T:11-->
If you are using a Steam Controller or a Valve Index, ensure Steam hardware support is enabled. This is typically handled by <code>programs.steam.enable = true;</code> which sets <code>hardware.steam-hardware.enable = true;</code> implicitly. You can verify or explicitly set it if needed:
</translate>
<syntaxhighlight lang="nix">
hardware.steam-hardware.enable = true;
</syntaxhighlight>
<translate>
== Tips and tricks == <!--T:12-->
</translate>


Example snippet of <code>configuration.nix</code>:
<translate>
<syntaxHighlight lang=nix>
=== Gamescope Compositor / "Boot to Steam Deck" === <!--T:13-->
  ...
</translate>
  environment.systemPackages = with pkgs; [
<translate>
  ...
<!--T:14-->
  (steam.override { nativeOnly = true; }).run
Gamescope can function as a minimal desktop environment, meaning you can launch it from a TTY and have an experience very similar to the Steam Deck hardware console.
  ];
</translate>
  ...
<syntaxhighlight lang="nix">
</syntaxHighlight>
# Clean Quiet Boot
This builds same result as <code>steam-run-native</code> above.
boot.kernelParams = [ "quiet" "splash" "console=/dev/null" ];
boot.plymouth.enable = true;


Install the game by setting the executable attribute on the installer and then running it via <code>steam-run ./your_gog_installer.sh</code>. After installation, edit the "~/.local/share/applications/your_game_here.desktop" and replace the exec line from <code>Exec="/home/user/game/start.sh" ""</code> with <code>Exec="steam-run" "/home/user/game/start.sh"</code>.
programs.gamescope = {
  enable = true;
  capSysNice = true;
};
programs.steam.gamescopeSession.enable = true; # Integrates with programs.steam


== Adding missing dependencies ==
# Gamescope Auto Boot from TTY (example)
services.xserver.enable = false; # Assuming no other Xserver needed
services.getty.autologinUser = "USERNAME_HERE";


This can be done this way:
services.greetd = {
<syntaxHighlight lang=nix>
   enable = true;
  ...
   settings = {
   environment.systemPackages = with pkgs; [
    default_session = {
   ...
      command = "${pkgs.gamescope}/bin/gamescope -W 1920 -H 1080 -f -e --xwayland-count 2 --hdr-enabled --hdr-itm-enabled -- steam -pipewire-dmabuf -gamepadui -steamdeck -steamos3 > /dev/null 2>&1";
  (steam.override { extraPkgs = pkgs: [ mono gtk3 gtk3-x11 libgdiplus zlib ]; nativeOnly = true; }).run
      user = "USERNAME_HERE";
   ];
    };
...
   };
</syntaxHighlight>
};
</syntaxhighlight>


=== Bumblebee and Primus ===
<translate>
This can be done this way:
=== steam-tui === <!--T:15-->
<syntaxHighlight lang=nix>
</translate>
  ...
<translate>
  environment.systemPackages = with pkgs; [
<!--T:16-->
  ...
If you want the steam-tui client, you'll have to install it. It relies on <code>steamcmd</code> being set up, so you'll need to run <code>steamcmd</code> once to generate the necessary configuration files.
  (steam.override { withPrimus = true; extraPkgs = pkgs: [ bumblebee glxinfo ]; nativeOnly = true; }).run
First, ensure <code>steamcmd</code> is available (e.g., via <code>nix-shell -p steamcmd</code> or by adding it to <code>environment.systemPackages</code>), then run:
  ];
</translate>
...
<syntaxhighlight lang="bash">
</syntaxHighlight>
steamcmd +quit # This initializes steamcmd's directory structure
</syntaxhighlight>
<translate>
<!--T:17-->
Then install and run `steam-tui`. You may need to log in within `steamcmd` first if `steam-tui` has issues:
</translate>
<syntaxhighlight lang="bash">
# (Inside steamcmd prompt, if needed for full login before steam-tui)
# login <username> <password> <steam_2fa_code>
# quit
</syntaxhighlight>
<translate>
<!--T:18-->
After setup, <code>steam-tui</code> (if installed e.g. via <code>home.packages</code> or <code>environment.systemPackages</code>) should start fine.
</translate>


=== Java ===
<translate>
Example snippet of <code>configuration.nix</code>:
=== FHS environment only === <!--T:19-->
<syntaxHighlight lang=nix>
</translate>
  ...
<translate>
programs.java.enable = true;
<!--T:20-->
To run proprietary games or software downloaded from the internet that expect a typical Linux Filesystem Hierarchy Standard (FHS), you can use <code>steam-run</code>. This provides an FHS-like environment without needing to patch the software.
Note that this is not necessary for clients installed from Nixpkgs (like Minigalaxy or Itch), which already use the FHS environment as needed.
There are two options to make <code>steam-run</code> available:
1. Install <code>steam-run</code> system-wide or user-specifically:
</translate>
<syntaxhighlight lang="nix">
# In /etc/nixos/configuration.nix
environment.systemPackages = with pkgs; [
environment.systemPackages = with pkgs; [
   ...
   steam-run
(steam.override { withJava = true; })
];
];
   ...
</syntaxhighlight>
</syntaxHighlight>
<translate>
<!--T:21-->
2. If you need more flexibility or want to use an overridden Steam package's FHS environment:
</translate>
<syntaxhighlight lang="nix">
# In /etc/nixos/configuration.nix
environment.systemPackages = with pkgs; [
   (steam.override { /* Your overrides here */ }).run
];
</syntaxhighlight>
<translate>
=== Proton === <!--T:22-->
</translate>
<translate>
<!--T:23-->
You should be able to play most Windows games using Proton. If a game has a native Linux version that causes issues on NixOS, you can force the use of Proton by selecting a specific Proton version in the game's compatibility settings in Steam.
</translate>
<translate>
<!--T:24-->
By default, Steam also looks for custom Proton versions in <code>~/.steam/root/compatibilitytools.d</code>. The environment variable <code>STEAM_EXTRA_COMPAT_TOOLS_PATHS</code> can be set to add other search paths.
</translate>
<translate>
<!--T:25-->
Declarative install of custom Proton versions (e.g. GE-Proton):
</translate>
<syntaxhighlight lang="nix">
programs.steam.extraCompatPackages = with pkgs; [
  proton-ge-bin
];
</syntaxhighlight>
<translate>
<!--T:26-->
Manual management of multiple Proton versions can be done with ProtonUp-Qt:
</translate>
<syntaxhighlight lang="nix">
environment.systemPackages = with pkgs; [
  protonup-qt
];
</syntaxhighlight>
<translate>
=== Overriding the Steam package === <!--T:27-->
</translate>
<translate>
<!--T:28-->
In some cases, you may need to override the default Steam package to provide missing dependencies or modify its build. Use the <code>programs.steam.package</code> option for this. Steam on NixOS runs many games in an FHS environment, but the Steam client itself or certain tools might need extra libraries.
</translate>
<translate>
<!--T:29-->
Example: Adding Bumblebee and Primus (for NVIDIA Optimus):
</translate>
<syntaxhighlight lang="nix">
programs.steam.package = pkgs.steam.override {
  extraPkgs = pkgs': with pkgs'; [ bumblebee primus ];
};


You can test java availability by invoking chrooted bash instance: <code>steam-run bash</code> and then typing: <code>java -version</code>. Can be combined with extra packages above.
# For 32-bit applications with Steam, if using steamFull:
# programs.steam.package = pkgs.steamFull.override { extraPkgs = pkgs': with pkgs'; [ bumblebee primus ]; };
</syntaxhighlight>


== Limit user access ==
<translate>
Example snippet of <code>configuration.nix</code>:
<!--T:30-->
<syntaxHighlight lang=nix>
Example: Adding Xorg libraries for Gamescope (when used within Steam):
  ...
</translate>
   users.users.<your-username>.packages = [
<syntaxhighlight lang="nix">
     pkgs.steam
programs.steam.package = pkgs.steam.override {
   extraPkgs = pkgs': with pkgs'; [
    xorg.libXcursor
    xorg.libXi
    xorg.libXinerama
    xorg.libXScrnSaver
    libpng
    libpulseaudio
    libvorbis
     stdenv.cc.cc.lib # Provides libstdc++.so.6
    libkrb5
    keyutils
    # Add other libraries as needed
   ];
   ];
...
};
</syntaxHighlight>
</syntaxhighlight>
 
<translate>
=== Fix missing icons for games in GNOME dock and activities overview ===
</translate>
<translate>
GNOME uses the window class to determine the icon associated with a window. Steam currently doesn't set the required key for this in its .desktop files<ref>https://github.com/ValveSoftware/steam-for-linux/issues/12207</ref>, but you can fix this manually by editing the <code>StartupWMClass</code> key for each game's .desktop file, found under <code>~/.local/share/applications/</code>.
 
For games running through Proton, the value should be <code>steam_app_<game_id></code> (where <code><game_id></code> matches the value after steam://rungameid/ on the <code>Exec</code> line).
 
For games running natively, the value should match the game's main executable.
 
For example, the modified .desktop file for Valheim looks like this:
</translate>
 
<syntaxhighlight lang="desktop">
[Desktop Entry]
Name=Valheim
Comment=Play this game on Steam
Exec=steam steam://rungameid/892970
Icon=steam_icon_892970
Terminal=false
Type=Application
Categories=Game;
StartupWMClass=valheim.x86_64
</syntaxhighlight>
<translate>
== Troubleshooting == <!--T:31-->
</translate>


== Troubleshooting ==
<translate>
<!--T:32-->
For all issues: first run <code>steam -dev -console</code> through the terminal and read the output.
</translate>


=== Steam fails to start. What do I do? ===
<translate>
strace then open bug report.
=== Steam fails to start. What do I do? === <!--T:33-->
</translate>
<translate>
<!--T:34-->
Run <code>strace steam -dev -console 2> steam.logs</code> in the terminal. If <code>strace</code> is not installed, temporarily install it using <code>nix-shell -p strace</code> or <code>nix run nixpkgs#strace -- steam -dev -console 2> steam.logs</code> (if using Flakes). After that, create a bug report. <!-- This is vague. Where should the user create a bug report?  -->
</translate>


=== Game fails to start ===
<translate>
=== Steam is not updated === <!--T:35-->
</translate>
<translate>
<!--T:36-->
When you restart [[Steam]] after an update, it starts the old version. ([https://github.com/NixOS/nixpkgs/issues/181904 #181904])
A workaround is to remove the user files in <code>/home/&lt;USER&gt;/.local/share/Steam/userdata</code>. This can be done with <code>rm -rf /home/&lt;USER&gt;/.local/share/Steam/userdata</code> in the terminal or with your file manager. After that, Steam can be set up again by restarting.
</translate>
 
<translate>
=== Game fails to start === <!--T:37-->
</translate>
<translate>
<!--T:38-->
Games may fail to start because they lack dependencies (this should be added to the script, for now), or because they cannot be patched. The steps to launch a game directly are:
Games may fail to start because they lack dependencies (this should be added to the script, for now), or because they cannot be patched. The steps to launch a game directly are:
* Patch the script/binary if you can
* Patch the script/binary if you can
* Add a file named steam_appid.txt in the binary folder, with the appid as contents (it can be found in the stdout from steam)
* Add a file named steam_appid.txt in the binary folder, with the appid as contents (it can be found in the stdout from steam)
* Using the LD_LIBRARY_PATH from the nix/store steam script, with some additions, launch the game binary
* Using the LD_LIBRARY_PATH from the nix/store steam script, with some additions, launch the game binary
</translate>
<syntaxhighlight lang="bash">
<syntaxhighlight lang="bash">
LD_LIBRARY_PATH=~/.steam/bin32:$LD_LIBRARY_PATH:/nix/store/pfsa... blabla ...curl-7.29.0/lib:. ./Osmos.bin32 (if you could not patchelf the game, call ld.so directly with the binary as param)
LD_LIBRARY_PATH=~/.steam/bin32:$LD_LIBRARY_PATH:/nix/store/pfsa... blabla ...curl-7.29.0/lib:. ./Osmos.bin32 (if you could not patchelf the game, call ld.so directly with the binary as parameter)
</syntaxhighlight>
</syntaxhighlight>
With this technique, I can play many games directly from steam. Others, like Team Fortress, cannot be patched so I only managed to run them from the cmd line.
<translate>
<!--T:39-->
Note: If a game gets stuck on Installing scripts, check for a DXSETUP.EXE process and run it manually, then restart the game launch.
</translate>


=== new Libcpp for steam ===
<translate>
{{outdated|Since the merge of {{issue|29180}} this subsection is obsolete}}
==== Changing the driver on AMD GPUs <!-- this is not recommended due radv drivers performing better and generally more stable than amdvlk. My suggestion remove this section. source: https://forums.guru3d.com/threads/the-mesa-radv-amdvlk-thread.449774/ -->==== <!--T:40-->
The open source radeon drivers need a newer libc++ than is provided by the default runtime, which leads to acrash on launch. Use
</translate>
{{note|This is not recommended because radv drivers tend to perform better and are generally more stable than amdvlk.}}
<translate>
<!--T:41-->
Sometimes, changing the driver on AMD GPUs helps. To try this, first, install multiple drivers such as radv and amdvlk:
</translate>
<syntaxhighlight lang="nix">
hardware.graphics = {
  ## radv: an open-source Vulkan driver from freedesktop
  enable32Bit = true;
 
  ## amdvlk: an open-source Vulkan driver from AMD
  extraPackages = [ pkgs.amdvlk ];
  extraPackages32 = [ pkgs.driversi686Linux.amdvlk ];
};
</syntaxhighlight>
<translate>
<!--T:42-->
In the presence of both drivers, [[Steam]] will default to amdvlk. The amdvlk driver can be considered more correct regarding Vulkan specification implementation, but less performant than radv. However, this tradeoff between correctness and performance can sometimes make or break the gaming experience.
</translate>
<translate>
<!--T:43-->
To "reset" your driver to radv when both radv and amdvlk are installed, set either <code>AMD_VULKAN_ICD = "RADV"</code> or <code>VK_ICD_FILENAMES = "/run/opengl-driver/share/vulkan/icd.d/radeon_icd.x86_64.json"</code> environment variable. For example, if you start [[Steam]] from the shell, you can enable radv for the current session by running <code>AMD_VULKAN_ICD="RADV" steam</code>. If you are unsure which driver you currently use, you can launch a game with [https://github.com/flightlessmango/MangoHud MangoHud] enabled, which has the capability to show what driver is currently in use.
</translate>
<translate>
=== SteamVR === <!--T:44-->
</translate>
<translate>
<!--T:45-->
The setcap issue at SteamVR start can be fixed with:
<code>sudo setcap CAP_SYS_NICE+ep ~/.local/share/Steam/steamapps/common/SteamVR/bin/linux64/vrcompositor-launcher</code>
</translate>
<translate>
=== Gamescope fails to launch when used within Steam === <!--T:46-->
</translate>
<translate>
<!--T:47-->
Gamescope may fail to start due to missing Xorg libraries. ([https://github.com/NixOS/nixpkgs/issues/214275 #214275]) To resolve this override the steam package to add them:
</translate>
<syntaxhighlight lang="nix">
programs.steam.package = pkgs.steam.override {
  extraPkgs = pkgs': with pkgs'; [
    xorg.libXcursor
    xorg.libXi
    xorg.libXinerama
    xorg.libXScrnSaver
    libpng
    libpulseaudio
    libvorbis
    stdenv.cc.cc.lib # Provides libstdc++.so.6
    libkrb5
    keyutils
    # Add other libraries as needed
  ];
};
</syntaxhighlight>
<translate>
=== Udev rules for additional Gamepads === <!--T:48-->
</translate>
<translate>
<!--T:49-->
In specific scenarios gamepads, might require some additional configuration in order to function properly in the form of udev rules. This can be achieved with <code>services.udev.extraRules</code>.
</translate>
<translate>
<!--T:50-->
The following example is for the 8bitdo Ultimate Bluetooth controller, different controllers will require knowledge of the vendor and product ID for the device:
</translate>
<syntaxhighlight lang="nix">
<syntaxhighlight lang="nix">
(steamPackages.override { newLibcpp = true; }).steam-chrootenv
  services.udev.extraRules = ''
    SUBSYSTEM=="input", ATTRS{idVendor}=="2dc8", ATTRS{idProduct}=="3106", MODE="0660", GROUP="input"
  '';
</syntaxhighlight>
</syntaxhighlight>
[https://github.com/NixOS/nixpkgs/pull/12404 in your config] if you get an error like
<translate>
<!--T:51-->
To find the vendor and product ID of a device [https://search.nixos.org/packages?channel=unstable&show=usbutils&from=0&size=50&sort=relevance&type=packages&query=usbutils usbutils] might be useful
</translate>
<translate>
=== Known issues === <!--T:52-->
</translate>
<translate>
<!--T:53-->
"Project Zomboid" may report "couldn't determine 32/64 bit of java". This is not related to java at all, it carries its own outdated java binary that refuses to start if path contains non-Latin characters. Check for errors by directly starting local java binary within <code>steam-run bash</code>.


libGL error: unable to load driver: radeonsi_dri.so
<!--T:55-->
libGL error: driver pointer missing
Resetting your password through the [[Steam]] app may fail at the CAPTCHA step repeatedly, with [[Steam]] itself reporting that the CAPTCHA was not correct, even though the CAPTCHA UI shows success. Resetting password through the [[Steam]] website should work around that.
libGL error: failed to load driver: radeonsi
</translate>
libGL error: unable to load driver: swrast_dri.so
<translate>
libGL error: failed to load driver: swrast
== References == <!--T:54-->
 
</translate>
=== Known issues ===
"Project Zomboid" may report "couldn't determine 32/64 bit of java". This is not related to java at all, it carries own outdated java binary that refuses to start if path contains non-latein characters. Check for errors by directly starting local java binary within <code>steam-run bash</code>.
 
=== HiDPI ===
If Steam's UI fonts are unbearably tiny, consider adding a custom skin from https://github.com/MoriTanosuke/HiDPI-Steam-Skin for your user to alleviate this. The skins directory is ~/.local/share/Steam/skins/.
 
== steam-run ==
<code>steam-run</code> is a helper that can be used to run external programs in the steam FHS environment. This means that some third-party software, mostly games, can be run easily on NixOS using <code>steam-run</code>. Before trying other solutions, try starting your game this way, where <code>start-game.sh</code> is the script used to start the game on Linux.
<syntaxhighlight lang="commands">
$ steam-run ./start-game.sh
</syntaxhighlight>


== Steam hardware ==
[[Category:Applications]]
If you are using a Steam Controller or a Valve Index, you will want to add <code>hardware.steam-hardware.enable = true;</code> to your configurations.
[[Category:Gaming]]
Retrieved from "https://wiki.nixos.org/wiki/Steam"