How to create a Rust server: guide for Windows and Linux

Your Rust server is running and your friends can connect through the F1 console — yet it never shows up in the server browser. Usually that is the query port: the game port 28015/UDP accepts connections just fine, while 28017/UDP, which the server list depends on, is blocked in the firewall or the router.

Requirements: hardware and hosting

Rust is above all hungry for memory. How much your server actually uses depends on map size, player count, placed entities and installed plugins. Treat these as guidelines, not guaranteed minimums:

Large bases, many entities, plugins and long wipe cycles all push memory use up. On the CPU side, strong single-core performance counts for more than core count. Use an SSD with room for server files, maps, logs and backups.

At home, Rust works for testing and small private rounds. Public connections need a stable upload, a public IPv4 address and port forwarding. On DS-Lite or CGNAT lines a normal IPv4 port forward is frequently impossible.

For a public server, power costs, upload bandwidth and DDoS exposure usually make a VPS, root server or ready-made game server the more realistic choice. You can also rent a Rust server.

Installing on Windows

Create two separate folders: C:\steamcmd for SteamCMD and C:\rust-server for the server itself. Download SteamCMD from Valve, extract steamcmd.zip into C:\steamcmd and run steamcmd.exe once so it can update itself. Then install the Rust dedicated server:

steamcmd.exe +login anonymous +force_install_dir C:\rust-server +app_update 258550 validate +quit

258550 is the app ID of the dedicated server; 252490 belongs to the client. validate checks the files and replaces any that were changed — including, if present, files belonging to a modding framework.

Create a file called start.bat in C:\rust-server:

@echo off
cd /d C:\rust-server

RustDedicated.exe -batchmode ^
+server.identity "meinserver" ^
+server.hostname "My Rust Server" ^
+server.description "Vanilla Rust server for friends" ^
+server.port 28015 ^
+server.queryport 28017 ^
+server.level "Procedural Map" ^
+server.seed 12345 ^
+server.worldsize 3500 ^
+server.maxplayers 20 ^
+rcon.port 28016 ^
+rcon.password "PUT_A_LONG_SECURE_PASSWORD_HERE" ^
+rcon.web 1 ^
-logfile "rustserver.log"

pause

Adjust name, description, map and player count. You must replace PUT_A_LONG_SECURE_PASSWORD_HERE with a long RCON password of your own — RCON gives full remote control of the server. Run the batch file; the log ends up in C:\rust-server\rustserver.log.

Open PowerShell as an administrator and set up the Windows firewall:

New-NetFirewallRule -DisplayName "Rust Game UDP 28015" -Direction Inbound -Protocol UDP -LocalPort 28015 -Action Allow
New-NetFirewallRule -DisplayName "Rust Query UDP 28017" -Direction Inbound -Protocol UDP -LocalPort 28017 -Action Allow
New-NetFirewallRule -DisplayName "Rust RCON TCP 28016" -Direction Inbound -Protocol TCP -LocalPort 28016 -Action Allow
New-NetFirewallRule -DisplayName "Rust Plus TCP 28082" -Direction Inbound -Protocol TCP -LocalPort 28082 -Action Allow

You only need 28016/TCP for RCON and 28082/TCP for Rust+ if you use those features. Behind a router, forward the required ports to a fixed local IP on the server PC.

Installing on Linux and running it under systemd

On Debian or Ubuntu, the game server should not run as root. Create a rust user, switch to it and set up separate directories for SteamCMD and the server:

sudo adduser --disabled-password --gecos "" rust
sudo -iu rust
mkdir -p ~/steamcmd ~/server
cd ~/steamcmd
wget https://steamcdn-a.akamaihd.net/client/installer/steamcmd_linux.tar.gz
tar -xzf steamcmd_linux.tar.gz

Depending on the system, SteamCMD may ask for extra 32-bit libraries such as lib32gcc-s1. If it complains on start, install the missing library from a user with sudo rights. Then download the server files as the rust user:

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

Create the start script at /home/rust/server/start.sh. The values match the Windows configuration, so the two examples line up:

#!/usr/bin/env bash
set -e

cd /home/rust/server

exec ./RustDedicated -batchmode \
  +server.identity "meinserver" \
  +server.hostname "My Rust Server" \
  +server.description "Vanilla Rust server for friends" \
  +server.port 28015 \
  +server.queryport 28017 \
  +server.level "Procedural Map" \
  +server.seed 12345 \
  +server.worldsize 3500 \
  +server.maxplayers 20 \
  +rcon.port 28016 \
  +rcon.password "PUT_A_LONG_SECURE_PASSWORD_HERE" \
  +rcon.web 1 \
  -logfile "/home/rust/server/rustserver.log"

Set a long RCON password of your own here as well, and make the script executable:

chmod +x /home/rust/server/start.sh

For permanent operation, systemd handles starting on boot and restarting after a crash — the same pattern as for a Valheim server or a Palworld server. Switch back to your administrative user for the unit file and the sudo commands, then create /etc/systemd/system/rust-server.service:

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

[Service]
Type=simple
User=rust
Group=rust
WorkingDirectory=/home/rust/server
ExecStart=/home/rust/server/start.sh
Restart=on-failure
RestartSec=10
LimitNOFILE=100000

[Install]
WantedBy=multi-user.target

Load the unit, enable the service and check its state. The last command follows the log as it runs:

sudo systemctl daemon-reload
sudo systemctl enable --now rust-server
sudo systemctl status rust-server
sudo journalctl -u rust-server -f

If you use UFW, open the required ports:

sudo ufw allow 28015/udp
sudo ufw allow 28017/udp
sudo ufw allow 28016/tcp
sudo ufw allow 28082/tcp

RCON and Rust+ are optional. Restrict RCON to a trusted source IP where you can. With a hosting provider, an external firewall may apply on top.

Launch parameters and server.cfg

The start scripts already carry the main values. What each parameter does:

Ports, identity and base values fit in the start script. Everything else belongs in server.cfg inside the identity folder:

• Windows: C:\rust-server\server\meinserver\cfg\server.cfg
• Linux: /home/rust/server/server/meinserver/cfg/server.cfg

A possible configuration:

server.hostname "My Rust Server"
server.description "Vanilla Rust with a monthly wipe"
server.maxplayers 20
server.tags "monthly,vanilla,EU"
server.saveinterval 300

In this file, commands are written without a leading +. The identity folder usually only appears after the first start. Where values contradict each other, server.cfg wins over the start script — so if a change in the script seems to do nothing, look here first.

Which ports does a Rust server need?

In the example configuration Rust uses four ports with different jobs. Mind the protocol, too: a TCP rule does not stand in for a UDP one.

The query port has a quirk. If you do not set server.queryport explicitly, Rust picks a port above the higher of the game and RCON ports by default. With 28015 and 28016 that works out to 28017. Change either of those two and the automatically chosen query port can move with it — without anyone noticing. Setting +server.queryport 28017 in the start script pins it down.

A direct connection only needs the game port. The query port does a different job: with 28017/UDP blocked, players can still join using the direct connect command, but your server is missing from the browser. That is exactly why opening only 28015/UDP is not enough for a public server. Check the operating system firewall and any firewall in front of it.

At home there is a second layer. The router forward has to point at the server PC's fixed local IP; a firewall rule on the machine alone does not open the router. If your connection sits behind DS-Lite or CGNAT, a normal IPv4 forward can fail even with every rule set correctly. Only test ports while the server is actually running — a failed test against a stopped service tells you nothing about the forward.

Connecting to the server

Start Rust and press F1 to open the console. Depending on where the server runs, use one of these:

connect localhost:28015
connect 192.168.1.50:28015
connect SERVER-IP:28015

localhost is the same PC, 192.168.1.50 stands for a machine on your home network, and SERVER-IP is the public server address. The older client.connect IP:28015 still works; connect IP:Port is all you need. To use a hostname instead of an IP, set up an A record pointing at the IPv4 address and an SRV record with service _rust and protocol _udp.

Granting admin and moderator rights

Rights are tied to the player's SteamID64. Enter the matching command in the server console or over RCON:

ownerid STEAMID64 "Name" "Owner"
moderatorid STEAMID64 "Name" "Moderator"

Replace STEAMID64 and Name with the player's details. That player has to reconnect once for the new rights to apply. Current server versions save these changes automatically; the server.writecfg that older guides still insist on is no longer required. On Linux, administration usually runs through RCON. users shows who is currently online.

Name, images and tags in the server browser

Your server-browser entry is built from several settings. Name and description should reflect what the server actually offers; tags help players filter. In server.cfg that might look like this:

server.hostname "DE/EU My Rust Server"
server.description "Vanilla | Monthly Wipe | active admins"
server.url "https://example.com"
server.headerimage "https://example.com/rust-header.jpg"
server.logoimage "https://example.com/rust-logo.png"
server.tags "monthly,vanilla,EU"

Header image and logo URLs must be directly reachable. The logo is shown as a circle, so keep anything important out of the corners. Up to four tags appear in the server browser. Pick ones that fit and do not combine contradictory tags from the same group, such as weekly and monthly. A good-looking entry does not fix a blocked query port, though — the server still has to be findable first.

Plugins with Oxide/uMod or Carbon

Kits, shops, teleports, clans, extra UI and admin tools all require a modding framework. Oxide/uMod has a large, established plugin catalogue. Carbon is an alternative with high Oxide compatibility and extra features of its own. Which one fits depends on the plugins you want to run and which framework supports them.

For Oxide, stop the Rust server first. Open the Rust page on umod.org and download the archive for Windows or Linux. Extract it into the root directory of your Rust server and overwrite the existing files. Start the server and check that an oxide folder has appeared. Your plugins go into oxide/plugins. With Carbon, plugins typically live in carbon/plugins.

So stick to a fixed update order: back up first, then update Rust, then install the current Oxide or Carbon version, and check the plugins last. The backup protects your world and settings; reinstalling the framework restores the files SteamCMD overwrote. Update only Rust and restart straight away, and it is easy to miss that the framework is no longer fully there.

Map wipe, blueprint wipe and force wipe

A wipe resets part of the progress. What disappears depends on the kind of wipe:

• Map wipe: the world, including buildings and placed objects, is reset.
• Blueprint wipe: learned blueprints are deleted.
• Full wipe: map and blueprints are both reset.
• Force wipe: Rust gets a mandatory update on the first Thursday of the month, which usually forces a map wipe. Not every force wipe automatically deletes all blueprints.

A new server.seed or a different server.worldsize produces a new map. Do not change these values on the side during a running wipe in order to replace an existing world. Stop the server and back it up before a manual wipe, so you can restore the previous data if you reset the wrong world or save.

Backing up and restoring a Rust server

Back up the whole folder of your server identity — server/meinserver/ in this example. It holds the world and save files, the map file, blueprint data, admin and ban lists, the configuration and the Rust+ identity. Backing up individual config files is not enough if you want to restore the world and progress later.

Save cleanly before the backup, or stop the server. Do not keep the backup only on the same disk Rust runs on; if that disk fails, you lose server and backup together. Take a fresh backup before every update to Rust, Oxide, Carbon or plugins.

companion.id belongs to the Rust+ identity. Do not delete it casually, and do not use it on several servers at once. When restoring, the complete identity folder is therefore the sensible starting point. If you want to keep several states, back them up separately instead of overwriting your only backup at every update.

Troubleshooting

Start with the log when the server will not come up. On Windows it is at C:\rust-server\rustserver.log in this example; on Linux, follow the systemd service's output:

sudo journalctl -u rust-server -f

With network problems, keep the game port for direct joins and the query port for the list apart. If only the server list is affected, there is no reason to reinstall Rust. And when plugins fail after an update, check first whether Oxide is still present and works with the updated Rust version.

Frequently asked questions about Rust servers

How much RAM does a Rust server need?

For a small group on a world size of 2000 to 3000, 8 GB is the guideline. With roughly 10 to 50 players on a larger map, plan for 12 to 16 GB. Many plugins, entities and longer wipe cycles can require more.

Which ports do I need to open for Rust?

Players need 28015/UDP; to appear in the server browser, our configuration adds 28017/UDP. 28016/TCP is for RCON and 28082/TCP for Rust+. If you configured different ports, the rules have to match them.

Can I host a Rust server on my own PC?

Yes, especially for testing and small private groups. For players outside your home network you need a public IPv4 address, matching forwards and enough upload bandwidth. On DS-Lite or CGNAT the usual IPv4 port forward can fail.

How do I become admin on my Rust server?

Grant owner rights in the server console or over RCON with ownerid and your SteamID64, then reconnect so they take effect. For more limited moderation rights, use moderatorid.

Why is my Rust server not showing up?

If a direct connection works but there is no browser entry, check the query port. In this example that is 28017/UDP, which has to be open in the firewall and, for a home server, forwarded in the router as well. A changed game or RCON port can shift the automatically chosen query port if you did not set it explicitly.

What is the difference between Oxide and Carbon?

Both are frameworks for extending Rust with plugins. Oxide/uMod has a large, established plugin catalogue; Carbon offers high Oxide compatibility plus extra features. The choice comes down to which plugins you want to use.

When is the Rust force wipe?

Rust gets its mandatory update on the first Thursday of the month. That usually resets the map, while blueprints are not necessarily wiped every time. A full wipe resets both.

Why did my plugins disappear after an update?

When updating, SteamCMD can overwrite modified server files and replace Oxide's files with vanilla ones. Stop the server for maintenance, back up first, update Rust, then reinstall the matching framework version. Check the plugins before opening the server to players again.