Rust Dedicated Server: Wipe Schedule, Hardware Requirements, and Performance Tuning

Rust is one of the most demanding multiplayer survival games to self-host. Its dedicated server must handle hundreds of player-built structures, AI entities (animals, scientists, NPCs), and the physics of projectile ballistics — all while maintaining a stable tick rate under a forced monthly wipe cycle. This article covers the hardware requirements, wipe schedule management, and performance tuning needed to run a competitive Rust server on dedicated hardware.

Before you provision hardware, check our dedicated server comparison table to find a configuration that matches your target player count and wipe schedule.

Understanding the Rust Wipe Cycle

Facepunch Studios enforces a mandatory wipe on the first Thursday of every month at 2:00 PM EST. This wipe clears all player-built structures and resets the map, forcing every server to start fresh. In addition to the forced monthly wipe, server admins can choose to wipe weekly or bi-weekly. The wipe schedule directly affects server performance: a fresh wipe server has fewer entities and runs faster, while a server nearing the end of its cycle has hundreds of thousands of entities that strain the CPU.

Hardware Requirements by Server Population

Player Slots	CPU	RAM	Storage	Network
50–100	6–8 cores @ 4.0+ GHz	16 GB	256 GB NVMe	1 Gbps
100–200	8–12 cores @ 4.5+ GHz	24–32 GB	512 GB NVMe	1 Gbps
200–300	12–16 cores @ 4.5+ GHz	32–48 GB	1 TB NVMe	1 Gbps
300+	16+ cores @ 4.5+ GHz	48–64 GB	2 TB NVMe	1–10 Gbps

Rust uses a multi-threaded server architecture, unlike Minecraft’s single-threaded model. While the main game loop is still the primary bottleneck, Rust offloads entity AI, physics, and network I/O to separate threads. This means more cores actually help — a 12-core CPU at 4.5 GHz will handle a 200-player server better than a 6-core CPU at 5.0 GHz.

Setting Up the Rust Dedicated Server

SteamCMD Installation

# Install SteamCMD
sudo add-apt-repository multiverse
sudo dpkg --add-architecture i386
sudo apt update
sudo apt install steamcmd

# Create a dedicated user
sudo useradd -m -s /bin/bash rust
sudo -u rust -i

# Install Rust dedicated server
steamcmd +force_install_dir /opt/rustserver \
  +login anonymous \
  +app_update 258550 validate \
  +quit

Startup Script with Oxide/uMod

Most Rust servers run Oxide (uMod) for plugin support. The startup command includes the server identity, map seed, world size, and RCON settings:

#!/bin/bash
# /opt/rustserver/start.sh
export LD_LIBRARY_PATH=/opt/rustserver/RustDedicated_Data/Plugins/x86_64:$LD_LIBRARY_PATH

./RustDedicated \
  -batchmode \
  +server.port 28015 \
  +rcon.port 28016 \
  +rcon.password "your_strong_password" \
  +server.tickrate 30 \
  +server.hostname "My Rust Server" \
  +server.description "Monthly wipe | 2x gather | Solo/Duo/Trio" \
  +server.url "https://your-server-discord.com" \
  +server.identity "my_server" \
  +server.seed 12345 \
  +server.worldsize 4000 \
  +server.maxplayers 150 \
  +server.saveinterval 300 \
  +server.level "Procedural Map"

Performance Tuning for Rust

Tick Rate and Entity Limits

Rust’s default tick rate is 30. This is generally sufficient — higher tick rates (60) increase CPU load dramatically without noticeable player benefit. The main performance knob is entity limits. Each player structure (wall, foundation, deployable) is an entity tracked by the server. A 200-player server with monthly wipes can accumulate 500,000+ entities by week four. To keep performance stable:

Set entity limits: Use the server.maxentitycount convar or Oxide plugins like EntityLimit to cap the number of entities per player or per grid.
Shorten the wipe cycle: Bi-weekly wipes keep entity counts lower. Weekly wipes are common for high-population servers.
Reduce world size: A 3000-size map generates fewer entities than a 4000-size map. Most competitive servers use 3000–3500.

Garbage Collection and Memory

Rust runs on Unity, which uses a garbage collector. As entities accumulate, the GC pauses become longer. Monitor GC pauses with the gc.collect console command. If pauses exceed 100ms, the server tick rate drops. Mitigations:

Schedule daily restarts (common practice for Rust servers).
Use the server.saveinterval setting to save less frequently (300 seconds is fine).
Allocate sufficient RAM. Rust servers use 8–16 GB base plus 50–100 MB per active player.

DDoS Protection for Rust Servers

Rust servers are among the most frequently DDoSed game servers. Competitors, disgruntled players, and script kiddies target popular servers. Your dedicated server provider must offer:

At least 10 Gbps of always-on DDoS mitigation. Rust attacks commonly exceed 5 Gbps.
Per-IP filtering. If the mitigation is per-rack, an attack on another server on the same rack can affect yours.
UDP amplification protection. Rust uses UDP for game traffic. Attackers exploit UDP amplification attacks (DNS, NTP, SSDP reflectors).

Wipe Management and Automation

Automate your wipe process to reduce downtime. A typical wipe script:

#!/bin/bash
# Rust wipe script
IDENTITY="my_server"
SERVER_DIR="/opt/rustserver"

# Stop the server
systemctl stop rustserver

# Delete map and save files
rm -rf "$SERVER_DIR/server/$IDENTITY/proceduralmap.*.map"
rm -rf "$SERVER_DIR/server/$IDENTITY/proceduralmap.*.sav"
rm -rf "$SERVER_DIR/server/$IDENTITY/player.blueprints.*.db"

# Update the server
steamcmd +force_install_dir "$SERVER_DIR" \
  +login anonymous \
  +app_update 258550 validate \
  +quit

# Update Oxide if needed
# wget -O "$SERVER_DIR/RustDedicated_Data/Managed/Oxide.Rust.dll" https://umod.org/games/rust/download

# Start the server
systemctl start rustserver

echo "$(date): Wipe complete" >> /var/log/rust-wipes.log

Schedule this script with a systemd timer or cron to run on the first Thursday of each month. For bi-weekly wipes, add a second timer.

Monitoring Server Health

Key metrics to watch:

Server FPS: The server’s internal tick rate. Should stay at 30. Drops below 25 indicate CPU saturation.
Entity count: Run entities in the console. If it exceeds 300,000, consider a wipe or entity limit plugin.
Network in/out: A 200-player server generates 40–80 Mbps of UDP traffic. Monitor with iftop or nload.
RAM usage: Track with htop. If the server exceeds 80% of available RAM, schedule a restart.

Bottom Line

Running a Rust dedicated server is a commitment. The forced monthly wipe cycle, high entity counts, and frequent DDoS attacks demand a server with multi-core CPU power, abundant RAM, NVMe storage, and robust DDoS protection. Automate the wipe process, monitor entity counts, and keep the server updated. With the right hardware and configuration, you can build a Rust community that survives wipe after wipe.

Find dedicated server hosting for Rust on our comparison page to match your population and budget.