Steam Deck as a Homelab Toolkit (Yes, Really)

Your Gaming Console Is Already a Linux Box

You bought the Steam Deck to play games. Maybe you’re deep into Baldur’s Gate 3, or you’ve been stockpiling your backlog for three years like the rest of us. But here’s the thing — SteamOS 3.x is Arch Linux with a KDE Plasma desktop and a game launcher slapped on top. That’s it. That’s the whole trick.

Valve gave you a portable, fanless-ish (well, quiet-ish), dual-boot-capable Linux computer with a touchscreen, trackpads, and an 8-hour battery. Sysadmins have been squeezing value out of worse hardware for decades. So let’s do this properly.

This article covers turning your Steam Deck into a legitimate homelab toolkit — Tailscale mesh VPN, Distrobox containers for any tooling you want, tmux sessions that survive suspend/resume, IPMI from the couch, and the dotfiles setup that makes it actually usable. Gaming stays intact. That’s the deal.

SteamOS: What You’re Actually Working With

The base OS is a read-only, immutable Arch-based system. Valve updates the root partition atomically and you can’t just pacman -S your way to happiness without things breaking on the next OS update. This sounds annoying. It kind of is. But Valve also gave you the escape hatch: Desktop Mode.

Switch to Desktop Mode (hold Power → Switch to Desktop), open Konsole, and you have a full Arch terminal. The read-only root partition means system-level installs won’t survive updates, but your home directory at /home/deck is yours and persists forever.

The correct answer to “I want tool X on my Deck” is not pacman -S X. It’s Distrobox.

OLED vs LCD Storage

Quick hardware note before we dive in: the LCD model ships with 64GB, 256GB, or 512GB eMMC. The OLED model bumped the base to 512GB with faster eMMC. Both accept a microSD card (up to 2TB confirmed working). For homelab use, grab a fast A2-rated microSD — put your Distrobox containers and dotfiles workspace there. The eMMC handles the OS and games; the SD card handles your sysadmin layer.

Format the SD card as ext4 if you want Linux permissions to work properly. FAT32 and exFAT will cause you pain with symlinks and chmod.

Step 1: Konsole + tmux — Your Actual Workspace

Desktop Mode ships with Konsole. Open it, set the profile font to something readable (JetBrains Mono 14pt holds up on the Deck’s 1280×800 display), and immediately install tmux via Distrobox rather than the system pacman.

Before that, let’s set a sudo password. Out of the box, deck has no password set:

passwd

Do this first. Everything else breaks without it.

Now, configure tmux so sessions survive the Deck going to sleep. Create ~/.tmux.conf:

set -g default-terminal "screen-256color"
set -g mouse on
set -g history-limit 50000

# Status bar — keeps it readable at 1280x800
set -g status-bg colour234
set -g status-fg colour137
set -g status-left '#[fg=colour045,bold] [#S] '
set -g status-right '#[fg=colour239] %H:%M '

# Don't rename windows automatically
set-option -g allow-rename off

# Ctrl+a prefix (muscle memory from screen days)
unbind C-b
set-prefix C-a
bind C-a send-prefix

When you suspend the Deck mid-SSH session, tmux keeps your sessions alive on the remote end. When you wake it up and reconnect, tmux attach drops you right back in. No lost work, no broken pipes lying around.

Step 2: Distrobox — Install Literally Anything

Distrobox runs containers (via Podman under the hood) that share your home directory. You get full access to any distro’s package manager without touching the read-only root. And unlike Flatpak, tools installed in Distrobox behave like native binaries.

Install Distrobox to your home directory (no root required):

curl -s https://raw.githubusercontent.com/89luca89/distrobox/main/install | sh -s -- --prefix ~/.local

Add ~/.local/bin to your PATH in ~/.bashrc or ~/.zshrc, then create your boxes:

# Arch box for bleeding-edge tools
distrobox create --name arch-tools --image archlinux:latest

# Debian box for anything that "only runs on Ubuntu"
distrobox create --name debian-tools --image debian:bookworm

# Fedora box if you live on the edge with podman tooling
distrobox create --name fedora-tools --image fedora:latest

Enter a box and install tools as you normally would:

distrobox enter arch-tools
sudo pacman -S nmap wireshark-cli iproute2 tcpdump netcat kubectl helm

Export binaries back to your host so you can call them without entering the box:

distrobox-export --bin /usr/bin/kubectl
distrobox-export --bin /usr/bin/helm
distrobox-export --bin /usr/bin/nmap

These land in ~/.local/bin and work from any terminal. Your arch-tools box becomes a rolling-release toolbox that survives OS updates because it lives in your home directory, not on the read-only root.

Step 3: Tailscale — Connect Your Homelab Everywhere

This is the big one. Tailscale turns the Deck into a mesh VPN node that can reach every machine in your homelab without port forwarding, firewall rules, or waking up at 2 AM to debug WireGuard configs.

Tailscale isn’t in the SteamOS package manager, but it runs great in Distrobox with a small trick — you need --privileged mode for the network interface:

distrobox create \
  --name tailscale-box \
  --image archlinux:latest \
  --additional-flags "--privileged --network=host"

Inside the box:

distrobox enter tailscale-box
sudo pacman -S tailscale
sudo systemctl enable --now tailscaled
sudo tailscale up

Authenticate via the link it prints, and your Deck appears in your Tailscale admin console. Now every machine in your tailnet is reachable by hostname from the Deck, anywhere you have Wi-Fi.

To auto-start Tailscale when Desktop Mode launches, add a KDE autostart entry pointing to distrobox run tailscale-box -- sudo tailscaled. Not glamorous, but it works.

Step 4: SSH Console + IPMI From the Couch

With Tailscale running, your entire homelab is reachable. Set up SSH config so you’re not typing IPs:

Host proxmox
    HostName 100.x.x.x
    User root
    IdentityFile ~/.ssh/id_ed25519
    ServerAliveInterval 30
    ServerAliveCountMax 3

Host nas
    HostName 100.x.x.y
    User admin
    IdentityFile ~/.ssh/id_ed25519

Host *
    AddKeysToAgent yes
    IdentityFile ~/.ssh/id_ed25519

ServerAliveInterval and ServerAliveCountMax keep connections alive through the Deck’s aggressive power management. Without this, SSH drops every time the screen dims.

For IPMI access (checking on a crashed server without getting off the couch), most BMCs expose a web UI on port 443 and an SSH interface. With Tailscale connected, just point the Deck’s browser at the BMC IP. KVM-over-IP renders fine in a browser. You can reboot a server from Game Mode if you install a browser as a non-Steam game. Yes, this is cursed. Yes, it works.

Step 5: Packet Captures and Network Debugging

The Deck has a solid Wi-Fi adapter (Intel AX210 on OLED, AX200 on late LCD models). Running tcpdump or Wireshark from your arch-tools Distrobox box captures traffic on whatever network you’re connected to.

distrobox enter arch-tools
sudo tcpdump -i wlan0 -w /home/deck/capture_$(date +%Y%m%d_%H%M%S).pcap

Pull the pcap file to your workstation later via scp or just analyze it on the Deck with tshark:

tshark -r /home/deck/capture_20260823_142200.pcap -Y "http.request" -T fields \
  -e ip.src -e ip.dst -e http.request.uri

Useful when you’re at a client site or a hotel and something on the local network smells wrong. The Deck fits in your bag in a way that a laptop with a full Wireshark GUI doesn’t always.

Step 6: Dotfiles with chezmoi

The Deck will get wiped eventually — an OS update goes sideways, you do a factory reset, something explodes. Set up chezmoi so your config travels with you.

# Install chezmoi to home dir (no root)
sh -c "$(curl -fsLS get.chezmoi.io)" -- -b ~/.local/bin

# Initialize from your existing dotfiles repo
chezmoi init https://github.com/yourusername/dotfiles.git

# Apply
chezmoi apply

Manage your ~/.tmux.conf, ~/.ssh/config, ~/.bashrc, and any tool configs through chezmoi. When you set up a fresh Deck, one chezmoi init && chezmoi apply and you’re back to your full environment in five minutes.

Store secrets (SSH keys, Tailscale auth keys) encrypted with chezmoi’s age integration — don’t commit bare keys to GitHub like it’s 2012.

Step 7: Decky Loader Plugins (Bonus Round)

If you want system-level plugins for Game Mode (the gaming UI, not Desktop Mode), Decky Loader is the community plugin framework. Install it in Desktop Mode:

curl -L https://github.com/SteamDeckHomebrew/decky-installer/releases/latest/download/install_release.sh | sh

Relevant plugins for homelab use:

• SSH Shortcut — launch an SSH session directly from Game Mode
• System Toolbox — CPU/GPU clocks, fan curves, battery stats
• Network Info — shows current IP, Tailscale status at a glance

You won’t be managing servers from the Game Mode UI regularly, but having quick SSH access when you’re mid-session and get a Grafana alert is legitimately useful.

Storage Strategy

Keep this layout on your SD card (/run/media/deck/<card-name>/):

/run/media/deck/toolkit/
  distrobox/          ← set DISTROBOX_HOME here
  captures/           ← pcap files
  workspace/          ← git repos, scratch files
  scripts/            ← runbooks, one-off scripts

Set Distrobox to use the SD card for container storage by exporting DISTROBOX_HOME in your .bashrc. Container images are 500MB–2GB each; keeping them off the eMMC leaves room for games.

export DISTROBOX_HOME=/run/media/deck/toolkit/distrobox

The Actual Pitch

Here’s the honest take: the Steam Deck is not going to replace your workstation for serious homelab work. The screen is 1280×800, you’re typing on a virtual keyboard or a Bluetooth keyboard, and tmux on a 8-inch screen has its limits.

But for the specific scenario of “I’m away from my desk and something needs attention” — it’s genuinely excellent. Tailscale is connected, SSH config is loaded, tmux is running, and you have nmap and tcpdump in your arch-tools box. You can triage an incident from a couch, a coffee shop, or the passenger seat of a car (please don’t drive). You already have the device. Setting this up takes maybe two hours. Your 2 AM self will appreciate it.

The worst case is you go back to playing Elden Ring when the alert resolves. There are worse outcomes.

Quick Reference

[ ] Set sudo password: passwd
[ ] Install Distrobox: curl | sh
[ ] Create arch-tools box, install nmap/tcpdump/kubectl/helm
[ ] Create tailscale-box (--privileged --network=host)
[ ] Configure ~/.ssh/config with ServerAliveInterval
[ ] Install chezmoi, init from dotfiles repo
[ ] Format microSD as ext4, set DISTROBOX_HOME
[ ] Set tmux prefix, enable mouse mode
[ ] (Optional) Install Decky Loader + plugins

Related Reading

• Sunshine + Moonlight: Roll Your Own Cloud Gaming
• Steam on Linux: It Actually Works Now
• Bazzite vs Nobara vs CachyOS Gaming
• GeForce Now: Cloud Gaming Done Right
• Access Docker socket via TCP