Rust Dedicated Server: 12 Steps, 30 Min [2026]

Rust remains one of Steam’s most-played survival titles in 2026, with SteamCharts recording roughly 130,000 concurrent players at the time of writing and an all-time peak of 259,646 concurrent users. Most of that population plays on community-run servers rather than official Facepunch matchmaking, because a self-hosted box gives an owner full control over wipe schedules, plugin choices, moderation, and the map itself — none of which official servers offer. This tutorial walks through every step of standing up a self-hosted Rust server in 2026, from SteamCMD installation through RCON hardening and mod support, in roughly 30 minutes of hands-on work.

Unlike most games in the genre, Rust ships no traditional version number. Facepunch instead pushes a forced update on the first Thursday of every month that wipes every server, official and community-run alike, whether the owner wants it or not. That cadence shapes almost every operational decision covered below, from save intervals to plugin update timing to when to schedule your own maintenance windows. This guide uses only specifications confirmed directly against Facepunch’s official server wiki, live SteamCharts data pulled at the time of writing, and cross-checked hosting-provider pricing from multiple independent sources, so every figure here is verifiable rather than estimated from memory or a single source.

By the end of this guide you’ll have a working Rust dedicated server with a procedurally-generated map, remote administration through RCON, optional mod support via Oxide or Carbon, and a production-ready systemd service so the whole stack survives a reboot without manual intervention. The full command set is included at each step, so you can copy and adapt it directly rather than piecing together fragments from several different sources.

Prerequisites: Hardware, Software and Account Requirements

Before installing anything, confirm your machine or VPS meets Facepunch’s baseline. The official server-creation wiki lists 12 GB of free RAM as the standard minimum, explicitly noting that larger 6,000-unit maps consume more, plus 15 GB of free disk space with SSD or NVMe storage “highly preferred” over spinning disks, since Rust’s save and world-generation process is disk-I/O sensitive. You’ll also need a Windows, Linux, or macOS machine capable of running the RustDedicated binary — Facepunch supports all three natively for the server executable, even though the player client itself is Windows/Linux-only. Most production Rust servers in the wild run on Linux, since it’s cheaper to rent as a VPS and lighter on RAM overhead than an equivalent Windows box, but every step in this guide includes both paths.

A Steam account is not required to download or run the server files — SteamCMD’s anonymous login (+login anonymous) is sufficient for pulling app ID 258550, the dedicated-server build, which is distinct from the player client’s app ID 252490. You will, however, want a router or firewall you control, since three ports need forwarding before the server becomes reachable from outside your local network. If you’re hosting from a home connection, it’s worth checking for Carrier-Grade NAT (CGNAT) with your ISP before you start — it’s the single most common reason home-hosted Rust servers never become reachable no matter how carefully the rest of this guide is followed, since no amount of router configuration fixes an ISP-level NAT layer sitting upstream of your own equipment. A quick way to check: if your router’s WAN IP doesn’t match what a site like whatismyip.com reports from inside your network, you’re likely behind CGNAT and will need either a VPS, a tunneling service, or an ISP static-IP add-on instead of direct home hosting.

Server Size	RAM	CPU	Disk	Typical Player Count
Small / vanilla	8–12 GB	3.0 GHz quad-core	15–25 GB SSD	Up to 50
Medium / modded	16–24 GB	3.5 GHz quad-core+	25–40 GB NVMe	50–100
Large / custom map	32–48 GB	4.0 GHz 6-8 core	50+ GB NVMe	100+
Facepunch official minimum	12 GB	Not specified	15 GB	Varies by worldsize
Community 3,000–3,500 map	8 GB min, 16 GB ideal	Modern quad-core	20 GB SSD	Small friend groups

Rust is notably single-thread and clock-speed sensitive rather than core-count sensitive — a CPU with fewer, faster cores will typically outperform one with more, slower cores for a given population, which is worth keeping in mind since many budget VPS plans advertise core count prominently but bury clock speed in the fine print. Keep that distinction in mind when choosing between a home PC, a generic VPS, and a managed game-hosting plan in the steps that follow.

Step 1: Choose Your Hosting Path

There are three realistic ways to run a Rust server in 2026: self-hosting on a home PC, renting a generic VPS or dedicated box and installing everything yourself, or paying a managed hosting provider that pre-installs SteamCMD, Oxide, and a control panel for you. Home hosting is free beyond electricity and is by far the best way to learn exactly how the stack fits together, which is why this tutorial defaults to that path — but it ties up an always-on machine, adds to your power bill, and depends entirely on your ISP allowing inbound connections without CGNAT in the way. A generic VPS from a provider like OVH, Hetzner, or Contabo gives you full root access and predictable uptime independent of your home connection, at the cost of doing every step below yourself on rented hardware instead of your own.

Managed hosting providers, covered in more detail later in this guide, charge a recurring premium but strip out most of the manual setup entirely, trading direct control for convenience — a reasonable trade if you’d rather spend your time moderating a community than maintaining infrastructure. Whichever path you choose, the underlying software stack is identical: SteamCMD, the RustDedicated binary, a startup script, and optionally Oxide or Carbon for mods. That means this guide applies whether you’re repurposing a spare gaming PC, spinning up a cloud VPS for the first time, or just want to understand what a managed host is actually doing behind its control panel.

Step 2: Open the Required Rust Server Ports

Rust needs three ports open and forwarded to your server’s local IP address before it’s reachable from the outside. According to Facepunch’s own server wiki, the game port defaults to 28015/UDP, the RCON port defaults to 28016/TCP, and the query port — used for server-browser visibility — defaults automatically to whichever of the game or RCON port is higher, plus one, which makes 28017/UDP the practical default in a standard setup. Some community guides list the query and RCON assignments the other way around, since Facepunch’s own defaults can shift depending on which flags you set explicitly in your launch parameters. The safest approach, and the one used throughout this guide, is to set all three ports explicitly in your startup script rather than relying on any implicit default, removing the ambiguity entirely.

Port	Protocol	Purpose	Required?
28015	UDP	Primary game connection (players)	Yes
28016	TCP	RCON remote administration	Yes, for remote admin
28017	UDP	Server browser / query port	Yes, for public listing
28082	TCP	rcon.web browser-based RCON console	Optional
Steam backend ports	UDP (various)	SteamCMD downloads and Steam networking	Outbound only, usually open by default

If you’re hosting from a home router, log into its admin panel and forward each port to your server machine’s static local IP — set that static IP first, either through your router’s DHCP reservation feature or a manual static configuration on the machine itself, since a port forward tied to a DHCP-assigned address will silently break the next time your router reassigns it. If you’re on a VPS or cloud box instead, remember that most providers add a second firewall layer in their own control panel — a “security group,” “cloud firewall,” or similar — sitting on top of the operating system’s own firewall. Forwarding a port at only one of those two layers, and assuming the other is already open, is one of the most common reasons a freshly-configured cloud server still isn’t reachable from outside.

Step 3: Install SteamCMD

SteamCMD is Valve’s command-line tool for downloading dedicated server files, and it’s the same tool used across nearly every Steam-based dedicated server, not just Rust, so it’s worth getting comfortable with regardless of which game you host in the future. On Linux (Ubuntu/Debian), enable the multiverse repository and install SteamCMD directly from the package manager:

sudo add-apt-repository multiverse
sudo dpkg --add-architecture i386
sudo apt update
sudo apt install -y lib32gcc-s1 steamcmd

On Windows, download the SteamCMD zip archive directly from Valve, extract it into a dedicated folder such as C:\steamcmd, and run steamcmd.exe once to let it self-update before proceeding — the first run always pulls a small update to SteamCMD itself before it will accept any other commands:

mkdir C:\steamcmd
cd C:\steamcmd
:: extract the downloaded steamcmd.zip into this folder, then run:
steamcmd.exe

Step 4: Download the Rust Dedicated Server Files

With SteamCMD installed, pull the Rust dedicated server build using anonymous login and app ID 258550 — this is the server-specific app ID and is different from 252490, which is the player client. Point force_install_dir at wherever you want the server files to live; this same directory becomes your working directory for every step that follows, so pick a permanent location rather than a temporary folder.

steamcmd +force_install_dir /home/steam/rust_server +login anonymous +app_update 258550 validate +quit

On Windows, the equivalent command points at a local path instead of a Linux-style directory:

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

The initial download is several gigabytes and can take anywhere from ten minutes to over an hour depending on your connection speed and SteamCMD’s regional content-delivery routing that day. Re-running the exact same command later is also how you apply Rust’s monthly forced update — SteamCMD only downloads the delta between what’s already on disk and the current build, not the full multi-gigabyte install again, which matters a great deal given Facepunch’s wipe-every-month cadence discussed in Step 11. Independent hosting guides such as Hostinger’s Rust hosting walkthrough describe this same anonymous-login, app-update pattern as the standard install path across both Windows and Linux.

Step 5: Create Your Startup Script

A startup script chains together every launch flag your server needs — network ports, RCON credentials, map size, seed, player cap, and save interval — so you don’t retype a long command every time you restart. This is also where you explicitly set the three ports from Step 2 rather than leaving them to Rust’s defaults, closing off the ambiguity mentioned earlier.

Linux Startup Script

Create a file named start.sh inside your server directory:

#!/bin/bash
cd /home/steam/rust_server
./RustDedicated -batchmode \
  +server.port 28015 \
  +server.identity "myserver" \
  +rcon.port 28016 \
  +rcon.password "CHANGE_ME_STRONG_PASSWORD" \
  +rcon.web 1 \
  +server.hostname "My Rust Server" \
  +server.level "Procedural Map" \
  +server.seed 12345 \
  +server.worldsize 4000 \
  +server.maxplayers 100 \
  +server.saveinterval 300

Make it executable with chmod +x start.sh before your first launch, and double-check the file uses Unix line endings if you wrote or edited it on Windows first — a stray carriage-return character is a surprisingly common reason a shell script that “looks right” fails to execute on Linux.

Windows Startup Script

Create start.bat in the same folder as RustDedicated.exe:

@echo off
cd /d C:\rust_server
RustDedicated.exe -batchmode +server.port 28015 +server.identity "myserver" +rcon.port 28016 +rcon.password "CHANGE_ME_STRONG_PASSWORD" +rcon.web 1 +server.hostname "My Rust Server" +server.level "Procedural Map" +server.seed 12345 +server.worldsize 4000 +server.maxplayers 100 +server.saveinterval 300
pause

Replace the placeholder RCON password on both platforms before your first real launch — a default or weak RCON password is one of the most common ways a Rust server gets griefed or wiped by an outsider, since RCON access is functionally equivalent to full admin control over the entire instance, not just chat moderation.

Step 6: First Launch and World Generation

Run your startup script for the first time. With server.seed and server.worldsize set, Rust procedurally generates a brand-new map matching those exact values — generation time scales with world size, so a 4,000-unit map typically takes a few minutes on modern hardware, while 4,500-plus maps can take considerably longer and use noticeably more RAM during the generation step itself than during normal play afterward. Watch the console output for the line confirming the server is “Ready” and listening on your configured port; that’s your signal the world finished generating and the server is genuinely accepting connections rather than still building the map in the background.

If you plan to keep the same map across restarts — recommended, since regenerating with a different seed wipes any existing bases — never change server.seed or server.worldsize after your first launch. Changing either value on a server that already has a saved map creates a mismatch between the save file and a freshly-generated world, which typically manifests as players spawning underground or inside terrain that no longer matches the save.

Step 7: Connect to Your Server as a Player

From the Rust client, open the F1 developer console and connect directly with client.connect YOUR_IP:28015, substituting your server’s public IP (or a domain name, if you’ve pointed one at it) and the game port from Step 5. If you’re testing from the same network the server runs on, use the machine’s local IP rather than its public IP — many consumer routers don’t support “NAT loopback” or “hairpin NAT,” meaning a public IP simply won’t resolve back to a machine on the same LAN, which is a frequent source of “it works for my friends but not for me” confusion during initial testing.

Once connected, confirm chat and movement work normally, then check the server console for your Steam ID in the join log — you’ll need that ID in the next step to grant yourself admin rights.

Step 8: Configure RCON for Remote Administration

RCON (Remote Console) is how you administer a running Rust server without physical or SSH access to the machine itself — banning players, changing live settings, and running console commands remotely through a separate client or web interface. The rcon.web 1 flag from your startup script enables a browser-based RCON console, reachable by pointing a compatible RCON web tool at your server’s IP and RCON port; several free browser-based and desktop RCON clients exist specifically for Rust and connect using nothing more than the IP, port, and password already set in Step 5. As Rustly’s setup guide puts it plainly when covering this same step, the three ports simply need to be forwarded to the local IP of the machine running the server before any remote tool can reach them.

Treat your RCON password with the same seriousness as a root or administrator password: anyone who has it gains full administrative control of your server, including the ability to wipe it, ban legitimate players, spawn items, or silently change core settings. A minimal server.cfg-style configuration, applied either via startup flags or through RCON commands after launch, looks like this:

server.hostname "My Rust Server"
server.description "A modded Rust server running Oxide"
server.url "https://example.com"
server.identity "myserver"
rcon.port 28016
rcon.password "CHANGE_ME_STRONG_PASSWORD"
rcon.web 1

Step 9: Promote Yourself to Admin

With your Steam ID captured from the join log in Step 7, grant yourself admin status through the server console or an RCON client:

ownerid YOUR_STEAM_ID64 "YourName" "granted via console"

Owner status is the highest privilege level available; a lower moderatorid tier exists for trusted players who need kick and ban powers without full server control, which is worth using for co-admins instead of handing out owner rights indiscriminately. Restart the server once after granting owner status to confirm the permission persists correctly into the next session rather than only applying to the current one.

Step 10: Install Oxide or Carbon for Mod Support

A vanilla Rust server works perfectly well, but most community servers run a modding framework to add plugins — custom kits, teleport commands, economy systems, clan systems, and anti-cheat layers that vanilla Rust doesn’t include on its own. Two frameworks dominate in 2026: Oxide, also known as uMod, the long-established framework with by far the largest existing plugin library built up over years of community development, and Carbon, a newer drop-in replacement positioned around performance. Carbon’s own documentation describes it as built with “performance as the number one factor,” designed to be “super lightweight” by loading hooks only when a plugin actually requires them rather than running every hook unconditionally, and explicitly built for easy migration — its plugin and folder structure deliberately mirrors Oxide’s so an existing setup transfers with minimal restructuring. Multiple independent hosting-provider comparisons report Carbon booting faster and using a smaller RAM footprint than Oxide in side-by-side testing, though Oxide still holds a clear edge in raw plugin-ecosystem depth simply because it’s been the default choice for longer.

To install Oxide, download the latest release matching your platform from the official uMod site, then extract it directly into your server’s root directory — the same folder as your RustDedicated executable:

cd /home/steam/rust_server
unzip -o Oxide.Rust-linux.zip -d .
mkdir -p oxide/plugins

Plugins, typically distributed as individual .cs files, then drop directly into the oxide/plugins folder Oxide creates on first install — the server picks up new or updated plugins without requiring a full restart in most cases, reloading just the changed file. If you choose Carbon instead, its official installer follows the same basic extraction pattern and, per Carbon’s own site, deliberately keeps that same plugin folder layout so a mid-project switch between the two frameworks doesn’t force you to reorganize an already-working plugin setup. Whichever framework you pick, always re-check plugin compatibility immediately after Rust’s monthly forced update — a plugin built against last month’s Rust build is one of the most common causes of a server that ran fine yesterday but won’t start today.

Step 11: Security Hardening and the Monthly Force-Wipe

Rust has no version-number release cycle in the way most dedicated-server software does. Instead, Facepunch pushes a mandatory forced update on the first Thursday of every month, which wipes every server — official and community alike — with no opt-out available to individual owners, alongside smaller patches landing in between those monthly events. Build your entire operational routine around that date: schedule your own server’s map wipe, any plugin-compatibility checks, and a backup of the outgoing map for the same window, since running an outdated Oxide or Carbon build against a freshly-patched Rust binary is one of the most common causes of post-wipe crashes reported by server owners every month.

On the security side specifically, Facepunch has been rolling out stronger anti-cheat requirements over the course of 2026. According to a report citing a public statement from Facepunch COO Alistair McFarlane, an opt-in Secure Boot and TPM 2.0 requirement toggle for server owners went live in March 2026, following an initial announcement in January 2026. Server owners can enable the toggle to require that connecting players’ machines meet those hardware-backed integrity checks, which raises the bar for certain classes of cheat software, though it is not mandatory game-wide as of this writing. If you enable it, be aware it can also block legitimate players running Linux through a compatibility layer whose systems don’t expose a TPM 2.0 chip to the game the same way native Windows does, so weigh anti-cheat strictness against your own community’s actual platform mix before switching it on for a public server.

Beyond that toggle, basic hardening still matters most in practice: keep your RCON password long, unique, and rotated periodically; avoid exposing your RCON port directly to the public internet if you can instead restrict it to a VPN or a specific allow-listed set of IPs; and keep regular off-server backups of your map save file on a separate disk or cloud location so a bad plugin, corrupted save, or hardware failure doesn’t cost you an entire world’s progress between scheduled wipes.

Step 12: Enable Rust+ and Monitor Performance

Rust+ is Facepunch’s companion mobile app, letting players check server status, view in-game security cameras, and control smart devices from their phone without launching the game itself. Enabling it server-side just requires the app.port flag alongside the ports already forwarded in Step 2, plus forwarding that additional port through the exact same process. It’s a low-effort feature to turn on and a genuine differentiator for a community server, since public Rust+ pairing isn’t guaranteed by default on every hosted server, and players increasingly expect it as a baseline feature on any server they join regularly.

For ongoing performance monitoring, watch your server’s own frames-per-second figure in its console output, which is a distinct measurement from any individual player’s in-game FPS — a healthy dedicated server should hold close to its target tick rate under normal load, and a sustained drop is usually the first visible symptom of a plugin problem, a RAM shortfall, or simply too many players and entities for the current hardware tier. Third-party server-listing and monitoring tools can track uptime and player-count history over time, which is useful both for diagnosing recurring lag windows tied to a specific time of day and for giving your community visibility into overall server health.

Self-Hosting vs Managed Rust Server Hosting: Price Comparison

If the 12 steps above feel like more ongoing setup and maintenance than you want to keep handling long-term, managed Rust server hosting providers handle installation, the monthly forced update, and often Oxide pre-installation for a recurring monthly fee. Pricing varies significantly by slot count, RAM allocation, and region. GTX Gaming, a UK-based provider, lists its entry “Survivor” tier at £14.89 per month for 50 player slots, 10 GB of DDR5 RAM, 100 GB of NVMe storage, and a 2,000m² world size, with a lower-cost custom-configuration tier starting around £9.99 per month for smaller specifications. Other well-known providers cited across independent hosting comparison roundups include Shockbyte, which has advertised introductory Rust pricing in the roughly $8 to $12 per month range for smaller slot counts, and Survival Servers, which lists Oxide-ready Rust hosting starting near $4.50 per month for its smallest tier. Nitrado, one of the largest game-hosting brands overall, is typically cited in the $35 to $65 per month range for a 50-slot Rust server depending on the specific survey and region consulted.

Treat all of these as approximate starting prices rather than fixed figures — game-hosting providers frequently run introductory discounts that expire after the first billing cycle, and slot count, RAM, and regional data-center choice all move the final price substantially. The right choice generally comes down to how much of the setup work in this guide you want to keep doing yourself every month versus paying someone else to handle it.

Approach	Approximate Cost	Setup Effort	Best For
Home self-hosting	Electricity only	High (this full guide)	Learning, small private groups
Generic VPS (self-managed)	~$10–40/month	High (same steps, rented hardware)	Reliability without CGNAT risk
Survival Servers (entry tier)	From ~$4.50/month	Low, Oxide pre-installed	Budget small communities
Shockbyte (entry tier)	~$8–12/month	Low, control panel included	First-time managed hosting
GTX Gaming Survivor tier	£14.89/month (50 slots)	Low, panel + support included	Established mid-size communities

Note the currency difference in the table above — GTX Gaming publishes UK pricing in pounds sterling, while the other providers listed quote US dollars, so compare specs per dollar or pound rather than the headline number alone if budget is the deciding factor.

Common Pitfalls When Setting Up a Rust Server

CGNAT blocking inbound connections entirely. If port forwarding appears correct on paper but the server never becomes reachable from outside your own network, contact your ISP and ask directly whether your connection uses Carrier-Grade NAT — no router configuration fixes this, since the NAT layer sits upstream of your own equipment entirely, and the only real fixes are a VPS, a static-IP add-on from your ISP, or a tunneling service.
Forgetting the query port. A server that’s joinable by direct IP but invisible in the in-game server browser almost always has its query port (28017 by default) closed or unforwarded, even though the game port itself works fine for direct connections — these two symptoms get diagnosed as the same problem far too often.
Leaving the RCON password at a weak or default value. RCON access equals full admin control over the entire server — a short or guessable password is one of the most common ways a public Rust server gets griefed, wiped early by an outsider, or has its core settings silently changed without the owner noticing right away.
Changing world seed or worldsize after the first launch. Both values are effectively locked in at map generation time; altering either on a server that already has an existing save creates a mismatch between the save file and a freshly-generated world, which usually forces an unplanned wipe to resolve.
Running mismatched Oxide/Carbon and Rust versions after the monthly force-wipe. Facepunch’s first-Thursday update can silently break plugin compatibility until the framework itself ships a matching update of its own — update your modding framework before or immediately after each monthly patch lands, not days later once players are already reporting crashes.
Only forwarding ports at the router level on a VPS. Cloud providers frequently add a second firewall layer — a security group or cloud panel — on top of the operating system’s own firewall rules; missing either one of those two layers leaves the port effectively closed even though the other layer looks correctly configured.
Underestimating RAM for the chosen world size. Facepunch’s own 12 GB baseline explicitly assumes a standard-size map; a 6,000-unit or heavily custom map can push memory usage well past that minimum, causing crashes under real player load even though the same server ran perfectly fine while still empty during initial testing.

Troubleshooting Guide: 8 Common Rust Server Issues

1. Server doesn’t appear in the in-game server browser. Verify the query port (28017/UDP by default) is forwarded and not blocked by an OS-level firewall — this is the single most common cause, and it’s entirely separate from basic player connectivity, which can work perfectly even while this is broken.

2. “Connection Timed Out” when a player tries to join. Confirm the game port (28015/UDP) is forwarded to the correct local IP, and that the IP itself is static rather than DHCP-assigned — a lease change silently breaks an existing port forward without any obvious error message pointing to the real cause.

3. RCON client won’t connect. Double-check the RCON port matches exactly what’s set in your startup script rather than Rust’s undeclared default, confirm rcon.web is enabled if you’re using a browser-based tool, and verify the RCON port is forwarded separately from the game port rather than assumed to piggyback on it.

4. SteamCMD reports an app state error after updating. A stuck or partially-corrupted update, commonly surfaced as an “app state” error code in the console output, is usually fixed by re-running the exact same app_update 258550 validate command a second time — the validate flag forces SteamCMD to check every local file against Steam’s manifest and re-download anything that doesn’t match, correcting most partial-download issues automatically.

5. Server FPS drops under load. Since Rust scales with CPU clock speed rather than raw core count, check whether your host’s CPU is being shared or throttled — common on budget VPS plans that oversell CPU time — before assuming the drop is a software or plugin problem that needs a code-level fix.

6. Server crashes shortly after adding plugins. Add one plugin at a time and restart between each addition rather than installing several at once — a single incompatible or outdated plugin is far easier to isolate this way, since a crash immediately after adding one new file points directly at the culprit.

7. You can’t connect from the same network the server runs on, but remote players can join fine. This is a NAT loopback, or “hairpin NAT,” limitation present on many consumer routers — connect using the server’s local LAN IP instead of its public IP whenever you’re testing from the same network the server itself is running on.

8. World fails to load or appears corrupted after a crash. Restore from your most recent automatic save, governed by the server.saveinterval setting, or from an off-server backup — this is precisely why keeping backups independent of the host machine matters, since a disk-level failure on the server itself can take any local-only saves down with it at the same time.

9. Server restarts in a loop right after the monthly wipe. Check for an outdated Oxide or Carbon build throwing a fatal error against the newly-patched Rust binary — temporarily renaming or removing the oxide or carbon folder to confirm a vanilla launch succeeds cleanly isolates whether the modding framework itself is the actual cause before you spend time debugging individual plugins.

Advanced Tips for Production Rust Servers

Once your server is stable, a handful of production-grade adjustments pay off over the following months. Run the server inside a screen or tmux session on Linux so it keeps running after you disconnect from SSH, and consider wrapping it in a systemd service so it restarts automatically after a crash or host reboot rather than requiring manual intervention at whatever hour the crash happens to occur. Combined together, this gives you the complete, production-ready version of everything covered above — the startup script from Step 5 wrapped in an auto-restarting service definition:

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

[Service]
Type=simple
User=steam
WorkingDirectory=/home/steam/rust_server
ExecStart=/home/steam/rust_server/start.sh
Restart=on-failure
RestartSec=10

[Install]
WantedBy=multi-user.target

Save that as /etc/systemd/system/rustserver.service, then enable and start it with sudo systemctl enable --now rustserver. Combined with the port configuration from Step 2, the startup script from Step 5, RCON setup from Step 8, and Oxide or Carbon from Step 10, this gives you a complete, auto-recovering Rust server stack rather than a loose collection of manual steps you’d otherwise need to re-run by hand after every restart.

If you’re running multiple Rust instances on one machine — common for hosting both a modded and a vanilla server side by side, or a build/test instance alongside a live one — give each its own server.identity value and a fully distinct set of ports; reusing any single port across two instances on the same machine will cause one of them to fail to bind at startup. For custom maps rather than procedurally-generated ones, community tools let you browse and download hand-built maps, which you load by pointing server.levelurl at the map file’s download location instead of relying on server.seed. Finally, if you expect your player base or plugin list to grow significantly, consider running the server inside a Docker container from the start — it isolates dependencies cleanly and makes migrating to a larger host later a matter of moving one container rather than reinstalling the entire stack from Step 3 onward.

Frequently Asked Questions

What is the SteamCMD app ID for a Rust dedicated server?
258550. This is distinct from 252490, which is the player client’s app ID — using the wrong one downloads the game itself instead of the dedicated-server binary, and is a common first-time mistake.

How much RAM does a Rust server actually need?
Facepunch’s official wiki lists 12 GB as the standard baseline, with larger 6,000-unit maps needing more than that. Real-world hosting guides suggest 8 GB can work for a very small vanilla server with just a few friends, while modded servers supporting 50 to 100 players are better served by 16 to 24 GB to avoid crashes under real load.

Do I need to own Rust or have a Steam account to host a server?
No. SteamCMD’s anonymous login is entirely sufficient to download and run the dedicated server files — you only need a Steam account and a purchased copy of the game to connect and play as a client afterward.

Which ports does a Rust server need forwarded?
Three, at minimum: 28015/UDP for the game itself, 28016/TCP for RCON remote administration, and 28017/UDP for server-browser visibility. Set all three explicitly in your startup script rather than relying on Rust’s automatic, and sometimes ambiguous, default assignment.

How often does Rust wipe servers?
Facepunch forces a wipe on every server, official and community alike, on the first Thursday of each month, alongside smaller updates landing in between those monthly events. There’s no opt-out for the monthly forced update itself, though individual server owners remain free to schedule additional, more frequent wipes on top of it.

Should I choose Oxide or Carbon for mod support?
Oxide, also known as uMod, has the larger and more established plugin library built up over many years of community development. Carbon is a newer drop-in replacement designed for lighter resource use and faster restarts, and deliberately keeps Oxide’s plugin folder structure so switching between the two doesn’t require restructuring an already-working setup. Either is a reasonable choice for a new server; Carbon suits owners who specifically want a lighter-weight framework from day one, while Oxide’s plugin ecosystem depth still leads for finding an existing plugin for almost any feature idea.

Can I run a Rust server on Windows and switch to Linux later?
Yes. The RustDedicated files, Oxide or Carbon plugins, and save files are all cross-compatible between the two operating systems — only the startup script syntax, a batch file versus a shell script, actually differs between them.

How much does managed Rust server hosting cost?
Entry-tier managed hosting spans roughly $4.50 to $15 a month depending on the specific provider, slot count, and region, before accounting for introductory promotional discounts that several providers apply only to the first billing cycle before reverting to a higher renewal price.

For more dedicated-server and game-hosting tutorials, visit the Gaming section on shattered.io.