Rust Dedicated Server Setup: Complete 2026 Guide

Running your own Rust dedicated server in 2026 gives you full control. You set the rules, choose the mods, and decide who plays. 

A Rust dedicated server is standalone server software that runs a Rust world 24/7 on a PC, VPS, or dedicated machine. It’s not tied to your personal gameplay. 

That means better uptime, more control, and fewer limits than player-hosted sessions.

You’ll learn how to install files, configure settings, open ports, fix errors, and boost performance. 

You’ll also learn how to protect the server, add plugins, and manage wipes. Everything you need to host and run a Rust server, clearly explained and up to date.

Key Takeaways

• A Rust dedicated server gives you full control over maps, mods, wipes, rules, and player slots.
• Rust Dedicated Server uses SteamCMD App ID 258550 for installation and updates.
• Open UDP 28015 for gameplay and a separate UDP query port for server browser visibility.
• Use TCP 28016 for RCON only if remote admin access is needed.
• Rust server performance depends most on single-core CPU speed, RAM, storage, and entity load.
• NVMe storage helps with faster saves, backups, restarts, and late-wipe stability.
• Linux is usually preferred for long-running Rust servers because it is lighter and easier to automate.
• A 3000–4500 world size works well for many active Rust communities.
• uMod/Oxide lets you add Rust plugins for kits, shops, teleport, clans, UI, and admin tools.
• Upgrade to dedicated Rust server hosting when players, plugins, custom maps, or lag become hard to manage.
• RedSwitches gives Rust communities high-clock CPUs, NVMe storage, DDoS protection, and full root access.

Rust Dedicated Server Requirements in 2026

Rust server performance mainly depends on high single-core CPU speed, enough RAM for entities and plugins, fast NVMe storage, and stable upload bandwidth.

Core count helps with background tasks, but Rust’s game logic leans hard on one main thread. For most Rust servers, a modern high-clock CPU often performs better than a low-clock many-core CPU, especially when player count and entity simulation stress the main game thread.

Below is a practical breakdown of Rust dedicated server requirements for 2026.

Minimum Requirements 

This tier is fine for learning or for small vanilla servers.

• CPU: 4 cores, 3.0 GHz+
  • Intel i5 / Ryzen 5 class
• RAM: 10–12 GB dedicated to Rust
  • 16 GB total system RAM recommended
• Storage: 40–50 GB SSD
  • Enough for server files and basic world saves
• Network: 20–50 Mbps upload
  • Supports ~10–20 players

This setup can run a small Procedural Map. It may lag during raids, large bases, or plugin use.

Recommended Requirements 

Best fit for long-term worlds and active communities.

• CPU: 6–8 cores, 4.0–4.5 GHz+
  • Intel i7 / Ryzen 7 or better
• RAM: 16–24 GB dedicated to Rust
• Storage: 100–200 GB NVMe
  • Covers backups, plugins, logs, and growth
• Network: 100–250 Mbps upload
  • Matches typical 50–100 player bandwidth needs

This tier gives Rust more room to handle combat, monuments, AI, and plugins with fewer performance spikes.

High-Performance Requirements 

Choose this when you run heavy plugins, large maps, multiple events, or several servers.

• CPU: 6–12 cores, 4.5–5.0 GHz+
  • Intel i9-12900K / 13900K / 14900K
  • Ryzen 9 5950X / 7950X / 9950X
• RAM: 32–48 GB dedicated to Rust (64 GB for extreme modding)
• Storage: 250–500 GB NVMe (Gen4 preferred)
  • Supports large saves, multiple backups, and heavy logging
• Network: 500 Mbps – 1 Gbps upload
  • Needed for 100+ players or multi-server clusters

This hardware gives Rust more headroom for high entity counts, custom maps, and raid-heavy servers, but plugin quality and entity cleanup still matter.

What Matters Most for Rust Performance

• Single-Thread CPU Speed: This is one of the most important factors. Rust leans heavily on main-thread performance. Modern high-clock CPUs usually offer the largest gains.
• RAM Headroom: Rust grows heavier as the map fills. Under-provisioned RAM is a common cause of late-wipe crashes, especially on plugin-heavy or entity-heavy servers.
• NVMe Storage: World saves, backups, logs, and plugin data grow fast. NVMe cuts load times and reduces stutter on large worlds.
• Upload Bandwidth: Plan generous upload capacity per active player, then monitor real usage under load. Upload speed is often the real limit, not download.

How to Download Rust Dedicated Server Files with SteamCMD

Here is how to download Rust dedicated server files with SteamCMD.

Create Your Folder Structure

Keep SteamCMD and your Rust server files in separate folders so updates are easier to manage.

Windows

C:\steamcmd

C:\rustserver

Linux

/home/rust/steamcmd

/home/rust/rustserver

• steamcmd → holds SteamCMD only
• rustserver → holds Rust dedicated server files

This avoids file mix-ups and makes updates simpler.

Install SteamCMD

Windows Installation

• Download SteamCMD
• Extract the contents into:
  C:\steamcmd
• Run steamcmd.exe.

On first run, SteamCMD will download and apply updates. This usually takes a few minutes, depending on your connection and system speed.

When it’s done, you’ll see a prompt like:

Steam>

Linux Installation

From your non-root user (e.g., rust):

• Download the Linux package:

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

• Extract it:

tar -xvzf steamcmd_linux.tar.gz

rm steamcmd_linux.tar.gz

chmod +x steamcmd.sh

• Install required 32-bit libraries.
• Ubuntu / Debian

sudo dpkg –add-architecture i386

sudo apt update

sudo apt install -y \

  lib32gcc-s1 \

  lib32stdc++6 \

  libc6-i386

• CentOS / RHEL

sudo yum install -y \

glibc.i686 \

libstdc++.i686

• Run SteamCMD:

./steamcmd.sh

• On first run, it will update itself, then show:

Steam>

• Type quit to exit.

What each command does:

• force_install_dir → tells SteamCMD where to install the server.
• login anonymous → Rust server files are public; no Steam account needed.
• app_update 258550 → downloads the Rust dedicated server (App ID 258550).
• validate → verifies file integrity and fixes corrupted downloads.
• quit → closes SteamCMD.

Note on validate:

• Always use it for first install and after errors/crashes.
• Optional for routine updates to save time.
• Recommended after forced wipes or major patches.

Disk space:

Rust server files can take several GB and may grow over time. Keep at least 30–50 GB free for files, logs, saves, updates, and backups.

Downloading Staging or Prerelease Branches (Advanced)

If you need early or experimental Rust builds:

• Staging Branch – weekly experimental updates

app_update 258550 -beta staging validate

• Prerelease Branch – upcoming major changes, often unstable

app_update 258550 -beta prerelease validate

Recommendation:

• Beginners should stick to the default stable branch.
• Use staging/prerelease only if you know you need them.

Understanding the Rust Server Folder Structure

After your first successful server boot, Rust will create its own internal folders.

Root Directory (C:\rustserver or /home/rust/rustserver)

Typical layout:

RustDedicated.exe        (Windows executable)

RustDedicated            (Linux binary)

RustDedicated_Data/      (core game files)

cfg/                     (global config templates)

logs/                    (console logs after first run)

server/                  (created after first launch)

Identity Folder (After First Launch)

When you start your server with an identity, for example:

+server.identity “server1”

Rust creates:

server/server1/

├── cfg/                        # Server-specific configs (server.cfg, etc.)

├── storage/                    # Entity and object persistence (folder)

├── UserPersistence.db          # Player progression and unlocks

├── sv.files.0.db               # Internal server file tracking

├── player.blueprints.5.db      # Player blueprint data

├── player.deaths.5.db          # Death history

├── player.identities.5.db      # Player identity mapping

├── player.states.5.db          # Player state data

└── proceduralmap.[seed].[size].[version].map  # World save file

This identity folder is what you back up before wipes and major updates.

Updating the Rust Server

Rust updates frequently. Updating is the same process as installation.

Always stop the server first. Updating while the server is running can cause file conflicts, failed updates, or possible world-save issues.

Windows

force_install_dir C:\rustserver

login anonymous

app_update 258550 validate

quit

Linux

force_install_dir /home/rust/rustserver

login anonymous

app_update 258550 validate

quit

Use validate for major updates or after errors. For quick patch days when you’re confident your disk is healthy, you can skip validate to speed things up.

Common SteamCMD Errors and Fixes

Here are the common SteamCMD errors and fixes. 

Permission Denied (Linux)

Cause: Running SteamCMD or Rust as root, or wrong folder ownership.

Fix:

sudo adduser rust         # Debian/Ubuntu (interactive, sets password)

# OR, universal:

# sudo useradd -m -s /bin/bash rust

# sudo passwd rust

sudo chown -R rust:rust /home/rust/steamcmd

sudo chown -R rust:rust /home/rust/rustserver

su – rust

cd /home/rust/steamcmd

./steamcmd.sh

Always run game servers as a limited user, not root.

Missing 32-bit Libraries (Linux)

If you see errors about 32-bit libraries:

Ubuntu / Debian

sudo apt install -y \

  lib32gcc-s1 \

  lib32stdc++6 \

  libc6-i386

CentOS / RHEL

sudo yum install -y \

  glibc.i686 \

  libstdc++.i686

Re-run SteamCMD afterward.

Corrupted or Stalled Downloads

If downloads stall or files seem broken:

Windows

Delete:

C:\steamcmd\steamapps\downloading\

Linux

Delete:

rm -rf ~/steamcmd/steamapps/downloading/

Then rerun:

app_update 258550 validate

Network Timeouts / Slow Downloads

Steps to troubleshoot:

• Check Steam’s status: https://steamstat.us/
• Temporarily review or relax firewall rules only while testing, then restore secure rules immediately.
• Check your router logs for drops/throttling.
• Re-run SteamCMD to let it auto-update.
• On VPS/dedicated, confirm your host isn’t blocking Steam CDN IP ranges.

DNS changes rarely help SteamCMD performance. You can skip that common “tweak.”

Windows Firewall Pop-Up

The first time you run RustDedicated.exe, Windows may ask for network access.

Tell users to:

• Click Allow access.
• Enable both Private and Public networks.

If you deny this, external players may not be able to connect (we’ll configure firewall more fully in the installation section).

Expected Download Time

Rust server files can take several GB, and SteamCMD also validates and decompresses files.

More realistic expectations:

• Fast (100+ Mbps): 15–25 minutes
• Average (25–50 Mbps): 45–90 minutes
• Slow (<10 Mbps): 2–4+ hours

SteamCMD may appear stuck at 0% or on certain steps for a few minutes. This can be normal while it’s verifying or unpacking.

Antivirus Conflicts (Windows)

Some antivirus tools may flag new .exe files.

Recommended steps:

• Add C:\rustserver as an exclusion.
• If Defender flags RustDedicated.exe, use Allow on device.
• Don’t permanently disable antivirus; keep exclusions targeted.

Install and Run Rust Server on Windows (SteamCMD)

Here is how to run a Rust server on Windows.

Confirm Folder Layout & Files

You should already have:

C:\steamcmd      # SteamCMD installed here

C:\rustserver    # Rust server files installed here

If C:\rustserver is empty or missing, go back to the Download section and complete the SteamCMD steps.

Create a Startup Batch File

Inside C:\rustserver, create:

start_server.bat

Paste:

@echo off

:start

echo Updating Rust server…

C:\steamcmd\steamcmd.exe +login anonymous +force_install_dir C:\rustserver +app_update 258550 +quit

echo Starting Rust server…

cd /d C:\rustserver

RustDedicated.exe -batchmode -nographics ^

+server.port 28015 ^

+server.queryport 28017 ^

+rcon.port 28016 ^

+rcon.password “YourStrongPasswordHere” ^

+server.level “Procedural Map” ^

+server.seed 12345 ^

+server.worldsize 3500 ^

+server.maxplayers 50 ^

+server.hostname “My Rust Server” ^

+server.description “A simple Rust server for testing.” ^

+server.identity “server1”

echo Server stopped. Restarting in 10 seconds…

echo Press CTRL+C to cancel restart.

timeout /t 10

goto start

What this script does:

• Updates the server before each start (without validate to save time).
• Sets the working directory correctly (cd /d C:\rustserver).
• Runs in a loop and auto-restarts after crashes (10-second delay).
• Lets you break the loop with CTRL+C.

For a fresh install or after major issues, run SteamCMD once manually with validate as shown in the download section, then rely on the script for routine restarts.

Secure Your RCON Password

 RCON Security Warning

• Use a strong password (12+ characters, mixed case, numbers, symbols).
• Never share start_server.bat publicly with +rcon.password visible.

For better security, move the password into server.cfg.

Important: The server/server1/cfg/ folder does not exist until after the first server launch.

Recommended Method (safer):

• Keep +rcon.password in start_server.bat for the first launch only.
• Run the server once and let it run for ~30–60 seconds.
• Stop the server (CTRL+C).

Now create:

C:\rustserver\server\server1\cfg\server.cfg

Add:

rcon.password “YourStrongPasswordHere”

• Remove +rcon.password “YourStrongPasswordHere” from start_server.bat.
• Restart the server.

Advanced Method (manual folder creation):

You can pre-create:

C:\rustserver\server\server1\cfg\

Before first boot, then create server.cfg directly. Just ensure the path matches your +server.identity.

Windows Firewall Configuration

When you first run RustDedicated.exe, Windows may show a Firewall prompt.

• Click Allow access
• Check Private and Public networks

If the prompt never appears or you clicked the wrong option:

• Open Windows Defender Firewall.
• Click Allow an app through Windows Defender Firewall.
• Click Allow another app…

Browse to:

C:\rustserver\RustDedicated.exe

• Add it and enable Private and Public.

Rust uses:

• Game port: 28015/UDP
• Query port: 28017/UDP if set with +server.queryport 28017
• RCON port: 28016/TCP if enabled

First Boot and World Generation (Windows)

Double-click:

start_server.bat

On first boot, world generation may take 5–15 minutes. During this process, you’ll see log lines like:

• Spawning World
• Processing monuments…
• Instantiating world decoration…
• Bootstrap Finish
• Server startup complete

Do not close the window while these are running.

You can also:

• Check Task Manager for RustDedicated.exe.

Look for console logs in:

C:\rustserver\server\server1\console_YYYY-MM-DD.log

When you see Server startup complete, the world is ready.

Connect to Your Windows Server

From the same PC:

client.connect localhost:28015

From another PC on the same LAN:

client.connect 192.168.1.X:28015

Replace X with your server PC’s local IP.

From the internet (after port forwarding):

client.connect YOUR.PUBLIC.IP:28015

Optional: Run as a Windows Service (Auto-Start on Boot)

For a more “fire-and-forget” setup, you can use NSSM (Non-Sucking Service Manager).

• Download NSSM
• Extract it and open Command Prompt as Administrator.

Install the service:

nssm.exe install RustServer

• In the GUI:
  • Application Path: C:\rustserver\start_server.bat
  • Save.

Start the service:

nssm.exe start RustServer

Manage it:

nssm.exe stop RustServer      # Stop

nssm.exe restart RustServer   # Restart

nssm.exe remove RustServer    # Remove service

Install & Run Rust Server on Linux (Ubuntu / Debian / CentOS / RHEL)

Linux is usually preferred for long-running game servers because it supports cleaner automation, service management, and lower background overhead.

Create a Dedicated User

Do not run Rust as root.

Universal approach:

sudo useradd -m -s /bin/bash rust

sudo passwd rust

 On Debian/Ubuntu you can also use:

sudo adduser rust

adduser is interactive and will ask for a password during creation. With useradd, you must run passwd afterwards to set one.

Create folders and assign ownership:

sudo mkdir -p /home/rust/steamcmd

sudo mkdir -p /home/rust/rustserver

sudo chown -R rust:rust /home/rust

Switch to the rust user:

su – rust

SteamCMD installation and download steps were already covered earlier. At this point, you should have the server files in /home/rust/rustserver.

Create a Startup Script on Linux

From the rust user:

cd /home/rust/rustserver

nano start.sh

Paste:

#!/usr/bin/env bash

set -e

echo “Updating Rust server…”

/home/rust/steamcmd/steamcmd.sh +login anonymous +force_install_dir /home/rust/rustserver +app_update 258550 +quit

echo “Starting Rust server…”

cd /home/rust/rustserver

./RustDedicated -batchmode -nographics \

+server.port 28015 \

+server.queryport 28017 \

+rcon.port 28016 \

+rcon.password “YourStrongPasswordHere” \

+server.level “Procedural Map” \

+server.seed 12345 \

+server.worldsize 3500 \

+server.maxplayers 50 \

+server.hostname “My Rust Linux Server” \

+server.description “Rust server running on Linux.” \

+server.identity “server1”

Make it executable:

chmod +x start.sh

More Secure RCON Config (Linux)

As with Windows, we don’t want to keep the RCON password in the startup script forever.

Remember: server/server1/cfg/ appears after the first successful boot.

Recommended flow:

1. Start the server once with +rcon.password in start.sh.
2. Let it run 30–60 seconds.
3. Stop it (CTRL+C if running directly, or via systemd if configured).

Create the config folder if needed:

mkdir -p /home/rust/rustserver/server/server1/cfg

Create and edit:

nano /home/rust/rustserver/server/server1/cfg/server.cfg

Add:

rcon.password “YourStrongPasswordHere”

Secure the file: chmod 640 /home/rust/rustserver/server/server1/cfg/server.cfg

sudo chown rust:rust /home/rust/rustserver/server/server1/cfg/server.cfg

      Remove +rcon.password from start.sh.

Run the Server with screen or tmux

Using screen

cd /home/rust/rustserver

screen -S rust -L -Logfile ~/rust-server.log ./start.sh

• Detach: CTRL + A, then D
• List: screen -ls
• Reattach: screen -r rust or screen -r <ID>.rust
• Force reattach: screen -rd rust

Using tmux

cd /home/rust/rustserver

tmux new -s rust ./start.sh

• Detach: CTRL + B, then D
• Reattach: tmux attach -t rust

If the server crashes, the session may exit; just rerun the same command.

Optional: systemd Service (Linux Auto-Start)

For a fully managed service, create:

sudo nano /etc/systemd/system/rustserver.service

Paste:

[Unit]

Description=Rust Dedicated Server

After=network.target

[Service]

Type=simple

User=rust

Group=rust

WorkingDirectory=/home/rust/rustserver

ExecStart=/home/rust/rustserver/start.sh

Restart=on-failure

RestartSec=10

KillSignal=SIGTERM

KillMode=mixed

StandardOutput=journal

StandardError=journal

[Install]

WantedBy=multi-user.target

Enable and start:

sudo systemctl daemon-reload

sudo systemctl enable rustserver

sudo systemctl start rustserver

Manage it:

sudo systemctl status rustserver      # Status

sudo systemctl stop rustserver        # Stop

sudo systemctl restart rustserver     # Restart

sudo systemctl disable rustserver     # Disable on boot

sudo journalctl -u rustserver -f      # Live logs

sudo journalctl -u rustserver -n 100  # Last 100 lines

Linux Firewall Configuration

If you skip this, players often cannot connect.

Ubuntu / Debian (ufw)

sudo ufw allow 28015/udp comment ‘Rust Game Port’

sudo ufw allow 28017/udp comment ‘Rust Query Port’

sudo ufw allow 28016/tcp comment ‘Rust RCON Port’

sudo ufw reload

CentOS / RHEL (firewalld)

sudo firewall-cmd –permanent –add-port=28015/udp

sudo firewall-cmd –permanent –add-port=28017/udp

sudo firewall-cmd –permanent –add-port=28016/tcp

sudo firewall-cmd –reload

First Boot and Verification on Linux

First boot may take 5–15 minutes while the world generates.

Check:

sudo systemctl status rustserver        # If using systemd

ps aux | grep RustDedicated             # Process running

ss -tulpn | grep 28015                  # Port listening on 28015

Logs:

Console logs:

/home/rust/rustserver/server/server1/console_YYYY-MM-DD.log

With systemd:

sudo journalctl -u rustserver

Look for:

Server startup complete

Changing Server Settings After Install

To change name, max players, description:

• Edit start_server.bat or start.sh.
• Adjust +server.hostname, +server.maxplayers, +server.description.
• Restart the server.

To change world seed, size, or level:

1. Stop the server.
2. Back up or delete: server/server1/ (this wipes the world)
3. Adjust +server.seed, +server.worldsize, +server.level in your startup script.
4. Start the server and let the new world generate.

Connect to Your Linux Server

From the same machine:

client.connect localhost:28015

From another device on the same LAN:

client.connect 192.168.1.X:28015

From the internet (with ports opened):

client.connect YOUR.PUBLIC.IP:28015

Rust Server Ports, Query Port, RCON & Firewall Rules

If your Rust server runs but players can’t join, the cause is almost always ports or firewall rules.
Here are the exact ports to open, how to forward them, and how to diagnose real network blockers.

Required Rust Ports, Protocols, and Use Cases

A basic Rust server needs the game UDP port for direct play, a separate UDP query port for browser visibility, TCP RCON if remote admin is enabled, and a TCP Rust+ companion port if Rust+ is enabled.

Game Port (Main Connection)

28015/UDP

Handles world data, player movement, combat, entities, and networking. If this port is blocked, players time out or fail to connect.

RCON Port (Remote Admin)

Recommended:

• Set RCON explicitly → +rcon.port 28016/TCP
• Do not rely on defaults or reuse the query port.

Open this only if you use RustAdmin, rcon.io, BattleMetrics, or remote commands, and restrict access to trusted admin IPs where possible.

Query Port (Server Browser Visibility)

Defaults:

• With server.port 28015 and rcon.port 28016, the query port often resolves to 28017/UDP. The safer option is to set it explicitly with +server.queryport 28017.
• Custom: Set explicitly with +server.queryport 28017

If this port is blocked:

• Direct connect works.
• Browser listing does NOT work.

Steam Backend Ports

Do not forward Steam client ports. The ranges below do not apply to Rust servers:

27000–27050  

27015  

27020

Rust registers with Steam using outbound traffic only. No inbound Steam ports needed.

How to Forward Ports (Home Hosting)

If you host at home, forward these ports to your server’s LAN IP:

28015 → UDP  

28017 → UDP  

28016 → TCP  (optional, only if using RCON)

Your server IP will look like:

192.168.1.x

10.0.0.x

Forwarding will break if your server’s LAN IP changes. So assign a static local IP.

Setting a Static Local IP 

Here is how to set a static local IP.

Method 1: DHCP Reservation 

• Find your server’s IP:
  • Windows: ipconfig
  • Linux: ip a
• Note the network adapter’s MAC address.
• Log in to your router (192.168.1.1 or 192.168.0.1).
• Open DHCP Reservation or Address Reservation.
• Add:
  MAC Address → Fixed IP (e.g., 192.168.1.100)
• Save → reboot router.

Method 2: Static IP on Windows

Control Panel → Network Connections → Adapter → IPv4 → set manual IP, gateway, DNS.

Method 3: Static IP on Linux

Edit Netplan (Ubuntu):
/etc/netplan/*.yaml
Assign a fixed address inside your LAN range.

Operating System Firewall Rules

Windows Firewall

New-NetFirewallRule -DisplayName “Rust Game” -Direction Inbound -Protocol UDP -LocalPort 28015 -Action Allow

New-NetFirewallRule -DisplayName “Rust RCON” -Direction Inbound -Protocol TCP -LocalPort 28016 -Action Allow

New-NetFirewallRule -DisplayName “Rust Query” -Direction Inbound -Protocol UDP -LocalPort 28017 -Action Allow

Ubuntu / Debian

sudo ufw allow 28015/udp

sudo ufw allow 28016/tcp

sudo ufw allow 28017/udp

sudo ufw reload

CentOS / RHEL

sudo firewall-cmd –permanent –add-port=28015/udp

sudo firewall-cmd –permanent –add-port=28016/tcp

sudo firewall-cmd –permanent –add-port=28017/udp

sudo firewall-cmd –reload

Cloud/VPS Firewall Panels (Often Missed)

Most cloud providers block ports at the network layer.

AWS EC2 Security Group

Add:

• UDP 28015
• UDP 28017
• TCP 28016 (if RCON)

Azure NSG

Add inbound rules for:

• UDP: 28015, 28017
• TCP: 28016

Google Cloud

VPC → Firewall:

• UDP: 28015, 28017
• TCP: 28016

VPS Providers 

Open the same ports in their firewall panel.

Detecting CGNAT (The #1 Reason Home Hosting Fails)

Your ISP shares one public IP across many customers. Port forwarding becomes impossible. To detect CGNAT; 

• Check the router’s WAN IP.
• Check public IP at whatismyip.com.
• If they don’t match, you’re behind CGNAT.

Fixes

• Ask ISP for a public IPv4 address
• Use ZeroTier / Tailscale for private servers
• Use a dedicated server / VPS for public servers

Detecting Double NAT

Run:

Windows

tracert 8.8.8.8

Linux

traceroute 8.8.8.8

If you see two private IPs (192.168.x.x, 10.x.x.x, or 100.x.x.x) before the public hop → Double NAT.

Fix:

• Put ISP router in bridge mode
• Or port-forward on both routers
• Or merge networks

Wi-Fi Hosting Warning

• Avoid hosting Rust on Wi-Fi. It can cause jitter, packet loss, lag spikes, and disconnects.
• Use Ethernet whenever possible.

Testing Ports Properly

UDP cannot be scanned like TCP.

For TCP checks such as RCON, online port tools can help. For UDP game and query ports, verify through the Rust client, server browser, provider firewall logs, or Steam query tools.

Linux/Mac

echo “test” | nc -u -w1 YOUR.IP 28015

Note: UDP checks can be unreliable. Confirm Rust connectivity through the client, server browser, or provider firewall logs.

Most Reliable Method

Use a Rust client, server browser checks, provider firewall logs, or Steam query tools from outside your network.

Rust RCON Setup, Administration & Essential Commands

RCON lets you control your Rust dedicated server from any device. You can manage players, save the world, restart safely, and monitor performance without logging into the game. 

How RCON Works

RCON opens a remote admin console port on your server. Any RCON client can connect using the port and password you set. Once connected, you can run commands that update the server in real time.

You will use RCON for:

• Player kicks, bans, promotions
• Saving the world
• Restarting or shutting down safely
• Changing admin roles
• Checking performance issues
• Managing wipes

RCON Setup

Add these to your startup command:

+rcon.port 28016

+rcon.password “STRONG_PASSWORD”

+rcon.web 1

What they mean:

• rcon.port → Port your RCON tool connects to
• rcon.password → Password for authentication
• rcon.web 1 → Enables WebSocket RCON for browser-based tools

Open the RCON port:

sudo ufw allow 28016/tcp

RCON Security Best Practices

Strong RCON security protects your server from unauthorized admin access. Restrict RCON access to your admin IP through your firewall or provider security group.

Change RCON Password Any Time

rcon.password “NewPass123”

server.writecfg

Disable RCON when not needed

Remove:

+rcon.port

+rcon.password

+rcon.web

Store RCON passwords in a protected config file only if your startup or server workflow actually loads that file. Do not leave passwords in public scripts, screenshots, or shared folders.

In-Game Console vs RCON

In-game console (F1):

• Requires an owner/mod role
• Some shortcuts available
• Names may work without quotes

RCON clients:

• Always authenticated
• Full command names required
• Names with spaces need quotes

Rust Admin Role Levels

• Owner (Level 2)      → Full access
• Moderator (Level 1)  → Limited access
• Developer (Level 3) → Advanced debug access; avoid using it unless you know exactly why it is needed

Check your auth level:

auth

Where Admin Roles Are Stored

server/identity/cfg/users.cfg

Save role changes: server.writecfg

Note: Current Rust servers may save some role changes automatically, but running server.writecfg remains a safe manual habit after admin changes.

Essential Admin Commands

Use these essential admin commands to manage players, saves, restarts, wipes, plugins, and server performance.

Installing uMod (Oxide) Plugins for a Modded Rust Server

uMod (Oxide) lets you turn a plain Rust server into a custom one. It adds permissions, hooks, plugin support, and a full modding framework. If you want teleportation, shops, clans, kits, custom UI, permissions, or many admin tools, you usually need uMod.

How to Install uMod (Oxide)

Install or reapply uMod after Rust server updates when the update overwrites patched files or when Oxide/uMod stops loading.

• Download the latest build
  • Go to uMod’s official site and download the Rust build.
  • Prefer the stable build for production servers unless you specifically need a newer nightly version.
•  Extract the ZIP
  •  Inside you’ll see /RustDedicated_Data replacements and new folders.
• Copy files into your Rust server directory
  •  Overwrite when asked. This applies the uMod/Oxide server framework files required for plugin loading.
• Start your server
  •  A successful install prints:

[Oxide] Loading plugins…

If you don’t see this message, uMod didn’t install.

The Oxide Folder Structure

After installation, you’ll see these folders inside your Rust server directory:

oxide/

  plugins/          ← All .cs plugins go here

  config/           ← Auto-generated plugin config files

  data/             ← Saved plugin data, player stats, shop data

  logs/             ← Plugin errors, hook failures, crash reports

  lang/             ← Language files

• plugins/
  You drop .cs files here. Rust loads them on startup or reload.
• config/
  Every plugin creates a JSON config file the first time it runs.
  This is where you set prices, cooldowns, messages, limits, etc.
• data/
  Stores persistent data.
  Delete with caution, you can wipe clan lists, shop inventories, teleport home lists, etc.
• logs/
  Your best friend during plugin debugging. Broken plugin? Start here.

How Plugin Reloads Work

uMod supports live reloads without restarting the server.

oxide.reload PluginName

oxide.unload PluginName

oxide.load PluginName

Reload triggers:

• Code recompile
• Config load
• Data file read

If a plugin throws errors or fails to compile, it shows in /oxide/logs.

Advanced Tips to Keep Your Modded Rust Server Stable

• Avoid 30+ plugins unless you know how they interact
• Don’t reload memory-heavy plugins too often
• Always check /oxide/logs after Rust updates
• Use GitHub forks when original plugins are abandoned
• Avoid plugins with constant OnTick hooks
• Consider splitting features across multiple lightweight plugins

Optimizing Rust Server Performance, FPS & Entity Load

A fast Rust server depends on clean world data, strong single-core CPU speed, and controlled entity growth. Use this as your tuning guide.

Tickrate, Server FPS & Entity Load

Rust admins commonly track server FPS, frame time, memory, and entity count to judge performance.

• Server FPS target: 50–60 FPS when possible
• Frame time target: lower is better, with spikes worth investigating
• Entity count target: depends on map size, plugins, wipe length, and hardware

What it means:

• 50–60 FPS → smooth
• 30–40 FPS → delay starts
• < 20 FPS → rubberbanding

Tools:

status          # FPS, memory, players

perf            # frame time, GC data

entity.report   # entity breakdown

global.objects  # active objects

Entity Guidelines

Not all entities cost the same.

• Low cost: trees, rocks, static props
• Medium: boxes, furnaces, bags, doors
• High: turrets, electric networks, vehicles, AI

Practical admin rule of thumb:

• < 100k → usually easier to manage
• 100k–150k → monitor closely
• 150k–200k → lag risk increases
• 200k+ → high risk on many setups

Clean often: dropped items, abandoned bags, empty furnaces, decayed bases.

Choosing the Right World Size

World size affects CPU load, memory use, save time, map generation, travel distance, and monument density.

Modern ranges:

• 10–50 players: 2500–3500
• 50–150 players: 3500–4000
• 150–300 players: 4000–4500
• 5000: only with high-end hardware

World gen time rises fast:

• 3000: ~2–4 min
• 4000: ~5–8 min
• 5000: ~10–20 min

Pick optimized custom maps and keep fresh entity counts as low as practical for your player count and wipe length.

Save Interval Tuning

Many Rust servers use a 600-second save interval by default or by common configuration.

server.saveinterval 600   # 10 min

server.saveinterval 900   # lighter load

server.saveinterval 300   # less rollback

Saves can create short freezes, especially on larger maps or slower storage.

Larger maps take longer. Watch console:

[Saved] World saved (took XXXXms)

Manual save:

server.save

Do this before restarts or config changes. Avoid save spam and avoid manual saves during peak combat when possible.

Plugin Performance Management

Plugin count doesn’t matter, plugin cost does.

• Low impact: chat, kits, simple UI
• Medium: TP, economy, clans
• High: zone managers, anti-cheat, event systems, heavy scanners

Test plugins:

1. Run perf baseline
2. Add plugins one by one
3. Investigate or remove plugins that add noticeable frame-time spikes

Reload tools:

oxide.reload Plugin

oxide.unload Plugin

oxide.load Plugin

Hardware Tuning

Rust rewards single-thread speed and fast storage.

Strong CPU examples for Rust hosting:

• Ryzen 7 7800X3D
• Ryzen 9 7950X3D
• Ryzen 9 7950X / 5950X
• Intel i9-12900K / 12900KS
• Intel i9-13900K / 13900KS

Avoid low-clock server CPUs and budget CPUs for high-pop Rust servers unless you have tested them under real player and entity load.

• Storage: NVMe strongly recommended for faster saves, backups, and restarts
• RAM: 16 GB minimum, 32 GB for modded servers
• Network: low jitter, minimal packet loss, and wired Ethernet for self-hosted setups

Testing:

ping -n 100 IP      # Windows

ping -c 100 IP      # Linux/Mac

Advanced Tuning

Disable heavy events (if needed)

bradley.enabled false

cargoship.enabled false

heli.enabled false

ch47.enabled false

Add them in startup for consistency.

Decay settings

decay.scale 2.0     # faster cleanup

decay.scale 3.0     # very fast

decay.scale 1.0     # default

decay.upkeep true

Higher decay.scale values speed up decay, which can reduce abandoned structures but may change the player experience.

Garbage Collection (GC)

Garbage collection can cause brief spikes. 

Monitor it:

perf

gc.collect

Reduce GC pressure by:

• keeping entity count low
• trimming heavy plugins
• avoiding plugins with OnTick/OnFrame hooks

Advanced:

Test +gc.buffer 4096 carefully before using it on a live server.

Custom Map Optimization

Rust already compresses saves. To improve custom map performance, reduce:

• clutter objects
• extra prefabs
• monument density
• tree/rock density

Always test new maps with entity.report.

When Should You Upgrade to a Dedicated Server?

A home PC or VPS can work for small private groups. It can struggle once your world grows, plugins stack up, or player counts rise. Rust is heavy on CPU time, disk writes, and entity counts. Once these limits show, a dedicated server becomes the next logical step.

Upgrade when you hit any of these points:

RedSwitches gives your Rust world dedicated hardware built for smoother performance under load.

You get strong single-core CPUs, NVMe storage, and low-latency networking that help keep server FPS steadier during peak raids.

DDoS protection and global locations help reduce attack-related downtime and give players cleaner regional routes.

Full root access and custom configs give you the control needed to tune heavy plugins, big maps, and larger populations.

This setup removes many common limits of home hosting and shared VPS environments while giving your server stronger long-term stability.

FAQs

Q. How do I host my own Rust dedicated server in 2026?

Download SteamCMD → install Rust server files → create a startup script → open required ports → launch the RustDedicated binary.

Basic install commands:

force_install_dir /rustserver

login anonymous

app_update 258550 validate

quit

Then run your startup script with your map seed, identity, ports, and player slots.

Q. What hardware do I need for a smooth Rust server?

Rust needs fast single-core CPU, NVMe storage, and enough RAM.

• Small groups: 8–12 GB RAM, SSD or NVMe, modern 3+ GHz CPU.
• 50–100 players/modded: 16–24 GB RAM, NVMe, 4+ GHz CPU.
• 100+ players/custom maps: 32–48 GB RAM, modern high-clock CPU, and NVMe strongly recommended.

CPU clock speed and modern single-core performance usually matter more than raw core count.

Q. Why isn’t my Rust server showing in the community list?

Most common reasons:

• Game or query ports not forwarded correctly
• Firewall blocks inbound traffic.
• Router forwards TCP only, not UDP.
• Startup script uses different ports than the router.
• Server isn’t listening on the port (netstat confirms this).

Fix those, confirm the query port is open, and the server should appear after a short delay.

Q. What ports do I need to open for Rust?

Open these on router + OS firewall:

• 28015 UDP, game traffic
• 28017 UDP, query traffic if set with +server.queryport 28017
• 28016 TCP, RCON if enabled
• Rust+ TCP companion port, if Rust+ is enabled.

All ports must match your startup script, and the game port and query port must be separate. Rust+ also needs a reachable TCP companion port if you enable Rust+ mobile app pairing. With common default ports, this is often 28082, but you should confirm your companion server setting before opening it.

Q. How do I install a Rust server with SteamCMD?

• Install SteamCMD.
• Run:

force_install_dir /rustserver

login anonymous

app_update 258550 validate

quit

• Create a startup script that runs RustDedicated.
• Open ports.
• Start the server.

That’s the complete installation flow.

Q. Is Linux better than Windows for hosting Rust?

Usually, yes.

Linux is often preferred for production Rust hosting because it has lower overhead, fewer background processes, easier automation, and simpler service management.

Windows works, but uses more RAM/CPU overhead and requires manual management.

Many serious Rust server operators prefer Linux for consistency, automation, and uptime.