---
title: "How to Host a Rust Server"
description: "Host a Rust server yourself with SteamCMD: the 12 GB RAM requirement, install commands, startup parameters, ports, config files - and when renting wins."
url: "https://www.gameserverkings.com/knowledge-base/rust/how-to-host-a-rust-server/"
category: "Rust"
category_url: "https://www.gameserverkings.com/knowledge-base/rust/"
published: "2026-08-07T10:44:54.884Z"
updated: "2026-08-07T10:44:54.884Z"
source_format: "markdown"
site: "GameServerKings"
---

# How to Host a Rust Server

There are two honest answers to "how do I host a Rust server", and which one is right for you comes down to hardware and patience. You can install the dedicated server yourself with SteamCMD — it is free, Facepunch supports it, and it works on Windows, Linux or macOS. Or you can rent one and skip the parts that have nothing to do with running a community.

This guide covers the self-hosted route properly, because that is the actual question, and then tells you honestly where it stops making sense. Every command, convar and port below is taken from [Facepunch's own server documentation](https://wiki.facepunch.com/rust/Creating-a-server).

## 1. What You Need to Host a Rust Server

Facepunch publishes the requirements for a Rust dedicated server. They are higher than people expect:

| Requirement | Facepunch's figure |
| --- | --- |
| Operating system | "System based on Windows, Linux or OSX" |
| RAM | **12 GB free RAM** ("6k map will use more") |
| Disk space | **15 GB free disc space** ("SSD/NVMe highly preferred") |
| CPU | No figure given — "The more players, the faster your computer CPU needs to be" |
| Steam account | Not needed to install or run the server |

> [!IMPORTANT] The 12 GB RAM figure is the one that catches people out
> This is the single biggest difference between Rust and the games people have usually hosted before. A Minecraft server runs happily in 2–4 GB. Rust asks for **12 GB free** before you add a large map or plugins, and Facepunch explicitly warns a 6k map will use more. It is also the reason Rust hosting costs more than almost any other game — you are paying for memory.

Facepunch is careful to hedge these numbers, and so are we. In their words, these "values are not fixed and highly depend on the use case and population of the server." A ten-slot server on a 3000 map and a 200-slot server on a 6000 map are not the same machine.

Note the gap in that table: **there is no official CPU requirement**. Facepunch's only guidance is that more players need a faster CPU. From our own experience running Rust servers, what matters is single-thread speed rather than core count — Rust's main server loop does not spread across many cores, so a modern high-clock CPU beats a many-core one. [Rust Server Lag & Performance](/knowledge-base/rust/server-performance/) goes into why.

You will also need:

- A machine you can leave running. A Rust server that is only online when your PC is on will not hold a population.
- Ports open and reachable from the internet (covered in section 4).
- If you are behind a home router, port forwarding — and a static LAN IP for the server so DHCP does not move it.

## 2. How to Install a Rust Server with SteamCMD

SteamCMD is the canonical route and the one Facepunch documents. The Rust server **App ID is 258550**, and you do not need a Steam account — `anonymous` login works.

### Linux

Create a directory for the server and one for SteamCMD:

``` title="Create the directories"
cd /home/user_kuper
mkdir rust
mkdir steamcmd
cd steamcmd
```

Download and unpack SteamCMD, and make it executable:

``` title="Install SteamCMD"
wget https://steamcdn-a.akamaihd.net/client/installer/steamcmd_linux.tar.gz
tar xvfz steamcmd_linux.tar.gz
chmod +x steamcmd.sh
```

Now download the Rust server itself:

``` title="Download the Rust dedicated server"
./steamcmd.sh +force_install_dir ../rust +login anonymous +app_update 258550 validate +quit
```

> [!NOTE] You must include `+login anonymous`
> Facepunch's wiki is explicit about this: if you omit `+login` you will get the error `ERROR! Failed to install app '258550' (No subscription)`. The `anonymous` account is all you need — a Steam account with Rust is only required to *join* and play, not to install the server.

SteamCMD installs a basic `runds.sh` startup file. Return to the server folder and make it executable, then edit it to add your own settings:

``` title="Prepare the start script"
cd ../rust
chmod +x runds.sh
```

The Linux console is not interactive the way the Windows one is, so you will want either a log file or a `screen` session to watch output:

``` title="Run inside a screen session"
screen -S rust_server ./runds.sh
```

Press **CTRL+A** then **D** to detach and return to your terminal. Reattach later with `screen -x rust_server`.

### Windows

Windows uses the same SteamCMD program and the same App ID — download SteamCMD from Valve, then point it at a server directory and run `+login anonymous +app_update 258550`. You start the server by running `RustDedicated.exe` with your parameters, usually from a `.BAT` file so you do not retype them.

A common pattern from Facepunch's wiki restarts the server automatically when it stops:

``` title="RunServer.BAT — auto-restart loop"
:start
C:\Rust\SteamCMD\SteamCMD.exe +force_install_dir C:\Rust\MyServer\ +login anonymous +app_update 258550 +quit
RustDedicated.exe -batchmode +server.port 28015 +...(and any other parameter/variable you chose)
goto start
```

`goto start` sends the script back to `:start` whenever the server shuts down — through a crash or the `restart` command — so it updates and relaunches on its own.

> [!WARNING] Running SteamCMD on every start wipes Oxide and Carbon
> That update line keeps your files vanilla, which is exactly what you want on a plain server and exactly what you do not want on a modded one. As Facepunch puts it: "If you run SteamCMD in your startup script, your files will be reverted back to vanilla." If you use Oxide, you need to reinstall it after each update — see [How to install Oxide for Rust](/knowledge-base/rust/how-to-install-oxide/) and [How to install Carbon for Rust](/knowledge-base/rust/how-to-install-carbon/).

If you want to test unreleased features, SteamCMD can pull a beta branch instead — for example `app_update 258550 -beta staging`. Stick to the default public branch for a live community server.

## 3. Rust Server Startup Parameters You Actually Need

Your server needs to be told how to run. This is Facepunch's example Windows command line, unabridged:

``` title="Example startup command line"
RustDedicated.exe -batchmode +server.port 28015 +server.level "Procedural Map" +server.seed 1234 +server.worldsize 4000 +server.maxplayers 10 +server.hostname "Name of Server as Shown on the Client Server List" +server.description "Description shown on server connection window." +server.url "http://yourwebsite.com" +server.headerimage "http://yourwebsite.com/serverimage.jpg" +server.identity "server1" +rcon.port 28016 +rcon.password letmein +rcon.web 1 -logfile rustserverlog.txt
```

It looks like a wall, but each piece is small:

| Parameter | What it does | Notes |
| --- | --- | --- |
| `-batchmode` | Runs the server without a GUI | |
| `+server.port 28015` | The port players connect to | 28015 is default. UDP. |
| `+server.level "Procedural Map"` | Sets the map type | Currently the only option |
| `+server.seed 1234` | The random seed the map is generated from | Any value **0–2147483647** |
| `+server.worldsize 4000` | Map size | **Use 1000 to 6000.** Larger maps need more disk and memory |
| `+server.maxplayers 10` | Slot count | "The more players, the faster your computer CPU needs to be" |
| `+server.hostname "..."` | Server name in the client server list | |
| `+server.description "..."` | Text shown on the connection window | |
| `+server.url "..."` | Your website | Optional, can be omitted |
| `+server.headerimage "..."` | Banner image for your server | Optional, can be omitted |
| `+server.identity "server1"` | Internal server name | Creates the directory your server files live in |
| `+rcon.port 28016` | Remote admin port | TCP. **Defaults to `server.port`** |
| `+rcon.password letmein` | RCON password | Facepunch's own note: "Change this value!!!" |
| `+rcon.web 1` | RCON connection method | "rcon.web 1 is suggested" |
| `-logfile <name>` | Sends all console output to a file | Putting the date/time in the filename is suggested |

This is **not an exhaustive list** — Rust has far more convars than these. Once the server is running, use the `find` command in the console to search for others (for example, `find image`). [Rust Admin Commands](/knowledge-base/rust/admin-commands/) covers the ones you will use day to day.

> [!TIP] Change the RCON password before the server is ever publicly reachable
> `letmein` is Facepunch's placeholder, not a suggestion. RCON is full administrative control of your server. Set a long, unique password in the startup line before you open the port.

Two changes here are not like the others: **`server.seed` and `server.worldsize` regenerate the map**. Changing either means a fresh world, so decide them before you open to players. [How to change the map and map size on a Rust server](/knowledge-base/rust/rust-change-map-size-seed/) walks through that.

## 4. Which Ports Does a Rust Server Need?

A Rust server uses **four ports in total**. Only the first one is required to play — get that working, then add the others.

| Port | Default | Protocol | What it is for |
| --- | --- | --- | --- |
| `server.port` | **28015** | UDP | Game traffic. Players connect here |
| `server.queryport` | 1 + `server.port` or `rcon.port`, whichever is greater | UDP | Lets services query the server so it appears in the in-game browser |
| `rcon.port` | Equal to `server.port` | TCP | Remote admin tools |
| `app.port` | Game port + 67 (**28082** on default ports) | TCP | The Rust+ companion app |

Three rules from Facepunch's documentation that cause most of the "my server does not show in the list" tickets:

- **`server.port` and `server.queryport` both need to be open and reachable, and both are UDP.**
- **`server.port` and `server.queryport` can NOT be the same port.**
- The query port "is needed for your server to appear in the game's server browser list." If your server runs but nobody can find it, this is almost always why.

For Rust+, Facepunch notes the companion port must be TCP, reachable from the internet, and "must be 10000 or higher for it to be successfully reached by our Rust+ backend."

By default the server listens on `0.0.0.0`, meaning any IP pointed at the machine. You can restrict that with `+server.ip` — for example `+server.ip 192.168.1.2` to keep the server LAN-only.

> [!NOTE] If you are behind a home router, set the LAN IP static first
> Port forwarding sends traffic hitting your public IP on a given port to a specific machine on your network. If that machine's LAN IP changes via DHCP, the forwarding rule silently points at nothing. Facepunch also advises avoiding "both" or "all" if your router offers it as a protocol option — set UDP and TCP deliberately.

## 5. What Happens on First Boot

Start the server and a great deal of text will scroll past. Some of it will look like errors and can usually be ignored.

**It will take several minutes to fully start.** The server is generating an entire procedural world from your seed and world size, and a larger `worldsize` takes longer and uses more memory. Watch for this line:

``` title="The line you are waiting for"
Server startup complete
```

Once you see it, you can connect. If the server and the game are on the same machine, press **F1** in Rust and type `connect localhost:28015` (or whichever `server.port` you set). From another machine, use the server's IP in place of `localhost`.

If your server is on a private network — addresses starting `192.`, `172.` or `10.` are private and not reachable from outside — you will need your public IP and port forwarding for anyone else to join.

> [!NOTE] Your server's country can be detected wrongly
> Facepunch uses MaxMind to work out where a server is located, and it is occasionally wrong. Check in-game that your server shows the right country. If it does not, you can submit a data correction request to MaxMind; if you rent, your host can get their Geofeed data used instead, which fixes it for every server they run.

## 6. Where the Rust Server Config Files Live

Set only necessities like ports and RCON on the command line. For everything else, use a **`server.cfg`** file, which lives here:

``` title="Config location"
rust/server/<server.identity>/cfg/server.cfg
```

That `<server.identity>` is whatever you passed to `+server.identity` — so with `+server.identity "server1"` the path uses `server1`.

Three things to know about `server.cfg`:

1. The server **reads it at startup and it takes priority over anything set on the command line.**
2. You **do not** include the `+` or `-` prefix on variables in this file.
3. The server does not touch this file — you edit it manually.

An example, straight from Facepunch's wiki:

``` title="server.cfg"
server.maxplayers 10
server.hostname "Tom Server"
hackablelockedcrate.requiredhackseconds 600
```

> [!WARNING] Some variables cannot be set at startup at all
> Facepunch flags this explicitly: certain variables "wont work this way", the weather `_chance` variables being their example. Those must be set after the server is running, either manually in the console or through an RCON client.

The same `cfg` folder holds **`users.cfg`**, which is where admins and moderators are stored.

## 7. How to Make Yourself Admin

With the server running and you connected, run `users` in the server console to list players and find your SteamID, then grant yourself a role:

``` title="Grant owner or moderator"
ownerid 76561198123456789 "TomSmith"
moderatorid 76561198123456789 "TomSmith"
```

You need to **reconnect** for the auth level to apply — when you rejoin you should see `has auth level` in the console or log file. Facepunch's wiki states this is saved automatically now, so no separate save step is required.

If the server is shut down, you can instead edit `users.cfg` in the `cfg` folder directly, one line per admin, in the form `ownerid 76561198123456789 "TomSmith" ""`.

For what to do with those powers, see [Rust Admin Commands: The Complete List](/knowledge-base/rust/admin-commands/) and [How to use external Rust Rcon tools](/knowledge-base/rust/how-to-use-external-rcon-tools/).

## 8. How Much Does It Cost to Run a Rust Server?

There is no single number, but the cost drivers are predictable, and **RAM is the dominant one**. That 12 GB requirement is why Rust hosting is priced well above most other games.

**Self-hosting on hardware you already own** costs you electricity, your internet connection's upload bandwidth, and the 12 GB of RAM plus 15 GB of SSD that the server occupies while it runs. If the machine is also your gaming PC, the real cost is that you cannot use those resources for anything else, and the server is offline whenever the PC is.

**Self-hosting on rented hardware** — a VPS or dedicated box — means paying for a machine with at least 12 GB of free RAM, fast single-thread CPU and NVMe storage. Prices vary far too much by provider and region for us to quote a figure we have not verified, but a box meeting Rust's requirements is not a budget VPS.

**Renting a game server** bundles the hardware, the DDoS protection and the setup. For reference, our own [Rust server plans](/games/rust-server-hosting/) start at **$12.00/month**, and the configuration we recommend for Rust — **12 GB RAM, 20 GB NVMe, 1.5 vCores** — comes to **$17.00/month** at the time of writing. Note that the recommended memory is 12 GB precisely because that is Facepunch's stated requirement.

Costs that catch people out either way:

- **Bandwidth.** A populated Rust server is a constant stream of UDP traffic. Residential upload is often the real ceiling on a home-hosted server, not the CPU.
- **DDoS protection.** A public Rust server with a healthy population *will* attract attacks — this is normal, not bad luck. Home connections have no defence, and getting your whole household's internet knocked offline is the usual outcome.
- **A dedicated IPv4 address**, if you want one that is not shared.
- **Your time.** Updates land often, and Oxide or Carbon needs reinstalling after each one.

## 9. Should You Self-Host or Rent a Rust Server?

Self-hosting is genuinely the right answer in several cases, and we would rather say so than pretend otherwise:

**Self-host when:**

- You are testing plugins, learning, or building a map, and nobody else needs to reach it.
- You want a private server for you and a few friends on a LAN.
- You already own a spare machine with 12 GB of RAM going unused, and you enjoy the administration.
- You want total control of the filesystem and no provider between you and the server.

**Renting starts to win when:**

- You want the server reachable 24/7, including while your PC is off or updating.
- You are opening it to the public — at which point DDoS protection stops being optional.
- Your home upload bandwidth cannot carry a populated server.
- Your players are geographically spread and you need decent routing to them.
- You would rather spend your time on the community than on SteamCMD, port forwarding and update cycles.

The honest summary: **self-hosting Rust is not hard, it is just relentless.** The install is a single SteamCMD command. Keeping a public server updated, protected and online through wipe day is the part that turns into a job.

If you do go the rented route, [Getting started with your Rust server](/knowledge-base/rust/rust-startup/) picks up from there — logging into the panel, first boot and connecting.

## 10. FAQ

### What are the requirements for a Rust server?

Facepunch lists a system running Windows, Linux or OSX, **12 GB of free RAM** (noting that a 6k map will use more), and **15 GB of free disk space**, with SSD or NVMe "highly preferred". No specific CPU is given — their guidance is only that the more players you host, the faster the CPU needs to be. Facepunch also stresses these values "are not fixed and highly depend on the use case and population of the server."

### What hardware do I need to run a Rust server?

Enough RAM that the server never has to swap — 12 GB free is the documented starting point, and larger maps and populations need more. Storage should be SSD or NVMe rather than a mechanical drive. For CPU, there is no official figure, but in our experience Rust's server loop depends on single-thread speed more than core count, so a modern high-clock processor matters more than a high core count.

### How much RAM does a Rust server need?

Facepunch's documented requirement is **12 GB of free RAM**, and they explicitly note a 6k map will use more. Memory use also grows with player count, entity count (bases and deployables) and plugin load, so a server late in a wipe uses considerably more than one on wipe day.

### How much does it cost to run a Rust server?

It depends on whether you own the hardware. On a machine you already have, the cost is electricity, bandwidth, and the 12 GB of RAM tied up while it runs. Renting bundles hardware, DDoS protection and setup — our own Rust plans start at $12.00/month, with the 12 GB configuration we recommend at $17.00/month at the time of writing. Prices elsewhere vary widely; the constant is that Rust's 12 GB memory requirement puts a floor under what any provider can charge.

### Do I need a Steam account to host a Rust server?

No. Facepunch is explicit: "You do NOT need a Steam account to install and run a Rust server, but you will need a steam account with Rust to join and play." SteamCMD downloads the server files using the `anonymous` login.

### What ports do I need to open for a Rust server?

At minimum `server.port` — **28015 by default, UDP** — which is what players connect to. To appear in the in-game server browser you also need `server.queryport` open, which is also UDP and defaults to 1 above whichever of `server.port` or `rcon.port` is greater. The two cannot be the same port. `rcon.port` (TCP) is needed for remote admin tools, and `app.port` (TCP, 28082 on default ports) for the Rust+ companion app.

### Can I host a Rust server on my own PC?

Yes. It needs 12 GB of free RAM and 15 GB of disk on top of whatever else the machine is doing, and if you want other people to join you will need port forwarding on your router and a static LAN IP for the machine. It works well for testing and for playing with friends. It works poorly for a public server, because the machine has to stay on permanently, your upload bandwidth limits how many players you can carry, and a home connection has no DDoS protection.

### How long does a Rust server take to start for the first time?

Several minutes. The server downloads its files through SteamCMD and then generates an entire procedural map from your seed and world size, and a larger `worldsize` takes longer. Watch the console for `Server startup complete` — that is the signal you can connect.

## 11. What to Read Next

- [Getting started with your Rust server](/knowledge-base/rust/rust-startup/) — first boot, connecting and the basics on a hosted server
- [How to install Oxide for Rust](/knowledge-base/rust/how-to-install-oxide/) — plugin support, and the first thing most owners add
- [Rust Admin Commands: The Complete List](/knowledge-base/rust/admin-commands/) — the commands worth knowing once you are admin
- [Rust Server Lag & Performance: How to Fix It](/knowledge-base/rust/server-performance/) — diagnosing lag and right-sizing hardware
- [When Is the Next Rust Wipe?](/knowledge-base/rust/wipe-day-guide/) — wipe schedules and how to wipe properly
- [How to change the map and map size on a Rust server](/knowledge-base/rust/rust-change-map-size-seed/) — seed and world size in practice

---

Made with 💜 by GameServerKings