Skip to content
Go back

LinuxGSM: Boring Game Servers Done Right

By KingPin 11 min read
LinuxGSM: Boring Game Servers Done Right
Contents

The tool nobody brags about, because it just works

Every homelab gaming setup you have read about this year is secretly running the same thing under the hood. Pterodactyl panel with a slick web UI? LinuxGSM does the actual server management underneath in a lot of guides. A friend’s dedicated Valheim box that never seems to go down? Probably a shell script called vhserver and a cron job.

LinuxGSM (Linux Game Server Managers) is a command-line tool that installs, starts, stops, updates, and monitors dedicated game servers on Linux. As of September 2026 it supports 140 different game servers, counted straight from its serverlist.csv manifest, from Counter-Strike 2 to Valheim to a Teamspeak voice server. Current release is v26.2.0, published July 19, 2026.

Full example: Clone the working files at github.com/KingPin/sumguy-examples/tree/main/gaming/linuxgsm-game-servers.

Nobody writes hype threads about LinuxGSM because there is nothing to hype. It downloads SteamCMD, wraps your server in a tmux session, gives you a ./gameserver start command, and gets out of the way. Nothing about it needs a sales deck. Below: bare Linux with systemd and cron, the official Docker image, and where a web panel like Pterodactyl fits on top of either one. The running example is Valheim, one of the best-documented servers in the LinuxGSM lineup, and most homelabbers already have a friend nagging them for one.

Bare metal: adduser, download, install

The bare-metal path is the original LinuxGSM experience. You get a dedicated Linux user, a folder, and one script that does everything.

Create the user and drop into its shell:

Terminal window
sudo adduser vhserver
sudo su - vhserver

Download the LinuxGSM bootstrap script and point it at Valheim’s shortname (vh):

Terminal window
curl -Lo linuxgsm.sh https://linuxgsm.sh && chmod +x linuxgsm.sh && bash linuxgsm.sh vhserver

That command generates a vhserver script in the current directory, LinuxGSM’s naming convention: <shortname>server for the gameserver name, so Valheim (vh) becomes vhserver, CS2 (cs2) becomes cs2server, and so on. Now install it:

Terminal window
./vhserver install

The installer creates directories, checks dependencies (tmux and glibc at minimum, SteamCMD for anything Steam-based), downloads the game server files, and drops in default configs. If vhserver has sudo rights, it will offer to install missing packages itself. If you are running as root instead, ./vhserver install will only handle dependencies and skip the rest, because LinuxGSM refuses to run a game server as root on purpose.

Once installed, the everyday commands are short and memorable:

Terminal window
./vhserver start # boots the server inside a tmux session
./vhserver stop # graceful shutdown
./vhserver restart # stop then start
./vhserver console # attach to the live tmux console
./vhserver details # ports, passwords, config paths, disk usage
./vhserver update # checks for updates, restarts only if needed
./vhserver backup # tar.gz archive of the whole server
./vhserver monitor # process + query check, restarts on failure

Every one of those has a short alias too (st, sp, r, c, dt, u, b, m), which matters once you are typing them at 2 AM because Discord is yelling that the server fell over again.

The console command drops you straight into the tmux session running the game process. CTRL+b d detaches without killing the server. CTRL+c kills it, so do not mash that one out of habit.

Config files: three layers, last one wins

LinuxGSM configs live at lgsm/config-lgsm/vhserver/ and follow a three-file cascade:

  1. _default.cfg: the full list of every setting LinuxGSM knows about. Read-only, regenerated by LinuxGSM itself. Never edit it, copy from it.
  2. common.cfg: optional, shared across every instance in that installation. Useful once you run more than one server as the same user.
  3. vhserver.cfg: the instance file. Same name as your gameserver script. Loaded last, wins every conflict.

Copy only the lines you actually want to change into vhserver.cfg. The Valheim defaults worth knowing:

lgsm/config-lgsm/vhserver/vhserver.cfg
servername="LinuxGSM"
serverpassword="" # minimum length is 5 characters
port="2456" # game port, query port is port+1 (2457)
worldname="${selfname}"
public="1"
savedir="$HOME/.config/unity3d/IronGate/Valheim"
saveinterval="1800" # autosave interval, seconds
backups="4"
backupshort="7200"
backuplong="43200"
instanceid="1"

Valheim also supports worldmodifiers, a start-parameter string for presets like -preset hard or key toggles like -setkey nomap. Those live in the same file and get folded into startparameters automatically. This is a real win over hand-rolling a systemd unit yourself: the config is one flat file instead of a wall of ExecStart flags you will forget the syntax for in six months.

systemd and cron: the two ways to keep it running

LinuxGSM itself does not ship a systemd unit. It runs inside tmux and expects cron for automation, which is the “boring” half of this article’s premise. If you want systemd anyway, because you like systemctl status more than attaching to a tmux session, you can wrap the LinuxGSM commands in a thin unit:

/etc/systemd/system/vhserver.service
[Unit]
Description=Valheim dedicated server (LinuxGSM)
After=network.target
[Service]
Type=forking
User=vhserver
WorkingDirectory=/home/vhserver
ExecStart=/home/vhserver/vhserver start
ExecStop=/home/vhserver/vhserver stop
Restart=no
[Install]
WantedBy=multi-user.target

Type=forking works here because ./vhserver start backgrounds into tmux and returns. Set Restart=no and let LinuxGSM’s own monitor command handle crash recovery instead of systemd; the two restart mechanisms fighting each other is how you end up with two Valheim processes fighting over the same save file. This unit is a convenience wrapper, not something LinuxGSM ships or documents itself, so test it before you trust it at 2 AM.

The actual recommended automation is cron, straight from LinuxGSM’s own Valheim page:

*/5 * * * * /home/vhserver/vhserver monitor > /dev/null 2>&1
*/30 * * * * /home/vhserver/vhserver update > /dev/null 2>&1
0 0 * * 0 /home/vhserver/vhserver update-lgsm > /dev/null 2>&1

monitor checks every five minutes that the tmux session is alive and that the server answers a query, restarting it if not. update checks for a new Valheim build twice an hour and only restarts if one is actually available. update-lgsm updates LinuxGSM’s own scripts weekly. Edit with crontab -e as the vhserver user, not root; LinuxGSM’s own docs are explicit that mixing sudo-run cron with a plain user install is a common source of permission headaches.

Opening the firewall

Valheim’s default config uses port 2456 for the game itself and 2457 for the Steam query port, one number up, verifiable any time with ./vhserver details once the server is running. On a bare-metal box with ufw, open both as UDP:

Terminal window
sudo ufw allow 2456:2457/udp

If you change port in vhserver.cfg, the query port always follows one number above it, so update the firewall rule to match. Forget this step and monitor will happily restart a server that was never broken, because the process is running fine, it is just unreachable from outside your LAN.

Backing up and restoring

./vhserver backup stops the server, compresses the whole install (serverfiles, configs, and the world save together) into a .tar.gz, and drops it in /home/vhserver/lgsm/backup/ as vhserver-YYYY-MM-DD-HHMMSS.tar.gz, then starts the server back up. Two settings control how many pile up: maxbackups (default 4, oldest gets deleted past that count) and maxbackupdays (default 30, anything older gets pruned), both set in vhserver.cfg. There is no dedicated one-command restore. Restoring means extracting the archive back over the install directory while the server is stopped:

Terminal window
./vhserver stop
tar -xzf lgsm/backup/vhserver-2026-09-20-030000.tar.gz -C /home/vhserver
./vhserver start

Automate the backup half with a weekly cron line next to the three above it. Automate the restore half never; a bad restore run unattended is how a world save gets overwritten by a stale archive, so keep that step manual.

Docker: the official image, no bash script required

The GameServerManagers/docker-gameserver repository builds an image for every entry in serverlist.csv, published weekly to Docker Hub as gameservermanagers/gameserver and to GHCR as ghcr.io/gameservermanagers/gameserver, one tag per game shortname. Valheim is the vh tag, confirmed live on Docker Hub as of this week.

docker-compose.yml
services:
vhserver:
image: gameservermanagers/gameserver:vh
container_name: vhserver
restart: unless-stopped
network_mode: host
volumes:
- vhserver-data:/data
volumes:
vhserver-data:

network_mode: host is the pattern in LinuxGSM’s own compose examples, and it saves you from hand-mapping UDP ports every time a game adds a new one. The /data path is the container’s home directory: serverfiles, configs, logs, and saves all live under it, so it is the only volume you need. First run installs Valheim from scratch and can take a few minutes depending on your connection to Steam’s CDN.

The container runs the game process as a linuxgsm user via gosu, not root, matching the bare-metal install’s own refusal to run as root. Run LinuxGSM commands the same way you would locally, just prefixed with docker exec:

Terminal window
docker exec -it --user linuxgsm vhserver ./vhserver details
docker exec -it --user linuxgsm vhserver ./vhserver console
docker exec -it --user linuxgsm vhserver ./vhserver update

Editing the config is the same three-file cascade as bare metal, just reached through the bind mount instead of SSH: vhserver-data/lgsm/config-lgsm/vhserver/vhserver.cfg on the host, if you swap the named volume for a bind mount to /path/to/vhserver:/data. Change the file, then restart the container, since there is no separate docker restart shortcut for reloading LinuxGSM configs specifically.

Which one should you actually run

Bare metal wins when you already run other things on that box outside containers, or when you want htop to show you the raw game process without peeling back a container layer. Docker wins when you are already running Traefik or Portainer for everything else and do not want one server that is the odd one out in your fleet, or when you want to nuke and redeploy without worrying about leftover SteamCMD cache and dependency cruft on the host. Both run the identical LinuxGSM scripts underneath. You are choosing a delivery mechanism, not a different tool, so pick whichever one matches how you already manage the rest of your homelab and move on.

Where a web panel fits

Pterodactyl, Pelican, and Crafty Controller solve a different problem: letting someone who is not you restart the server without SSH access or a terminal. We compared those three head to head already, so this is not a rerun. The short version for how it relates to LinuxGSM: Pterodactyl and Pelican spin up a separate Docker container per game server through their own Wings daemon, and Crafty runs each server as a subprocess inside one Python app. None of the three shell out to LinuxGSM scripts under the hood. They are a parallel management layer, not a GUI wrapper around ./vhserver start.

If the only person touching the server is you, and you are comfortable with ./vhserver console, a panel is a forklift for a couch you can already carry yourself. If you are handing server control to three roommates who think cd is a scary command, install a panel. The two setups are not mutually exclusive, either: nothing stops you from running LinuxGSM’s Docker image inside a Pterodactyl egg, though at that point you are running two process managers to babysit one Valheim world, and your 2 AM self will have two dashboards to check instead of one.

Common Questions

Can LinuxGSM run inside Docker?

Yes. The GameServerManagers/docker-gameserver project publishes one official image per supported game, tagged by shortname, to both Docker Hub (gameservermanagers/gameserver) and GHCR. Valheim uses the vh tag. The image runs the same LinuxGSM scripts as the bare-metal install, executed via docker exec instead of SSH, with /data as the persistent volume.

Does LinuxGSM require systemd?

No. LinuxGSM runs the game process inside a tmux session and relies on cron for automated monitoring and updates, not systemd. A systemd unit wrapping start and stop works as an optional convenience, but LinuxGSM does not ship or document one itself, and it is not required for any of its 140 supported servers.

How many game servers does LinuxGSM support?

140, counted directly from the serverlist.csv manifest in the LinuxGSM GitHub repository as of September 2026. That list ranges from decades-old titles like Quake and Half-Life mods to current releases like Valheim, Palworld, and CS2. New entries get added as community demand and SteamCMD support allow.

Do I need Pterodactyl or Pelican to use LinuxGSM?

No. LinuxGSM runs standalone from the command line with no panel required. Pterodactyl, Pelican, and Crafty Controller are separate management layers built for handing server control to other people through a web UI. They do not depend on LinuxGSM and do not call its scripts, so pick a panel only when you need multi-user access, not as a LinuxGSM prerequisite.

What Linux distros does LinuxGSM officially support for Valheim?

Ubuntu 24.04 LTS, Debian 11, and Enterprise Linux 8 are the minimum recommended distros per LinuxGSM’s own compatibility page. Any distro with tmux 1.6 or newer and glibc 2.15 or newer should also work, though LinuxGSM does not run automated dependency checks against untested distros, so verify manually first.


Share this post on:

Send a Webmention

Written about this post on your own site? Send a webmention and it'll show up above once verified.


Previous Post
AppFlowy vs Notion: Self-Host Your Notes
Next Post
Prompt Injection vs Your Coding Agent

Discussion

Powered by Garrul . Sign in with GitHub or Google, or post anonymously.

Related Posts