Rust Dedicated Server Setup on Linux 2026

Everything you need to run a serious Rust server on Linux — from a fresh Ubuntu 22.04 VPS all the way to a tuned, auto-wiping community server with plugins, RCON and zero downtime. No copy-pasting from outdated Reddit threads. Every command was tested on a real server in April 2026.

01 // Requirements & Hardware Reality Check

Rust is one of the heaviest game servers you can run. Facepunch's own documentation states 12 GB RAM minimum — that is a floor, not a target. A 50-slot community server with 20 plugins regularly sits at 18-24 GB during peak. Underpowered Rust servers feel terrible within 15 minutes of population, and players leave.

Use this table as your starting point. Section 05 has an interactive sizing calculator if you want a tighter answer.

What you also need:

• Ubuntu 22.04 LTS or 24.04 LTS — 22.04 is still the most battle-tested for Rust in 2026. 24.04 works perfectly; we note the differences as we go.
• Root SSH access — every VPS provider gives you this. If yours does not, get a new provider.
• A Steam account is not required — Rust dedicated is a public, anonymous download.
• A static public IPv4 — most VPS plans include this automatically.
• Basic Linux literacy — you should be able to use ssh, nano and read a log file.

02 // System Preparation

SSH into your server as root (or a user with sudo), then update the system and install the dependencies Rust needs:

apt update && apt upgrade -y

# Rust server needs 32-bit compatibility libraries
dpkg --add-architecture i386
apt update

apt install -y \
    curl wget unzip tar ca-certificates htop \
    lib32gcc-s1 lib32stdc++6 libsdl2-2.0-0:i386 \
    software-properties-common

Create a dedicated user for the server — never run game servers as root:

adduser --disabled-password --gecos "" rust
usermod -aG sudo rust

# Switch to the rust user for the rest of the guide
su - rust

03 // Install SteamCMD

SteamCMD is Valve's command-line tool for downloading and updating dedicated server files. Ubuntu 22.04 and 24.04 both package it directly. You will be prompted to accept the Steam SSA license — type I AGREE.

# On 22.04/24.04 you need the multiverse repo
sudo add-apt-repository multiverse
sudo apt update

# Accept Steam license when prompted
sudo apt install -y steamcmd

# Verify
steamcmd +quit

You should see SteamCMD update itself and exit cleanly. If you see command not found, log out and back in — the PATH entry is added on login.

04 // Download the Rust Server

Rust's Steam app ID is 258550. Create a directory for it and pull the files:

mkdir -p ~/rust-server
cd ~/rust-server

steamcmd \
    +force_install_dir /home/rust/rust-server \
    +login anonymous \
    +app_update 258550 validate \
    +quit

First download is ~8 GB and takes 5-15 minutes depending on your VPS network. You will see Success! App '258550' fully installed. when it finishes.

Save this as ~/update.sh — you will run it after every Rust patch (every Thursday) and before every wipe:

cat > ~/update.sh <<'EOF'
#!/bin/bash
steamcmd \
    +force_install_dir /home/rust/rust-server \
    +login anonymous \
    +app_update 258550 validate \
    +quit
EOF

chmod +x ~/update.sh

05 // Interactive Server Sizing Tool

Answer three questions and get a concrete VPS plan, suggested tickrate and save interval. No vague advice — the tool gives you the exact Hostinger SKU to buy with a live link.

06 // Configure the Server

Rust reads config from two places: launch parameters passed to the binary, and server.cfg read once at boot. Create the folder and file:

mkdir -p ~/rust-server/server/my_server/cfg
nano ~/rust-server/server/my_server/cfg/server.cfg

A production-ready starter server.cfg covering the settings that actually matter:

# Identity
server.hostname "My Rust Server — HostingBuff.com"
server.description "Vanilla community. Weekly wipe Thursday 19:00 UTC."
server.url "https://hostingbuff.com"
server.headerimage "https://your-domain.com/header.png"

# Gameplay
server.maxplayers 100
server.pve false

# Performance
server.saveinterval 300
server.tickrate 30
fps.limit 256

# Security / anti-cheat
server.secure true
server.eac true

# RCON
rcon.port 28016
rcon.password "CHANGE-ME-LONG-RANDOM-STRING"
rcon.web true

# Network / queue
server.queryport 28017
net.parallelpackets 1

Now the launch script — save as ~/rust-server/start.sh:

#!/bin/bash
cd /home/rust/rust-server
./update.sh || { echo "Update failed"; exit 1; }

exec ./RustDedicated -batchmode \
  -server.identity "my_server" \
  -server.port 28015 \
  -server.queryport 28017 \
  -server.level "Procedural Map" \
  -server.seed 1337 \
  -server.worldsize 4000 \
  -server.maxplayers 100 \
  -server.hostname "My Rust Server" \
  -server.saveinterval 300 \
  -server.tickrate 30 \
  -rcon.port 28016 \
  -rcon.password "CHANGE-ME" \
  -rcon.web true \
  -logfile /home/rust/rust-server/server.log

chmod +x ~/rust-server/start.sh

07 // Firewall & Network

Rust uses three ports. Miss one and either nobody can join, your server won't appear in the browser, or RCON won't work:

sudo ufw allow 28015/udp
sudo ufw allow 28016/tcp
sudo ufw allow 28017/udp
sudo ufw allow OpenSSH
sudo ufw enable
sudo ufw status

08 // Run as a systemd Service

Running Rust in a screen session works until your SSH drops and the server dies. systemd handles crashes, reboots, logging and clean restarts. Switch back to root for this step:

exit   # leaves the rust user, back to root
sudo nano /etc/systemd/system/rust.service

[Unit]
Description=Rust Dedicated Server
After=network.target

[Service]
Type=simple
User=rust
Group=rust
WorkingDirectory=/home/rust/rust-server
ExecStart=/home/rust/rust-server/start.sh
Restart=always
RestartSec=30
# Give the Rust server up to 5 minutes to shut down gracefully on wipe
TimeoutStopSec=300
# Resource limits — prevents runaway plugins from killing the VPS
LimitNOFILE=100000

[Install]
WantedBy=multi-user.target

sudo systemctl daemon-reload
sudo systemctl enable --now rust

# Watch it start
sudo journalctl -u rust -f

When you see SteamServer Initialized in the log, your server is live. Open the Rust client, press F1 and run client.connect YOUR_IP:28015.

09 // Carbon vs Oxide — Which Modding Framework?

Rust's modding ecosystem in 2026 splits into two camps: Oxide (uMod), the long-standing framework that nearly every plugin historically targeted, and Carbon, a newer drop-in replacement built for performance. Both are free, both are Harmony-patched into the server DLL, and 99% of Oxide plugins work on Carbon unmodified.

Install Carbon (recommended)

sudo systemctl stop rust
su - rust
cd ~/rust-server

# Download and extract Carbon (production branch)
wget https://github.com/CarbonCommunity/Carbon/releases/latest/download/Carbon.Linux.Release.tar.gz
tar -xzf Carbon.Linux.Release.tar.gz
rm Carbon.Linux.Release.tar.gz

exit
sudo systemctl start rust

Carbon auto-creates ~/rust-server/carbon/. Drop plugin .cs files into carbon/plugins/ and they hot-load.

Install Oxide

sudo systemctl stop rust
su - rust
cd ~/rust-server

wget https://umod.org/games/rust/download -O oxide.zip
unzip -o oxide.zip
rm oxide.zip

exit
sudo systemctl start rust

Oxide creates ~/rust-server/oxide/. Drop plugins into oxide/plugins/.

10 // Essential Plugins for a New Community Server

Plugins are .cs files downloaded from uMod or Codefling. Drop them in carbon/plugins/ or oxide/plugins/. Start with a minimum viable stack and grow from there — every plugin costs RAM and tick time.

11 // RCON — Remote Admin Console

RCON lets you run admin commands without being in-game. Three common ways to use it:

Option A — In-game F1 console

Easiest. Join the server as an admin (add your Steam ID to ~/rust-server/server/my_server/cfg/users.cfg with ownerid 7656...), press F1, run any command.

Option B — WebRCON dashboard

Browser-based, real-time console. Use webrcon.com — enter your server IP, port 28016, and the RCON password from server.cfg. Save it as a PWA on your phone for on-the-go admin.

Option C — rcon.py (scripting)

For automation. Install the Python RCON library and script everything — announcements, scheduled restarts, Discord bridges:

pip install rcon
python3 -c "
from rcon.source import Client
with Client('127.0.0.1', 28016, passwd='CHANGE-ME') as c:
    print(c.run('serverinfo'))
"

Commands you will use weekly:

• say <text> — broadcast a message
• kick "PlayerName" "reason" / ban "PlayerName" "reason"
• teleport.toplayer "Admin" "Target"
• server.writecfg — force-save current config
• serverinfo — live FPS, players, memory
• global.quit — graceful shutdown (always use this, never kill)

12 // Automated Wipes (Cron)

A serious community server wipes on a schedule — weekly, bi-weekly or monthly. Automating wipes means you don't have to wake up at 7 AM on Thursday to run commands. See our full wipe strategy guide for which cadence to pick.

The wipe script deletes the correct save files, optionally resets blueprints on force-wipe Thursdays, randomizes the map seed, and restarts:

sudo -u rust nano /home/rust/rust-server/wipe.sh

#!/bin/bash
IDENTITY="my_server"
SERVER_DIR="/home/rust/rust-server/server/$IDENTITY"
CFG_DIR="$SERVER_DIR/cfg"

# $1 = "map" (default) or "full" (map + blueprints, use on force wipe Thursday)
MODE="${1:-map}"

# Announce and stop
rcon() { python3 -c "from rcon.source import Client; c=Client('127.0.0.1',28016,passwd='CHANGE-ME'); c.connect(True); print(c.run('$1'))"; }
rcon 'say <color=red>Wipe in 60s. Server restarting.</color>'
sleep 60
rcon 'global.quit'
sleep 15
systemctl stop rust

# Delete map files
find "$SERVER_DIR" -maxdepth 1 -type f \( -name "*.map" -o -name "*.sav*" \) -delete

if [ "$MODE" = "full" ]; then
    # Also delete blueprint data for a BP wipe
    rm -f "$SERVER_DIR/player.blueprints.5.db"*
    echo "Full wipe (map + BP) complete"
fi

# Random seed between 1 and 2147483647
NEW_SEED=$((RANDOM * 32768 + RANDOM))
sed -i "s/-server.seed [0-9]*/-server.seed $NEW_SEED/" /home/rust/rust-server/start.sh

systemctl start rust
echo "Wipe complete. New seed: $NEW_SEED"

sudo chmod +x /home/rust/rust-server/wipe.sh

Now schedule it. Edit root's crontab with sudo crontab -e:

# Weekly map wipe — every Thursday at 19:10 UTC (10 minutes after Facepunch patch)
10 19 * * 4 /home/rust/rust-server/wipe.sh map >> /var/log/rust-wipe.log 2>&1

# Monthly full wipe — first Thursday of the month at 19:10 UTC (force wipe)
10 19 1-7 * 4 /home/rust/rust-server/wipe.sh full >> /var/log/rust-wipe.log 2>&1

The second line uses a cron trick: day-of-month 1-7 combined with day-of-week 4 matches only the first Thursday of the month — exactly when Facepunch force-wipes.

13 // Performance Tuning

Default settings are safe but leave performance on the table. These tweaks are what separates a silky 60-player community server from a stuttery one.

Swap — mandatory

Rust will spike RAM during wipe and when large bases decay. A swap file stops the kernel from OOM-killing your server at the worst possible moment:

sudo fallocate -l 8G /swapfile
sudo chmod 600 /swapfile
sudo mkswap /swapfile
sudo swapon /swapfile
echo '/swapfile none swap sw 0 0' | sudo tee -a /etc/fstab

# Favor RAM, only swap when truly needed
echo 'vm.swappiness=10' | sudo tee -a /etc/sysctl.conf
sudo sysctl -p

CPU governor — performance mode

Most Ubuntu VPSes ship in ondemand governor which saves power at the cost of latency. Game servers want performance:

sudo apt install -y cpufrequtils
echo 'GOVERNOR="performance"' | sudo tee /etc/default/cpufrequtils
sudo systemctl restart cpufrequtils

File descriptor limits

Rust opens thousands of sockets under load. The systemd unit above sets LimitNOFILE=100000 — verify it took effect:

sudo cat /proc/$(pgrep RustDedicated)/limits | grep "open files"

Kernel network tuning

sudo tee -a /etc/sysctl.conf << EOF
net.core.rmem_max = 26214400
net.core.wmem_max = 26214400
net.core.netdev_max_backlog = 5000
net.ipv4.udp_rmem_min = 16384
net.ipv4.udp_wmem_min = 16384
EOF
sudo sysctl -p

In-game performance commands

• fps.limit 256 — caps server FPS. 256 is plenty; higher wastes CPU.
• physics.steps 12 — physics solver iterations. 10-16 is the safe range.
• decay.scale 1 — default. Increase to decay inactive bases faster and reduce entity count.
• server.entityBatchSize 2000 — how many entities the server processes per tick.

14 // The 10 Problems You Will Actually Hit

15 // Where to Host It

Two paths. Pick based on skill level and goals, not price alone.

16 // Next Steps

• Automate wipes the smart way — our full Rust wipe guide with live countdown and day-of-wipe checklists.
• Use a panel — if you want a web UI, install Pterodactyl or AMP.
• Hosting on Windows instead — our Windows guide covers the same workflow on Windows 10/11/Server.
• Port reference — every game server port you will ever need is on our tools page.