How to Install a Rust (Game) Dedicated Server on Ubuntu 24.04 VPS

Self-hosting your own Rust server gives you full control over the map, wipe schedule, modding stack, and player experience -- no monthly fees to a third-party game host, no shared-resource lag, and no arbitrary limits on plugins or slot counts. This tutorial walks you through installing a production-ready Rust dedicated server on an Ubuntu 24.04 LTS VPS using SteamCMD, then layering in Oxide/uMod for plugins, RCON administration, systemd auto-restart, scheduled wipes, and backups.

Note on naming: This guide is about Rust the survival game by Facepunch Studios (Steam AppID 258550) -- not the Rust programming language. If you landed here looking for the rustc compiler and cargo, this is not the guide you want. For the game, read on.

Skip the setup? Spin up a Rust-ready VPS in one click and follow along with plenty of headroom. Deploy a CloudCore Business VPS and be in-game before your coffee cools.

Table of Contents

What is a Rust Dedicated Server?

Rust is a multiplayer survival game where players spawn on a procedurally generated island, gather resources, build bases, and compete (or cooperate) with up to hundreds of other players per shard. The Rust Dedicated Server is the official headless Linux binary that hosts a world, accepts incoming connections, simulates entities, and enforces the game rules. Facepunch publishes it through Steam under AppID 258550, and it runs natively on Linux without Wine or Proton.

A typical Rust server consists of:

• The server binary (RustDedicated), which wraps the Unity-based game engine in headless mode.
• A procedurally generated map controlled by a numeric seed and a worldsize (meters squared). The same seed + size always produces the same map.
• The server identity directory (server/<identity>), which holds the world save, player data, config, and logs. Back this up, and you can move or restore the server in minutes.
• An RCON endpoint on a separate UDP/WebSocket port for remote administration from tools like RustAdmin or the official WebRcon browser client.
• Optional mods via Oxide/uMod, the de facto plugin framework that unlocks thousands of community plugins -- kits, economy, clan systems, anti-cheat helpers, map tooling, and more.

Why Self-Host Your Rust Server?

Managed Rust hosting is convenient, but it comes with real trade-offs. Self-hosting on a general-purpose VPS gives you:

• Full performance -- Dedicated cores and RAM, not oversold "game host" slots that throttle when your neighbor runs a 300-slot event.
• Unlimited slots and plugins -- No "per extra plugin" fees, no slot-gated pricing tiers. Your VPS limits are the hardware, not the billing plan.
• Unrestricted RCON and shell access -- Full root on the box means full control of systemd, firewall rules, backups, and monitoring -- things managed hosts often hide behind a web panel.
• Predictable flat pricing -- A single monthly VPS cost covers Rust plus any other workloads you want on the box (TeamSpeak, a Discord bot, a website, cron jobs).
• Mod flexibility -- Install Oxide/uMod, Carbon, custom harmony mods, or run vanilla -- your choice, no approval needed.
• Data ownership -- World saves, player data, and logs live on your server. You can back up, inspect, and migrate them freely.
• Portability -- The server identity folder is self-contained. Move from one VPS to another with rsync and zero downtime for returning players.

Prerequisites and Hardware Recommendations

Rust is RAM-hungry. The server loads the entire procedural map into memory, plus entities, player inventories, and network state. A 4000-size map with 100 players and mild modding can easily use 10-14 GB of RAM at peak. Plan accordingly.

Before you begin, make sure you have:

• A VPS running Ubuntu 24.04 LTS with root or sudo access
• SSH access (PuTTY on Windows, or the built-in terminal on macOS/Linux)
• At least 8 GB RAM for a small 50-slot server, 16 GB for 100+ slots or heavy modding
• 4+ CPU cores (Rust benefits from strong single-threaded performance -- pick a VPS with modern Intel or AMD EPYC cores)
• 80+ GB SSD/NVMe storage (the server binary plus map data is ~10 GB; logs and backups grow over time)
• A static public IPv4 address (required so players can connect and so the server can register with the Facepunch master list)

Recommended Plan: CloudCore Business

Rust is RAM-hungry, so we recommend our CloudCore Business plan as a comfortable starting point for a 50-100 slot server:

- 8 vCPU cores (modern AMD EPYC / Intel Xeon)

- 24 GB RAM

- 200 GB NVMe SSD

- Unmetered bandwidth

- Static IPv4

This gives you enough RAM for a 4000-size map with ~100 concurrent players, Oxide loaded with 20+ plugins, and room for backups and log rotation without hitting swap. For 200+ slot servers or 6000+ world sizes, size up to 32 GB or 64 GB of RAM.

Connect to your server:

ssh root@your-server-ip

Step 1: Update Ubuntu and Enable 32-bit Support

SteamCMD is distributed as a 32-bit binary, so Ubuntu 24.04 needs the i386 multiarch enabled. Start by refreshing the package index, upgrading installed packages, and installing the required libraries.

sudo dpkg --add-architecture i386
sudo apt update && sudo apt upgrade -y
sudo apt install -y curl wget ca-certificates lib32gcc-s1 lib32stdc++6 \
    libsdl2-2.0-0:i386 libcurl4-gnutls-dev:i386 \
    unzip tar screen ufw htop jq

Expected output (abbreviated):

0 upgraded, 13 newly installed, 0 to remove and 0 not upgraded.
Setting up lib32gcc-s1 (14.2.0-4ubuntu2) ...
Setting up libsdl2-2.0-0:i386 (2.30.0+dfsg-1ubuntu1) ...

If the kernel was upgraded, reboot once before continuing:

sudo reboot

Step 2: Create a Dedicated rustserver User

Running game servers as root is a bad habit. Create a dedicated unprivileged user so the Rust process, its files, and its systemd unit are isolated from the rest of the system.

sudo adduser --disabled-password --gecos "" rustserver
sudo mkdir -p /home/rustserver/{steamcmd,server}
sudo chown -R rustserver:rustserver /home/rustserver

Switch into the new user for the rest of the install:

sudo -iu rustserver

All subsequent commands in Steps 3 through 5 run as the rustserver user unless noted.

Step 3: Install SteamCMD

SteamCMD is Valve's official command-line tool for downloading and updating Steam game content, including dedicated servers. Install it into the user's home directory.

cd ~/steamcmd
wget -qO- https://steamcdn-a.akamaihd.net/client/installer/steamcmd_linux.tar.gz | tar zxf -

You should now see steamcmd.sh in the directory:

ls -la ~/steamcmd

Expected output:

-rwxr-xr-x 1 rustserver rustserver    7137 steamcmd.sh
-rw-r--r-- 1 rustserver rustserver   18594 linux32/steamcmd
...

Run SteamCMD once to let it self-update and bootstrap its directory structure, then exit:

./steamcmd.sh +quit

Expected output (first run):

Redirecting stderr to '/home/rustserver/Steam/logs/stderr.txt'
[  0%] Checking for available updates...
[----] Verifying installation...
Steam Console Client (c) Valve Corporation - version 1744330973

SteamCMD is now ready to download the Rust server files.

Step 4: Download the Rust Server with app_update 258550 validate

The Rust dedicated server lives under Steam AppID 258550. Pull it into ~/server with app_update and the validate flag so any corrupt or partial files are re-downloaded.

~/steamcmd/steamcmd.sh \
    +force_install_dir /home/rustserver/server \
    +login anonymous \
    +app_update 258550 validate \
    +quit

Expected output (abbreviated):

Logging in user 'anonymous' to Steam Public...OK
 Update state (0x3) reconfiguring, progress: 0.00 (0 / 0)
 Update state (0x61) downloading, progress: 1.23 (123456789 / 10000000000)
 ...
 Update state (0x61) downloading, progress: 100.00 (10000000000 / 10000000000)
Success! App '258550' fully installed.

The download is approximately 9-11 GB and takes 5-20 minutes depending on VPS bandwidth.

Pro tip: Save the update command as a script so you can rerun it after every Facepunch patch (forced updates happen on the first Thursday of each month, a.k.a. "forced wipe"):

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

Run ~/update-rust.sh any time you need to update.

Step 5: Configure server.cfg and Launch Arguments

Rust's configuration has two layers: launch arguments passed on the command line (host/port, world size, max players, tickrate) and server.cfg, a file of runtime commands the server reads on startup (MOTD messages, bans, convar overrides).

Create the Server Identity Directory

The identity is the name of the subfolder under server/ that holds this server's world save, config, and logs. Pick a short slug -- for example myrust.

mkdir -p ~/server/server/myrust/cfg

Create server.cfg

nano ~/server/server/myrust/cfg/server.cfg

Paste in a sensible starter config:

# Identity & display
server.hostname "My Rust Server | Weekly Wipe | Modded"
server.description "Friendly community. Weekly wipes Thursdays 8pm UTC. Discord: discord.gg/example"
server.url "https://example.com"
server.headerimage "https://example.com/rust-header-1024x512.jpg"
Gameplay tuning
server.pve false
server.saveinterval 300
server.tickrate 30
Chat & decay
decay.scale 1.0
craft.instant false
Friendly fire off, voice chat on
server.radiation true

• server.hostname -- The name shown in the Rust server browser. Keep it under 100 characters.
• server.description -- Multi-line description shown on the server info panel. Escape newlines with \n if needed.
• server.url -- A website players can visit for rules, Discord invites, or shop.
• server.headerimage -- A 1024x512 PNG/JPG banner shown in the info panel. Host it anywhere publicly reachable over HTTPS.
• server.saveinterval 300 -- Autosave every 300 seconds (5 minutes).
• server.tickrate 30 -- Target 30 ticks per second. Higher values cost more CPU; 30 is the standard.

Create the Launch Script

Now create the actual script that starts the server. This is where the launch arguments live.

nano ~/start-rust.sh

Paste:

#!/usr/bin/env bash
cd /home/rustserver/server
RCON credentials -- change this to a long random string
RCON_PASSWORD="REPLACE_WITH_A_LONG_RANDOM_STRING"
exec ./RustDedicated -batchmode -nographics \
    +server.identity "myrust" \
    +server.port 28015 \
    +server.queryport 28017 \
    +server.maxplayers 100 \
    +server.worldsize 4000 \
    +server.seed 1337 \
    +server.tickrate 30 \
    +server.hostname "My Rust Server | Weekly Wipe | Modded" \
    +server.description "Friendly community. Weekly wipes Thursdays 8pm UTC." \
    +server.url "https://example.com" \
    +server.headerimage "https://example.com/rust-header-1024x512.jpg" \
    +server.saveinterval 300 \
    +rcon.port 28016 \
    +rcon.password "$RCON_PASSWORD" \
    +rcon.web 1 \
    +app.port 28082

Explanation of each flag:

• -batchmode -nographics -- Run headlessly without a graphical window (mandatory on a VPS).
• +server.identity myrust -- Uses server/myrust/ as the world save directory. Must match the folder you created above.
• +server.port 28015 -- UDP port players connect to. This is the Rust default.
• +server.queryport 28017 -- UDP port Steam uses to query server status for the in-game browser.
• +server.maxplayers 100 -- Hard cap on concurrent players. Scale to your RAM.
• +server.worldsize 4000 -- Map size in meters. Common values: 3000 (small), 3500 (medium), 4000 (standard), 4500 (large), 6000 (huge, very RAM-heavy).
• +server.seed 1337 -- Numeric seed. The same seed + worldsize always generates the same map. Pick a fresh seed each wipe to avoid players memorizing monument layouts.
• +server.tickrate 30 -- Simulation tick rate.
• +rcon.port 28016 -- TCP/WebSocket port for RCON.
• +rcon.password -- RCON password. Use a long random string. Anyone with this password has full server admin.
• +rcon.web 1 -- Enables the WebSocket-based WebRcon protocol (required for Facepunch's browser WebRcon client and for Oxide admin tools).
• +app.port 28082 -- The companion app relay port (for the mobile Rust+ app). Safe to leave enabled.

chmod +x ~/start-rust.sh

Generate a Strong RCON Password

openssl rand -base64 32

Copy the output and paste it in place of REPLACE_WITH_A_LONG_RANDOM_STRING in start-rust.sh. Never commit this file to git.

Step 6: Open the Firewall (UDP 28015 and RCON 28016)

Rust uses UDP for the main game traffic and Steam queries, and TCP for RCON. Configure UFW to allow exactly those ports.

Exit back to your sudo user:

exit

Then:

sudo ufw allow 22/tcp comment 'SSH'
sudo ufw allow 28015/udp comment 'Rust game'
sudo ufw allow 28017/udp comment 'Rust Steam query'
sudo ufw allow 28016/tcp comment 'Rust RCON'
sudo ufw allow 28082/udp comment 'Rust+ companion app'
sudo ufw enable
sudo ufw status numbered

Expected output:

Status: active
     To                         Action      From
     --                         ------      ----
[ 1] 22/tcp                     ALLOW IN    Anywhere
[ 2] 28015/udp                  ALLOW IN    Anywhere
[ 3] 28017/udp                  ALLOW IN    Anywhere
[ 4] 28016/tcp                  ALLOW IN    Anywhere
[ 5] 28082/udp                  ALLOW IN    Anywhere

Security note: RCON on port 28016 is exposed to the internet after this step. The RCON password is your only line of defense. Use a long random password, and consider restricting RCON by source IP if you administer from a static location:

sudo ufw delete allow 28016/tcp
sudo ufw allow from YOUR.ADMIN.IP.HERE to any port 28016 proto tcp

Step 7: Create a systemd Service for Auto-Restart

A systemd unit makes the Rust server start on boot, restart on crash, and stream logs into journalctl for easy inspection.

As root or sudo:

sudo nano /etc/systemd/system/rust-myrust.service

Paste:

[Unit]
Description=Rust Dedicated Server (myrust)
After=network-online.target
Wants=network-online.target
[Service]
Type=simple
User=rustserver
Group=rustserver
WorkingDirectory=/home/rustserver/server
ExecStart=/home/rustserver/start-rust.sh
Restart=on-failure
RestartSec=15
TimeoutStopSec=60
LimitNOFILE=65536
KillSignal=SIGINT
Hardening
NoNewPrivileges=true
ProtectSystem=full
ProtectHome=false
PrivateTmp=true
[Install]
WantedBy=multi-user.target

Reload systemd, enable on boot, and start the server:

sudo systemctl daemon-reload
sudo systemctl enable rust-myrust
sudo systemctl start rust-myrust

Watch the live logs while Rust loads the world (this can take 2-5 minutes on first boot while the map is generated):

sudo journalctl -u rust-myrust -f

Expected output (abbreviated):

Loading Prefab Bundle ' ' (0)
Loaded Prefab Bundle 'content/' (96%)
Generating procedural map...
Server startup complete

Once you see Server startup complete, your server is live on your-server-ip:28015.

Step 8: Install Oxide/uMod for Plugins

Oxide/uMod is the plugin framework that ~90% of modded Rust servers use. It intercepts game events via hooks and lets you drop-in .cs plugin files to change behavior -- kits, economy, warp points, automated events, and much more.

Stop the server before installing:

sudo systemctl stop rust-myrust

Switch back to the rustserver user:

sudo -iu rustserver
cd ~/server

Download the latest Oxide Linux build:

wget -q https://umod.org/games/rust/download/develop -O Oxide.Rust-linux.zip
unzip -o Oxide.Rust-linux.zip
rm Oxide.Rust-linux.zip

The extraction overlays new files into RustDedicated_Data/Managed/ and creates an oxide/ directory. Confirm it worked:

ls oxide/

Expected output:

config  data  lang  logs  plugins

Start the server again:

exit   # back to sudo user
sudo systemctl start rust-myrust
sudo journalctl -u rust-myrust -f

You should see:

Loaded extension Unity v2.0.xxxx by Oxide Team
Oxide.Rust v2.0.xxxx is loaded.

Install Your First Plugins

Plugins are single .cs files dropped into /home/rustserver/server/oxide/plugins/. Oxide hot-loads them automatically -- no restart needed.

Two highly recommended starter plugins:

sudo -iu rustserver
cd ~/server/oxide/plugins
Kits -- give players starter loadouts
wget -q https://umod.org/plugins/kits.cs
Clans -- add clan/team support
wget -q https://umod.org/plugins/clans.cs

Browse the full catalog at umod.org/plugins. Always check a plugin is compatible with the current Rust build before installing.

Step 9: Connect via WebRcon and Administer the Server

RCON (Remote Console) is how you run admin commands, kick/ban players, say messages, and read live logs. Because we set +rcon.web 1, the server speaks the WebSocket WebRcon protocol.

Using Facepunch's Browser WebRcon

You should see live server logs stream in. Try a few commands in the input box:

say "Hello from RCON!"
serverinfo
users
playerlist
ownerid 76561198000000000 "AdminName" "Head admin"

Useful reference commands:

• say "<message>" -- Broadcast a chat message as SERVER.
• kick <steamid> "<reason>" -- Kick a player.
• banid <steamid> "<name>" "<reason>" -- Permanent ban by SteamID64.
• ownerid <steamid> -- Grant full admin (persists across wipes in cfg/users.cfg).
• moderatorid <steamid> -- Grant moderator permissions.
• save -- Force an immediate world save.
• restart 300 "Scheduled restart" -- Initiate a countdown restart.
• server.writecfg -- Persist live convar changes to server.cfg.

Using RustAdmin (Desktop Client)

RustAdmin is a free Windows admin tool with a much richer UI than the browser WebRcon. It supports chat moderation, player search, scheduled messages, and bulk commands. Point it at your-server-ip:28016 with the same RCON password.

Step 10: Schedule Wipes (Weekly/Bi-Weekly/Monthly)

A wipe regenerates the world map and optionally clears player data. Facepunch force-wipes the protocol on the first Thursday of each month, which requires every server to regenerate its map and update. Most community servers also run weekly or bi-weekly map wipes in between.

Types of Wipes

• Map wipe -- Delete the procedural map files. Players keep blueprints and progress.
• BP (blueprint) wipe -- Delete players' unlocked blueprints. Typically done monthly with the forced wipe.
• Full wipe -- Map + BPs + player data. Fresh start for everyone.

Wipe Script

Create a wipe script that stops the server, deletes the relevant files, optionally rotates the seed, updates, and restarts:

sudo nano /home/rustserver/wipe.sh

Paste:

#!/usr/bin/env bash
set -euo pipefail
IDENTITY="myrust"
SERVER_DIR="/home/rustserver/server/server/${IDENTITY}"
WIPE_BPS="${1:-no}"   # pass "bp" as first arg to also wipe blueprints
echo "[wipe] Stopping Rust service..."
sudo systemctl stop rust-myrust
echo "[wipe] Removing map files..."
rm -f "${SERVER_DIR}"/*.map \
      "${SERVER_DIR}"/*.sav \
      "${SERVER_DIR}"/.sav. \
      "${SERVER_DIR}"/player.deaths.* \
      "${SERVER_DIR}"/player.tokens.* \
      "${SERVER_DIR}"/player.states.* \
      "${SERVER_DIR}"/player.identities.*
if [[ "${WIPE_BPS}" == "bp" ]]; then
  echo "[wipe] Removing blueprints..."
  rm -f "${SERVER_DIR}"/player.blueprints.*
fi
echo "[wipe] Rotating seed..."
NEW_SEED=$(( (RANDOM * RANDOM) % 2147483647 ))
sed -i "s/+server.seed [0-9]*/+server.seed ${NEW_SEED}/" /home/rustserver/start-rust.sh
echo "[wipe] New seed: ${NEW_SEED}"
echo "[wipe] Running SteamCMD update..."
sudo -u rustserver /home/rustserver/update-rust.sh
echo "[wipe] Starting Rust service..."
sudo systemctl start rust-myrust
echo "[wipe] Done."

Make it executable:

sudo chmod +x /home/rustserver/wipe.sh

Run a map-only wipe manually:

sudo /home/rustserver/wipe.sh

Run a full BP wipe (typically on forced-wipe Thursday):

sudo /home/rustserver/wipe.sh bp

Automate with Cron

Schedule weekly map wipes every Thursday at 20:00 UTC:

sudo crontab -e

Add:

# Weekly map wipe -- Thursday 20:00 UTC
0 20   4 /home/rustserver/wipe.sh >> /var/log/rust-wipe.log 2>&1
Forced wipe -- first Thursday of the month, BPs included
0 19 1-7 * 4 /home/rustserver/wipe.sh bp >> /var/log/rust-wipe.log 2>&1

Announce upcoming wipes in-game via RCON say and on your community Discord at least 24 hours in advance.

Step 11: Back Up the Server Identity and Saves

The server/myrust/ directory contains your map, player data, bans, and Oxide config. Back it up before every wipe (and regularly during the wipe cycle) so you can recover from corruption, accidental deletes, or a VPS failure.

Daily Backup Script

sudo nano /home/rustserver/backup.sh

Paste:

#!/usr/bin/env bash
set -euo pipefail
IDENTITY="myrust"
SRC="/home/rustserver/server/server/${IDENTITY}"
DEST="/home/rustserver/backups"
STAMP=$(date +%Y%m%d-%H%M%S)
mkdir -p "${DEST}"
Force a save via RCON before backing up
(requires websocat or a small python helper; skip if you accept ~5min save skew)
tar czf "${DEST}/rust-${IDENTITY}-${STAMP}.tar.gz" -C "/home/rustserver/server/server" "${IDENTITY}"
Retain the last 14 backups
ls -1t "${DEST}"/rust-${IDENTITY}-*.tar.gz | tail -n +15 | xargs -r rm --
echo "[backup] Created ${DEST}/rust-${IDENTITY}-${STAMP}.tar.gz"

Make it executable and schedule it nightly at 04:00:

sudo chmod +x /home/rustserver/backup.sh
sudo chown rustserver:rustserver /home/rustserver/backup.sh
sudo -u rustserver crontab -e

Add:

0 4   * /home/rustserver/backup.sh >> /home/rustserver/backups/backup.log 2>&1

For true off-site safety, push the tarballs to S3, Backblaze B2, or a second VPS via rclone or rsync. Local backups protect against mistakes; off-site backups protect against hardware failure.

Troubleshooting

Useful Log Locations

• systemd journal: sudo journalctl -u rust-myrust -f
• Oxide plugin log: /home/rustserver/server/oxide/logs/oxide_<date>.txt
• Rust server log: /home/rustserver/server/server/myrust/Log.Log
• Wipe/backup cron: /var/log/rust-wipe.log, /home/rustserver/backups/backup.log

FAQ

Is this guide for Rust the game or Rust the programming language?

This guide is for Rust, the survival game by Facepunch Studios -- the multiplayer game you can buy on Steam (AppID 258550). It is not about the Rust programming language (rustc, cargo, crates.io). The two projects share a name but are unrelated. If you came here to install the compiler, look up rustup instead.

How much RAM do I actually need?

Rough rule of thumb: budget ~3-4 GB of RAM for the server binary baseline, plus ~80-100 MB per concurrent player, plus 1-3 GB for a typical Oxide plugin set. A 100-slot modded server with a 4000 worldsize usually sits at 10-14 GB in use. Add headroom for the OS, swap, and spikes during save events. 16 GB is the comfortable minimum for a serious community server, 24 GB is the sweet spot for most, and 32+ GB only becomes necessary at 200+ slots or 5000+ worldsize.

Can I run multiple Rust servers on one VPS?

Yes. Each instance needs its own identity, its own ports (e.g. 28015/16/17 for server one, 28025/26/27 for server two), its own systemd unit, and its own start-rust.sh. Make sure total RAM usage across all instances fits in physical memory -- Rust handles swap poorly and will stutter badly if it starts paging.

What is the difference between Oxide/uMod and Carbon?

Oxide/uMod is the long-standing plugin framework with the largest plugin catalog and the most community documentation. Carbon is a newer, performance-focused alternative that is API-compatible with most Oxide plugins but uses Harmony patching for faster hook execution. For a first server, Oxide is the safer choice -- more plugins "just work" and there is more help available when something breaks. Consider Carbon later if you hit performance ceilings on a large modded server.

How do I change the map seed without wiping?

You can't. The seed + worldsize pair deterministically generates the map when the server boots with an empty identity directory. Once a .map file exists, the server reuses it regardless of the seed argument. To get a new map you must delete the .map and .sav files (a wipe), which is exactly what wipe.sh does.

Where can I find official documentation?

The canonical technical reference for Rust's server commands, convars, and hooks is Facepunch's wiki at wiki.facepunch.com/rust/. It covers every server convar, admin command, and gameplay variable. For plugins and modding hooks, umod.org is the authoritative source.

Next Steps

Now that your Rust server is running, here are practical next steps:

• Tune performance with Oxide plugins -- Install NoEntityLimit, PerformanceTracker, and a server FPS monitor to spot bottlenecks before players complain.
• Set up a Discord webhook -- Plugins like DiscordLogger pipe chat, joins, kills, and raid alerts into a Discord channel.
• Configure scheduled messages -- Use ServerMessages or the built-in RCON say cronjob to run rules, wipe reminders, and Discord invites every 30-60 minutes.
• Host other game servers on the same VPS -- If you have headroom, add a Counter-Strike 2 server, an ARK server, or a Palworld server alongside Rust. Each needs its own ports and user.
• Monitor with Uptime Kuma -- Deploy Uptime Kuma and add a UDP check on port 28015 plus a TCP check on 28016 so you get alerted the moment something goes down.
• Grow your community -- List your server on best-servers.com, rust-servers.net, and rusttracker.com. A well-run server with consistent wipes and responsive admins fills up fast.

Skip the Manual Install -- Deploy a Rust-Ready VPS

Our CloudCore Business VPS gives you the cores, RAM, and NVMe headroom that Rust demands -- without the oversold "game host" throttling.

- 8 vCPU cores + 24 GB RAM (comfortable for 100 slots + Oxide)

- 200 GB NVMe SSD for maps, backups, and logs

- Unmetered bandwidth, static IPv4

- Full root access -- install Oxide, Carbon, custom harmony mods, anything

- Deploy in under 60 seconds, follow this guide, be wiping by the weekend

Launch Your Rust VPS and start hosting.