Rust Server on VPS: Wipe, Oxide, Ulm — Setup from Scratch

For a stable Rust server on a VPS with an online capacity of up to 50 players, you need a minimum of 16 GB RAM, 4 vCPUs with a high clock speed (from 3.5 GHz), and an NVMe drive—this configuration ensures no lag during map reading and entity processing, with the cost of renting a suitable server ranging between $25–45 per month.

Choosing a configuration for a Rust VPS server

Rust is one of the most resource-demanding games in the survival segment. Unlike many other projects, Rust consumes a massive amount of RAM due to the specifics of the Unity engine and the need to keep thousands of objects (player buildings, resources, NPCs) in the cache. When choosing a rust vps server, you must focus on single-threaded processor performance, as the server's main game loop (Tick) runs primarily on a single thread.

Difference between Vanilla and Rust modded server load

A vanilla server without modifications consumes a base of 6–8 GB RAM immediately after launching a map of size 4000. However, as players build up the map, memory consumption grows. If you plan to run a rust modded server using Oxide (uMod) and 20–30 plugins, the minimum requirement rises to 16 GB RAM. Plugins for accelerated loot, teleportation, and custom interfaces create additional load on the CPU. For comparison, Rust's requirements are significantly higher than those of other popular games, which you can read more about in the article on Minecraft Java server on VPS: mods, plugins, RAM selection.

Why NVMe is critical for Rust

Using standard SSDs or, even worse, HDDs is the main cause of "freezes" during map saves or during a rust wipe. The Rust server records the world state every 5–10 minutes (World Save). On maps with a large number of buildings, the save file size can reach hundreds of megabytes. Only NVMe drives with write speeds from 2000 MB/s allow these operations to occur unnoticed by players. If the disk subsystem is slow, all players will experience a "timeout" for 1–3 seconds at the moment of saving.

Parameter	Minimum (Vanilla, 20 players)	Optimal (Modded, 60 players)	PRO (100+ players, Custom Maps)
Processor (vCPU)	2 Cores (3.0+ GHz)	4 Cores (3.5+ GHz)	8 Cores (4.0+ GHz)
RAM	12 GB RAM	24 GB RAM	32-64 GB RAM
Disk Type	SSD	NVMe	NVMe Gen4
OS	Ubuntu 22.04 / 24.04	Ubuntu 22.04 / 24.04	Ubuntu 22.04 / 24.04

System Preparation and SteamCMD Installation

The Ubuntu 22.04 LTS distribution is best suited for running a rust dedicated server. This ensures stability and up-to-date libraries. It is not recommended to use Windows Server for Rust on a VPS, as the OS itself consumes up to 2–3 GB RAM, which is critical for gameplay. When switching from cloud platforms to dedicated resources, you can save significantly, as described in the material on AWS EC2 alternatives for backend.

Configuring System Limits

Before installation, you must increase the open file limits; otherwise, the server may crash under high player counts. Edit the /etc/security/limits.conf file, adding the following lines to the end:

* soft nofile 100000
* hard nofile 100000

Installing Dependencies and SteamCMD

Rust requires certain 32-bit libraries. Run the following commands as a superuser:

dpkg --add-architecture i386
apt update
apt install lib32gcc-s1 lib32stdc++6 lib32z1 libicu-dev wget tar screen -y

Create a separate user for the server (never run Rust as root):

useradd -m rustserver
su - rustserver
mkdir ~/steamcmd && cd ~/steamcmd
wget https://steamcdn-a.akamaihd.net/client/installer/steamcmd_linux.tar.gz
tar -xvzf steamcmd_linux.tar.gz

Deploying a Rust Dedicated Server

The game file installation process takes 10 to 30 minutes depending on your VPS internet speed. Rust requires about 15–20 GB of free disk space for the server files themselves, plus extra for logs and backups.

Downloading Server Files

Launch SteamCMD and install the Rust Dedicated Server (AppID 258550):

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

If a "Disk write failure" error occurs during the download, check your free space. Rust releases updates frequently, so you will need to use this command regularly before every start after a patch.

Creating a Start Script

In the /home/rustserver/rust_dir directory, create a start.sh file. This is a key stage in setting up your rust vps server. Example of an optimal config:

#!/bin/sh
export LD_LIBRARY_PATH=$LD_LIBRARY_PATH:`pwd`/RustDedicated_Data/Plugins/x86_64
./RustDedicated -batchmode \
+server.ip 0.0.0.0 \
+server.port 28015 \
+server.tickrate 30 \
+server.hostname "My Rust VPS Server" \
+server.identity "server_one" \
+server.seed 1234567 \
+server.worldsize 3500 \
+server.maxplayers 50 \
+rcon.port 28016 \
+rcon.password "YourSecurePassword" \
+rcon.web 1

The +server.tickrate 30 parameter is standard. Attempting to raise it to 60 or 100 on a VPS can lead to unstable gunplay and player "rubberbanding" if the CPU cannot keep up.

Installing Oxide Rust and Working with Plugins

Most server owners choose the modification path. Oxide rust (now known as uMod) is a framework that allows you to extend game functionality. It lets you change resource gathering rates, add clan systems, and custom menus.

uMod (Oxide) Integration

To install Oxide, download the latest Linux build from the official uMod website. Extract the archive directly into the server's root folder. Note: after every official Rust update from Facepunch, Oxide must be reinstalled (overwrite the files), as the game update replaces the modified Assembly-CSharp.dll library with the original one.

wget https://umod.org/games/rust/download/develop -O oxide.zip
unzip -o oxide.zip
chmod +x Carbon.Preloader # if using Carbon or similar

Plugin Management

Plugins have a .cs extension and are placed in the oxide/plugins folder. They are compiled "on the fly" while the server is running. If you are moving from budget hosts like Contabo, you will notice that plugin compilation happens much faster on high-performance VPS. More details on power comparisons can be found in the article Contabo vs Valebyte: Real Performance.

• GatherManager: Changes resource gathering rates (x2, x5, x10).
• ImageLibrary: Required for correctly displaying icons in the GUI.
• NoGiveNotices: Hides admin item-giving messages in chat.
• Vanish: Allows admins to become invisible to monitor for cheaters.

How to Properly Perform a Rust Wipe

The concept of a rust wipe is a forced clearing of game progress. Wipes are necessary because, over time, the map fills with buildings, which lowers player FPS and increases server load. There are two types of wipes: Map Wipe (map only) and Full Wipe (map + blueprints).

Wipe Schedule and Automation

The standard schedule for popular servers is a weekly map wipe on Thursdays (on Facepunch update day) and a monthly blueprint wipe (first Thursday of the month). To perform a manual wipe:

1. Stop the server via RCON or by killing the process.
2. Go to the server/server_one/ folder.
3. Delete files with the .sav extension (this removes buildings and terrain).
4. If a Full Wipe is needed—delete the player.blueprints.db file.
5. Change the +server.seed in the start script to generate a new map.
6. Start the server.

Wipe automation is possible via crontab, but experienced admins prefer doing it manually to ensure Oxide updates are installed correctly.

Server Management via RCON and Ulm

Administering a Rust server does not require staying in the Linux console constantly. The RCON protocol is used for this. Many tools exist, but the most popular is Ulm (RustAdmin) and its web analogs.

Setting Up Remote Access

In the start script, we already specified +rcon.web 1. This is the modern WebSocket RCON standard. To connect, use the RustAdmin program:

• IP: Your VPS address.
• Port: 28016 (or the one specified in rcon.port).
• Password: Your password from the start script.

Through RCON, you can ban players, give items, change weather and time of day, and monitor CPU load in real-time. If you plan to scale your project, consider moving to more powerful solutions, as mentioned in the guide on moving from AWS to dedicated.

Monitoring Server FPS

The server.fps command in the console shows the actual frame rate of the game loop. If this value drops below 10, players will start experiencing serious delays. On a high-quality rust vps server, the value should be stable above 30. If FPS drops with low player counts, check the logs for errors from looping plugins.

Optimization and Server Protection

Rust servers are prone to DDoS attacks as it is a competitive game. Basic data center-level protection is mandatory. Additionally, it is important to optimize the Linux network stack to handle a large number of UDP packets. Similar protection methods are used for other shooters, for example, when installing a CS2 server.

To optimize the network part, add the following to /etc/sysctl.conf:

net.core.rmem_max = 16777216
net.core.wmem_max = 16777216
net.ipv4.udp_rmem_min = 16384
net.ipv4.udp_wmem_min = 16384

Apply the changes with the command sysctl -p. This will help avoid packet loss during sharp traffic spikes during raids, when the server exchanges a massive amount of data with player clients.

Conclusion

To create a successful Rust server on a VPS, it is critical to invest in high CPU frequency and NVMe drives, as these determine the absence of lag under high player loads. Ubuntu 22.04 with Oxide installed is the optimal choice for flexible gameplay management and automated scripts for weekly wipes.