Set Up a Rust Dedicated Server on Ubuntu: First Launch

To set up a Rust dedicated server on Ubuntu, install App ID 258550 into a separate directory, run it as a non-root account, wait for Server startup complete, and test localhost before opening access to friends. This is a manual Ubuntu path for PC Rust. It separates package installation, server readiness, player connection and outside networking so one green check does not hide a later failure.

The commands below use /opt/rust and a disposable identity named b03-proof. Change those names before using an existing world. Facepunch’s current guidance lists 12 GB of free RAM and 15 GB of free disk, with SSD or NVMe preferred; those are starting requirements, not a capacity guarantee for a map, plugin stack or player count.

Check Ubuntu, architecture and headroom before installing#

Start by recording the operating system, CPU architecture, memory and disk that will host the server. A dedicated process is separate from the Rust client, and the server machine still needs headroom for the operating system and any other workload. Do not convert a catalog plan or one successful boot into a universal player limit.

1. Confirm the Ubuntu release and architecture

   Run the commands below as your normal administrator account. Keep the output with the server notes. The lab evidence for this guide used Ubuntu 26.04 amd64; ARM64 compatibility for the Rust dedicated binary was not established.

2. Check free resources, not installed capacity

   Compare the available memory and disk with the current Facepunch guidance. If the host is already busy, stop here and resize or choose another machine before world generation begins.

cat /etc/os-release
uname -m
free -h
df -h /

The architecture you want to see for this tested route is x86_64. Ubuntu’s release documentation lists more than one supported architecture, but that does not prove that RustDedicated runs natively on each of them. If you are on ARM64, treat the platform as a separate compatibility investigation rather than copying these commands into production.

The current Facepunch page also says that a Steam account is not required to install and run the server, while the person who joins needs a Steam account with PC Rust. This guide therefore keeps the server download and the player connection check as separate requirements. It does not describe Console Edition hosting or PC-console crossplay.

Create a service user and an owned Linux workspace#

Use a dedicated account before downloading server files. That makes a bad launch less likely to write into an administrator’s home directory and gives you a concrete ownership check when the server cannot save. The account is an operating-system boundary, not a Rust player permission or a whitelist.

sudo useradd --system --user-group --home-dir /opt/rust --shell /usr/sbin/nologin rustsrv
sudo install -d -o rustsrv -g rustsrv -m 0755 /opt/rust/steamcmd
sudo install -d -o rustsrv -g rustsrv -m 0755 /opt/rust/server
sudo -u rustsrv mkdir -p /opt/rust/server/server/b03-proof/cfg

Check the account and directories before installing anything else:

getent passwd rustsrv
stat -c '%U:%G %a %n' /opt/rust /opt/rust/steamcmd /opt/rust/server

The two directories should belong to rustsrv:rustsrv. If you already created them with sudo and they show root:root, correct ownership before SteamCMD or RustDedicated creates files:

sudo chown -R rustsrv:rustsrv /opt/rust

The server.identity value used later selects the data directory under server/. Our Rust server identity guide shows how to verify that separate PC instances load separate save paths. Keep b03-proof disposable until a stop and reload test has passed. Do not point this first launch at a friend’s live world.

Install the Ubuntu dependencies and Rust files#

Install the package envelope, download SteamCMD from the official Linux tarball, and use anonymous login for Rust App ID 258550. The package list below was exercised in a clean Ubuntu 26.04 amd64 container for the download/bootstrap path. It is not an official minimum-dependency matrix, so recheck it on your selected Ubuntu release.

sudo apt update
sudo apt install -y ca-certificates curl tar lib32gcc-s1 libc6-i386 lib32stdc++6

Fetch and extract SteamCMD as rustsrv, then install the public Rust dedicated package into the explicit server directory:

sudo -u rustsrv curl -fL \
  https://steamcdn-a.akamaihd.net/client/installer/steamcmd_linux.tar.gz \
  -o /opt/rust/steamcmd/steamcmd_linux.tar.gz

sudo -u rustsrv tar -xzf /opt/rust/steamcmd/steamcmd_linux.tar.gz \
  -C /opt/rust/steamcmd
sudo chmod +x /opt/rust/steamcmd/steamcmd.sh

sudo -u rustsrv /opt/rust/steamcmd/steamcmd.sh \
  +force_install_dir /opt/rust/server \
  +login anonymous \
  +app_update 258550 validate \
  +quit

Facepunch’s current server guide documents this App ID, the anonymous login and the same Linux SteamCMD route. Wait for SteamCMD’s completion output, then check the executable and its owner:

test -x /opt/rust/server/RustDedicated && echo 'RustDedicated is executable'
stat -c '%U:%G %a %s %n' /opt/rust/server/RustDedicated

The lab completed app_update 258550 validate and bootstrapped RustDedicated with protocol 2633.288.1, build date 2026-09-16 and changeset 164530. That is a dated verification record, not a version pin. Install the current public package when you follow this guide.

If the service account’s first launch reports that it cannot load steamclient.so, check the file shipped beside RustDedicated and give the service account the SDK path the runtime is looking for:

sudo -u rustsrv mkdir -p /opt/rust/.steam/sdk64
sudo -u rustsrv ln -sf /opt/rust/server/steamclient.so \
  /opt/rust/.steam/sdk64/steamclient.so

This is a runtime-path check, not a reason to run the server as root. Keep the link inside the same installation tree and record it with the rest of the setup.

If SteamCMD exits before its completion message, save its first useful error. A directory containing a few files is not proof that the package is complete. The broader Rust hosting route explains how this Ubuntu path fits with Windows, managed hosting and network checks; a future SteamCMD maintenance guide will own repeat-update workflows.

Launch RustDedicated from its own directory#

Start from /opt/rust/server, not from / or the SteamCMD folder. RustDedicated resolves bundled files relative to its working directory, and a correct binary can fail immediately when launched from the wrong place. Keep the first map small and disposable while you validate the process.

Create a launch script owned by rustsrv:

sudo -u rustsrv tee /opt/rust/server/start-rust.sh > /dev/null <<'EOF'
#!/usr/bin/env bash
set -euo pipefail
cd /opt/rust/server
exec ./RustDedicated -batchmode -nographics \
  +server.identity b03-proof \
  +server.port 28015 \
  +server.queryport 28016 \
  +server.level "Procedural Map" \
  +server.worldsize 1000 \
  +server.seed 1234 \
  +server.maxplayers 4 \
  +server.hostname "Ubuntu local test" \
  -logfile /opt/rust/server/b03-first-start.log
EOF
sudo chmod 0750 /opt/rust/server/start-rust.sh

Run it in a terminal or an approved session manager as the service user:

sudo -u rustsrv /opt/rust/server/start-rust.sh

The game port and query port are deliberately explicit and separate. Both are UDP. This local baseline does not open a firewall, forward a router port, configure RCON or install plugins. Those are separate changes that should happen only after the manual launch is understandable.

The corrected amd64 lab launch reached Server startup complete after the runtime path was available. It used a small disposable world and the b03-proof identity. That proves this installation path reached readiness in the lab; it does not prove a player can join from another machine or that this map size fits a community.

Read the readiness log and test the local PC path#

Wait for the current launch’s readiness marker before trying to connect. Facepunch documents Server startup complete; a running PID, a SteamCMD success message or a quiet terminal is weaker evidence. Search the current log, not an old file left by an earlier attempt.

grep -F 'Server startup complete' /opt/rust/server/b03-first-start.log

If the command returns the marker, record the timestamp and the identity/port values used for that launch. If it returns nothing, inspect the last lines and keep the first useful error:

tail -n 80 /opt/rust/server/b03-first-start.log

Only after readiness should you test the player path. On a licensed PC Rust client running on the same machine, press F1 and enter the game port from the script:

connect 127.0.0.1:28015

This check requires the PC client; it is not a PowerShell or server-console command. Reaching the intended world proves more than seeing a connection attempt in a log. Create one disposable object, leave normally, and record whether it is still present after the same identity is reloaded.

Stop cleanly and verify the identity before supervision#

Do not add systemd, a restart loop or a public firewall rule until the manual process has a known stop and reload path. B16 owns persistent systemd supervision; this guide stops at the baseline it needs. On Linux, Facepunch notes that the console is not interactive like Windows, so use an authorized local terminal path or a restricted RCON client for the command your current launch supports. Do not expose RCON broadly just to avoid a terminal check.

When the server is ready, use the documented graceful command through that authorized path:

sv quit

Wait for the process to exit, then inspect the same identity rather than searching the whole disk:

pgrep -af RustDedicated || true
find /opt/rust/server/server/b03-proof -maxdepth 3 -type f -printf '%p %s bytes\n' | sort
stat -c '%U:%G %a %n' /opt/rust/server/server/b03-proof \
  /opt/rust/server/server/b03-proof/cfg

The files should remain under the service account’s ownership. Relaunch the exact script and look for the same identity loading its existing data. If the path appears empty or becomes a new world, stop and compare the installation directory, server.identity, map settings, working directory and ownership before deleting anything.

The corrected lab launch loaded the existing b03-proof identity on its second start, wrote a .sav file, reported Saving complete and exited with the files still owned by rustsrv. That verifies the disposable process path and same-identity save handling on Ubuntu 26.04 amd64. It did not include a licensed PC client, so player entry and the outside network path remain your acceptance checks. A saved file is not the same as a verified recovery set; keep destructive backup and restore work separate.

Choose the next operating boundary for your Ubuntu server#

You now have a clean decision point. Keep self-hosting if you can patch Ubuntu, watch the process, protect the files and test recovery. Continue with the complete setup route and its network checks after the localhost pass. Do not jump directly to port forwarding while the readiness or identity checks are red.

If Linux maintenance no longer fits the group’s schedule, we recommend Game Hosting’s Rust PC hosting for its integrated panel and free backups. Ask about the import and access operations your world needs before moving it. This product is for PC Rust, not Console Edition; a managed server does not remove the need to verify your data and the player path.

Keep the release output, package command, launch script, current log and identity inventory together. Add one operational change at a time, then repeat the acceptance check that it could affect.