Game Servers on a VPS: Minecraft, CS2, Rust, Valheim and Palworld Close to Your Players

A game server you rent by the slot is someone else's machine with someone else's rules: fixed player counts, a plugin list you cannot extend, and a location chosen for the provider's convenience. A VPS turns that around. You get a Linux (or Windows) server with root access, a public IP of its own and unmetered traffic, you install exactly the server software you want, and you put it in the data centre closest to the people who play on it. This guide covers five popular games to run on your own server, Minecraft, Counter-Strike 2, Rust, Valheim and Palworld: what each one really needs, which ports to open, the mistakes that cost people an evening, and which RS Computers plan fits. Facts and version numbers were checked in October 2026.

Why ping is mostly about distance

Latency is the one thing no amount of hardware fixes. Light in fibre needs about 1 ms of round-trip time for every 100 km of cable, before a single router adds its share, so a server 2,000 km from your players starts with a 20 ms handicap that grows with every detour the route takes. Research on latency in games has long shown that first-person shooters are the first to suffer: in one widely cited study, accuracy with precision weapons fell by about a third once the delay reached 100 ms, while third-person, strategy and building games held up at several times that. Of the five games here, CS2 and gunfights in Rust are the most sensitive to ping; building and exploring in Minecraft, Valheim or Palworld are far more forgiving.

The practical rule: host where your players are. A group of friends in Kosovo, Albania, North Macedonia or elsewhere in the Balkans gets the shortest path from a server in Prishtina; a mixed European community is usually best served from Amsterdam, where most networks meet; Dublin suits players in Ireland and the UK. RS Computers offers the same plans in all three cities, and the plans page shows which locations currently have capacity. If you are unsure, ask a few players to ping the server's address in the first hour and move while the world is still empty.

Why run game servers at RS Computers

• Real KVM virtual machines. Every plan is a full virtual machine with its own kernel, so SteamCMD, Docker and panels such as Pterodactyl work without the nesting problems of container-based "VPS" products.
• NVMe storage. World saves, chunk loading and the roughly 73 GB a CS2 install needs are disk work. NVMe keeps the disk part of saves and chunk loading short, which makes autosave lag spikes less likely.
• Unmetered traffic. A 1 Gb/s port on VPS plans and 10 Gb/s on VDS plans, with no traffic counter to watch on a busy weekend.
• Your own IPv4 and IPv6. Default ports are yours, so friends connect with an address instead of an address and an odd port number, and a DNS name such as play.example.com is one A record away.
• Free weekly backups. The whole server is backed up every week and can be restored from the client area. Combine it with your own world backups (below) and a bad plugin update stops being a disaster.
• Grow in place. Start small while the community is small and upgrade vCPU, memory and disk from the client area when it grows; the world stays where it is.
• Linux or Windows. All five games have native Linux servers, which is what this guide uses. If you prefer Windows Server, it is available on VPS Mini and all VDS plans.

One honest note on performance: all five games run their simulation mostly on a single thread, so the speed of one core matters more than the number of cores. Our plans use shared vCPUs, as most cloud servers do, so choose a plan with some headroom rather than the bare minimum and watch the server's own tick metrics after launch.

Which plan for which game?

Memory figures come from each developer's own documentation where it exists, otherwise from the game's wiki or, where noted, from what hosting providers publish. Player counts are sensible starting points, not hard limits.

VPS Nano is too small for any of these games; it is the right size for a Discord bot or a status page that watches your game server from another location.

Ports at a glance

Most game traffic is UDP. A firewall that only allows SSH and web ports leaves the server running but invisible, and opening the TCP port when the game uses UDP (or the reverse) is the classic "it works for me on the server but nobody can join" mistake.

Every plan includes IPv6, but plan on players connecting over IPv4: most of these servers either do not listen on IPv6 or only partly support it.

Prepare the server once

Order a plan on the VPS & VDS plans page with Debian 13 or Ubuntu 24.04, then log in as root and set up the firewall and an unprivileged user. Game servers should never run as root, and Valve says the same about SteamCMD.

ssh root@YOUR_SERVER_IP
apt update && apt full-upgrade -y
apt install -y lib32gcc-s1 lib32stdc++6 lib32z1 curl ca-certificates tmux ufw
ufw allow OpenSSH
ufw --force enable
adduser --disabled-password --gecos "" steam

CS2, Rust, Valheim and Palworld are all downloaded with SteamCMD, Valve's command-line downloader. It is a 32-bit program, which is what the lib32 packages above are for. Install it once for the steam user:

su - steam
mkdir -p ~/steamcmd && cd ~/steamcmd
curl -sqL "https://steamcdn-a.akamaihd.net/client/installer/steamcmd_linux.tar.gz" | tar zxvf -

All four games download with an anonymous login; no Steam account and no copy of the game is needed on the server. In the four SteamCMD sections (CS2, Rust, Valheim and Palworld), each block says which lines are typed as root and which as the steam user: exit takes you from the steam user back to root and su - steam switches again. The Minecraft section and the systemd commands near the end do not use the steam user at all; run them as root.

Minecraft: Java 25, Paper and the whitelist surprise

Minecraft Java Edition does not use Steam; the server is a single jar file. Three things changed in 2026 that older tutorials get wrong. Since version 26.1 the server requires Java 25. Since 26.3 a freshly created server has the whitelist switched on, so nobody can join until you add them. And plugin platforms trail the vanilla release by a few weeks: in October 2026 the stable Paper build is still 26.2, where the whitelist is off by default, so check which version is marked stable before you tell players which version to use.

# as root (type exit first if you are still the steam user)
apt install -y openjdk-25-jre-headless
ufw allow 25565/tcp
useradd -r -m -d /opt/minecraft -s /bin/bash minecraft
cd /opt/minecraft
# download the current stable Paper jar from papermc.io and save it here as server.jar
# heap (-Xms/-Xmx): 1G on VPS Micro, 3G on VPS Mini, 6G on VDS Small; the lines below use the VPS Mini value
runuser -u minecraft -- java -Xms3G -Xmx3G -jar server.jar --nogui   # first run writes eula.txt and stops
sed -i 's/^eula=false/eula=true/' eula.txt                            # you accept the Minecraft EULA
runuser -u minecraft -- java -Xms3G -Xmx3G -jar server.jar --nogui   # stays in the foreground; type stop to shut it down

Debian 12 has no Java 25 package; use Debian 13 or Ubuntu 24.04, or add the Adoptium repository. In the server console, whitelist add PlayerName lets a player in and op PlayerName makes an admin. If your jar is older than 26.3, also run whitelist on once; without it the list is ignored and anyone with the address can join.

• Leave memory for the system. -Xmx is only the Java heap. Paper's documentation suggests keeping it 1 to 1.5 GB below the server's memory, otherwise Linux kills the process when it runs out: about 1 GB of heap on a 2 GB plan, about 3 GB on a 4 GB plan, about 6 GB on an 8 GB plan.
• More memory does not fix lag. The game has 50 ms to compute each tick on one thread. If the server falls behind, lower simulation-distance and view-distance in server.properties before you buy more RAM.
• Modpacks have their own rules. Forge, NeoForge and Fabric packs often need an older Java version and 4 to 6 GB or more. Use the Java version the pack names.
• Bedrock players. Phones, tablets and consoles run Bedrock Edition. Either run Mojang's Bedrock Dedicated Server (officially supported on Ubuntu, 4 GB of memory) or add the Geyser and Floodgate plugins to a Paper server so both editions share one world. Both listen on 19132/udp by default, so also run ufw allow 19132/udp (the standalone Bedrock server additionally uses 19133/udp for IPv6). Phone, tablet and Windows players add the server by address; Xbox, PlayStation and Switch have no button for that, so console players need a workaround such as BedrockConnect.

Counter-Strike 2: mind the disk

CS2 no longer has a separate server download: the dedicated server is part of the game itself, app 730, and at the time of writing it occupies about 73 GB on disk, well above the 60 GB most guides still quote. That makes VDS Small, with 240 GB of NVMe, the sensible starting point. Two more things are required: a Game Server Login Token, created for app ID 730 on Steam's game server account management page, and a small symlink without which the server cannot find Steam's library.

# as root
ufw allow 27015/udp

# as the steam user
~/steamcmd/steamcmd.sh +force_install_dir /home/steam/cs2 +login anonymous +app_update 730 validate +quit
mkdir -p ~/.steam/sdk64
ln -sf ~/steamcmd/linux64/steamclient.so ~/.steam/sdk64/steamclient.so

cd ~/cs2/game
./cs2.sh -dedicated -console -usercon -port 27015 -maxplayers 10 \
  +game_type 0 +game_mode 1 +mapgroup mg_active +map de_dust2 \
  +sv_setsteamaccount YOUR_TOKEN

• Start it with cs2.sh -dedicated, not the cs2 binary directly. The script sets the library path; guides written before late 2025 skip it and fail.
• Game modes: competitive is game_type 0 with game_mode 1, casual is 0 and 0, deathmatch is 1 and 2. Settings such as the server name and rcon_password live in game/csgo/cfg/server.cfg (the folder is still called csgo).
• Update after every patch. Players on a newer build cannot join an older server. Stop the server, run the same SteamCMD line again and start it. Plugin frameworks (Metamod:Source, CounterStrikeSharp) need re-enabling after updates because the game overwrites gameinfo.gi.
• Restart daily. Memory use is around 1 to 1.5 GB with ten players but grows with uptime, especially with CSTV recording switched on. A scheduled nightly restart keeps it in check.
• Tick rate is not a setting any more: CS2 servers run 64 tick with sub-tick input.

Rust: memory first, then the wipe calendar

Rust is one of the two memory-hungry games here, alongside Palworld. Facepunch asks for 12 GB of free memory for a server, more for the largest maps, and usage climbs through the month as players build. The biggest lever is map size: the default server.worldsize is 4500, and a 3000 to 3500 map needs far less. On VDS Small (8 GB, below Facepunch's own figure) stay at a 3000 map or smaller with a handful of friends, for example +server.worldsize 3000 +server.maxplayers 10. That sizing comes from what Rust hosting providers publish, not from Facepunch, and it leaves little headroom, so watch memory as the month goes on. The command below (a 3500 map, 50 slots) is sized for VDS Medium, the comfortable choice.

# as root
ufw allow 28015/udp
ufw allow 28017/udp
ufw allow 28082/tcp
ufw allow from YOUR_HOME_IP to any port 28016 proto tcp

# as the steam user
~/steamcmd/steamcmd.sh +force_install_dir /home/steam/rust +login anonymous +app_update 258550 validate +quit

cd ~/rust
export LD_LIBRARY_PATH="$LD_LIBRARY_PATH:$(pwd):$(pwd)/RustDedicated_Data/Plugins/x86_64"
./RustDedicated -batchmode \
  +server.identity "main" \
  +server.port 28015 +server.queryport 28017 \
  +rcon.port 28016 +rcon.web 1 +rcon.password "LONG_RANDOM_PASSWORD" \
  +app.port 28082 \
  +server.level "Procedural Map" +server.worldsize 3500 +server.seed 12345 \
  +server.maxplayers 50 +server.hostname "My Rust Server" \
  -logfile /home/steam/rust/server.log

• Set all four ports explicitly. Left unset, the query, RCON and Rust+ ports are calculated from each other and end up on numbers most guides do not mention.
• Always set server.maxplayers and server.worldsize. The defaults (500 players, a 4500 map) are far too large for a small server.
• Forced wipe: Facepunch ships the monthly update on the first Thursday of each month at 19:00 London time. Update the server that evening or nobody can connect, and expect plugin frameworks (Oxide, Carbon) to need a matching update.
• Protect RCON. The Linux console is not interactive, so you administer the server over WebRCON. It is an unencrypted WebSocket: allow it only from your own address, as in the fourth firewall line.

Valheim: small, friendly and recently changed

Valheim is the lightest SteamCMD game here: 4 GB of memory is a comfortable start for the ten players a server allows, and the install is about 2 GB. Memory grows with the age and size of the world rather than with the player count. Version 1.0, released in September 2026, changed the save format: a world is now a folder of files instead of a single pair, so back up the whole save directory, and take a copy of any older world before you first start it on a 1.0 server.

# as root
apt install -y libatomic1 libpulse0 libpulse-dev
ufw allow 2456:2458/udp

# as the steam user
~/steamcmd/steamcmd.sh +force_install_dir /home/steam/valheim +login anonymous +app_update 896660 validate +quit
cd ~/valheim
cp start_server.sh start_custom.sh      # updates overwrite the original script
# in start_custom.sh, replace the line that starts with ./valheim_server.x86_64
# (near the end; leave the final "export LD_LIBRARY_PATH=..." line below it as it is) with:
# ./valheim_server.x86_64 -name "My server" -port 2456 -world "Midgard" -password "atLeast5chars" -public 1
./start_custom.sh                       # stop with Ctrl+C so the world is saved

• Password rules: at least five characters, and the password may not appear in the server name, or the server refuses to start properly.
• Crossplay costs latency. With -crossplay, all traffic is relayed through Microsoft's servers so that console players can join with a code. If everyone is on Steam, leave the flag out and let players connect directly to your address; the shipped example script includes it, so check.
• Stop it gently. Use Ctrl+C or a normal service stop, never kill -9, or everything since the last save (30 minutes by default) is lost.
• World location: ~/.config/unity3d/IronGate/Valheim, or wherever -savedir points.

Palworld: generous memory, careful configuration

Pocketpair's own requirements for a dedicated server are 16 GB of memory, with more than 32 GB recommended; 8 GB starts but the documentation warns it may crash when memory runs out. That puts Palworld on VDS Medium or VDS Large. The install is under 5 GB and needs only one UDP port.

# as root
ufw allow 8211/udp

# as the steam user
~/steamcmd/steamcmd.sh +force_install_dir /home/steam/palworld +login anonymous +app_update 2394010 validate +quit
mkdir -p ~/.steam/sdk64
ln -sf ~/steamcmd/linux64/steamclient.so ~/.steam/sdk64/steamclient.so

cd ~/palworld
./PalServer.sh -port=8211 -players=16      # first start creates the config folders; stop it with Ctrl+C
cp DefaultPalWorldSettings.ini Pal/Saved/Config/LinuxServer/PalWorldSettings.ini
# edit that copy with the server stopped: ServerName, ServerPassword, AdminPassword, ServerPlayerMaxNum
./PalServer.sh -port=8211 -players=16

• Edit the right file. Changes to DefaultPalWorldSettings.ini do nothing. The live file is the copy under Pal/Saved/Config/LinuxServer/, and that folder only exists after the first start.
• Console players on Xbox and PS5 can only join a community server, which means starting with -publiclobby. For a private Steam group, leave it out and share the address.
• Use the REST API, not RCON. RCON is deprecated and scheduled for removal. The REST API on port 8212 is meant for the server itself only; keep it and RCON closed in the firewall.
• Plan a daily restart. Several memory leaks were fixed up to version 1.0, but memory still tends to grow with uptime. Save, stop and start once a night.
• Do not copy old launch lines. The threading flags many guides add (-useperfthreads and friends) are no longer recommended by the developer since 1.0.

Running several servers: LinuxGSM, Docker or a panel

The commands above are the transparent way, good for understanding what happens. For day-to-day operation most admins pick one of three helpers:

• LinuxGSM is a free set of scripts with no web interface and almost no overhead. One Linux user and one script per server (mcserver, pmcserver, cs2server, rustserver, vhserver, pwserver) give you install, start, update, backup and a monitor command that restarts a crashed server. The best fit for one to five servers managed over SSH.
• Docker suits people who already run containers: itzg/minecraft-server, joedwards32/cs2, lloesche/valheim-server and thijsvanloef/palworld-server-docker are all actively maintained. Remember that ports published by Docker bypass ufw; our Docker guide explains the trap and the fix.
• Pterodactyl (and its fork Pelican) adds a web panel with user accounts, schedules and file access, each game server in its own container. It needs a real KVM machine, which every RS Computers plan is, and takes a gigabyte or two of memory for itself, so it pays off on VDS plans when several people manage several servers.

Keep it running: services, backups, updates

A server started in an SSH session dies with the session. Run it in tmux while testing, then hand it to systemd so it starts at boot and restarts after a crash. A unit for the Minecraft server above, saved as /etc/systemd/system/minecraft.service (use the same -Xms and -Xmx values you started the server with):

[Unit]
Description=Minecraft server (Paper)
After=network-online.target
Wants=network-online.target

[Service]
User=minecraft
WorkingDirectory=/opt/minecraft
ExecStart=/usr/bin/java -Xms3G -Xmx3G -jar server.jar --nogui
Restart=on-failure
RestartSec=10
SuccessExitStatus=0 143

[Install]
WantedBy=multi-user.target

# as root
systemctl daemon-reload
systemctl enable --now minecraft
journalctl -u minecraft -f

Under systemd the server has no console to type into; journalctl only shows its output. Add yourself with whitelist add and op while the server still runs in tmux. After that, any admin can type /whitelist add PlayerName in the in-game chat.

The same pattern works for the other games with their own user, folder and start command; for Valheim add KillSignal=SIGINT and a generous TimeoutStopSec so the save finishes.

• Back up the world yourself as well. The free weekly backup covers the whole server; a nightly archive of the world folder, copied off the server, covers the six days in between. Take it right after a save or with the server stopped.
• Update on patch day. All five games refuse clients on a different version. For the Steam games it is the same SteamCMD line you installed with.
• Schedule restarts for CS2 and Palworld at an hour when nobody plays, with a systemd timer or a cron job.
• Watch it from outside. A small monitor such as Uptime Kuma on a second server tells you the game is down before your players do.

Security checklist

• Open only the game ports from the table; keep RCON, WebRCON and REST API ports closed or limited to your own IP.
• Run every server as an unprivileged user, never as root.
• Use SSH keys for root and switch off password login.
• Set long random RCON and admin passwords; they are sent unencrypted by several of these games, another reason not to expose those ports.
• Keep online-mode=true on Minecraft and use a whitelist or password for private servers.
• Install plugins and mods only from their official pages, and update them together with the game.
• Keep the operating system patched with unattended-upgrades.

Frequently asked questions

Which location gives my players the lowest ping?

The one closest to most of them. Prishtina for Kosovo and the surrounding region, Amsterdam for a mixed European group, Dublin for Ireland and the UK. The plans page shows which locations currently have capacity.

Can I run more than one game on the same server?

Yes, as long as the memory adds up and each server has its own ports. Give each game its own Linux user, or use LinuxGSM, Docker or Pterodactyl to keep them apart. A Minecraft server with a 3 GB heap and a Valheim world for a small group fit together on VDS Small. Rust on a small map next to one light server calls for VDS Medium, and Palworld next to anything else calls for VDS Large, because Palworld alone is specified at 16 GB.

Do these game servers need Windows?

No. All five have native Linux servers, and Linux leaves more memory for the game. Windows Server is available on VPS Mini and all VDS plans if a mod or tool you depend on is Windows-only.

Can players connect over IPv6?

Every plan has both IPv4 and IPv6, but treat game servers as IPv4 services: Bedrock and Valheim listen on IPv6, while CS2, Rust and Palworld are IPv4 in practice. Give players the IPv4 address or a DNS name with an A record.

What happens when my community outgrows the plan?

Upgrade from the client area. vCPU, memory and disk are added to the same server with a short reboot, so save and stop the game server first and do it when nobody is playing. The world, configuration and IP address stay the same.

Can I install mods and plugins?

Yes, you have root access. Paper plugins and Forge, NeoForge or Fabric mods for Minecraft, Metamod and CounterStrikeSharp for CS2, Oxide or Carbon for Rust, BepInEx for Valheim. Expect them to need updates after every game patch.

Can RS Computers set the server up for me?

Yes. Message us on Telegram or email info@rscomputers-ks.com with the game, the number of players and where they are, and we will suggest a plan and quote the setup.

Conclusion

A good game server is three decisions: a location near the players, enough memory for the game you actually run, and a setup you can update and restore without drama. Minecraft and Valheim are happy on a small plan, CS2 needs disk more than anything, and Rust and Palworld want memory. Pick the nearest city on the plans page, start with the commands above, and invite your friends once the firewall shows the right ports. If you would rather have it handed over ready to play, tell us what you need.

← All articles