How to Install Space Engineers Dedicated Server on Ubuntu 24.04

Space Engineers is a sandbox game where physics, gravity, and voxel engineering collide -- and the best way to play with friends is to run your own Dedicated Server. Keen Software House only publishes a Windows build, but with Docker and Wine you can run it cleanly on Ubuntu 24.04 LTS and keep it up 24/7. This tutorial takes you from an empty VPS to a production server with workshop mods, SaveGame persistence, automatic crash recovery, and a proper systemd unit.

Heads-up: no one-click image yet. Space Engineers is not currently in our one-click catalog, but the manual install below is the same one our support team uses on customer servers.

Table of Contents

Why Self-Host Space Engineers?

Space Engineers is famous for large worlds with thousands of grids, complex scripts, and long-running survival campaigns. Managed hosts like Nitrado and Citadel do work, but self-hosting on your own VPS gives you concrete advantages:

• Full control over the world. You can SSH in, edit SpaceEngineers-Dedicated.cfg, inspect .sbs SaveGame files, or roll back to yesterday's backup. Most managed panels hide these files behind a restricted UI.
• Unlimited mod freedom. Managed hosts often cap the number of workshop subscriptions or limit which scripts can run. On your own box you choose exactly which mods and PB scripts load.
• Flat pricing. Managed SE hosting typically scales with slot count -- 10 slots at 20 EUR, 20 slots at 35 EUR, and so on. A CloudCore Business VPS costs the same whether it hosts 4 or 32 players (physics and RAM become the real bottleneck, not billing).
• Multi-service economics. The same VPS that runs your SE server can also host a Discord bot, a TeamSpeak instance, a small Rust server, or your clan website. You pay once for the whole machine.
• Better latency control. Pick the region closest to your players (we have EU, US, and AP locations) and stop fighting whatever datacenter your managed host happened to put you in.
• No data lock-in. Moving worlds between VPS providers is a single rsync away. Moving out of a managed panel often means tar-balling through their web UI and praying the export works.

Prerequisites and Recommended Plan

Space Engineers is RAM-heavy. The simulation stores every grid, every block, and every physics object in memory, and both physics and pathfinding scale poorly with world complexity. Undersized servers do not crash gracefully -- they stutter, desync, and eventually OOM-kill.

You will need:

• An Ubuntu 24.04 LTS VPS with root or sudo access
• At least 8 GB RAM (12 GB+ strongly recommended for modded worlds)
• 30 GB free disk (the game install is ~12 GB, SaveGames and backups grow over time)
• Ports 27016/UDP (game) and optionally 8080/TCP (remote API) open in your firewall
• An SSH client (Terminal on macOS/Linux, or PuTTY/Windows Terminal on Windows)

Recommended Plan: CloudCore Business

Space Engineers will eat whatever RAM you give it. We recommend the CloudCore Business plan as a solid starting point:

- 6 vCPU cores

- 12 GB RAM

- 200 GB NVMe SSD

- Unmetered 1 Gbps bandwidth

- From EUR 29.99 / month

If you plan to run 16+ players, heavy mods like Industrial Overhaul, or multiple persistent NPC factions, size up to a 16 GB or 24 GB plan. You can upgrade in place without rebuilding.

Connect to your server:

ssh root@your-server-ip

Step 1: Prepare the Ubuntu 24.04 VPS

Update the base system first. This picks up kernel, libc, and security patches, and ensures Docker's apt repository resolves cleanly.

sudo apt update && sudo apt upgrade -y

Install a few utilities we will use throughout the guide:

sudo apt install -y curl ca-certificates gnupg ufw nano htop

Configure the firewall. Allow SSH first (otherwise you will lock yourself out), then open the Space Engineers ports:

sudo ufw allow 22/tcp
sudo ufw allow 27016/udp
sudo ufw allow 8080/tcp
sudo ufw --force enable
sudo ufw status

Expected output:

Status: active
To                         Action      From
--                         ------      ----
22/tcp                     ALLOW       Anywhere
27016/udp                  ALLOW       Anywhere
8080/tcp                   ALLOW       Anywhere

If your kernel was updated during apt upgrade, reboot now:

sudo reboot

Step 2: Install Docker

Docker isolates the Wine prefix and all .NET dependencies inside a container so they never pollute the host. Install the official Docker CE packages:

sudo install -m 0755 -d /etc/apt/keyrings
curl -fsSL https://download.docker.com/linux/ubuntu/gpg | \
  sudo gpg --dearmor -o /etc/apt/keyrings/docker.gpg
sudo chmod a+r /etc/apt/keyrings/docker.gpg
echo "deb [arch=$(dpkg --print-architecture) signed-by=/etc/apt/keyrings/docker.gpg] \
https://download.docker.com/linux/ubuntu $(. /etc/os-release && echo $VERSION_CODENAME) stable" | \
  sudo tee /etc/apt/sources.list.d/docker.list > /dev/null
sudo apt update
sudo apt install -y docker-ce docker-ce-cli containerd.io docker-buildx-plugin docker-compose-plugin

Verify Docker is healthy:

sudo systemctl status docker --no-pager
docker --version

Expected output:

Docker version 26.1.3, build ...

Add your non-root user (optional but recommended) to the docker group so you can run commands without sudo:

sudo usermod -aG docker $USER
newgrp docker

Step 3: Pull the Space Engineers Image

Because Keen ships a Windows-only binary, we use a community Docker image that bundles Wine, .NET, and SteamCMD. The most widely-used image is 7thcore/space-engineers-dedicated-server. It installs the server via anonymous SteamCMD on first boot and runs it through Wine headlessly.

Pull the image:

docker pull 7thcore/space-engineers-dedicated-server:latest

Expected output (abbreviated):

latest: Pulling from 7thcore/space-engineers-dedicated-server
Digest: sha256:...
Status: Downloaded newer image for 7thcore/space-engineers-dedicated-server:latest

The image is around 2 GB on disk. The game itself (~12 GB) is downloaded on first container start into the data volume, not baked into the image.

Create directories on the host that we will mount into the container:

sudo mkdir -p /opt/spaceengineers/{instance,saves,mods,steamcmd}
sudo chown -R 1000:1000 /opt/spaceengineers

• /opt/spaceengineers/instance -- runtime config and SpaceEngineers-Dedicated.cfg
• /opt/spaceengineers/saves -- SaveGame worlds (persistent across restarts)
• /opt/spaceengineers/mods -- workshop mod cache
• /opt/spaceengineers/steamcmd -- SteamCMD binary + game install (~12 GB)

Step 4: First Run and Data Volumes

Do a first-run of the container in the foreground so you can watch the install log. This takes 10-20 minutes depending on your bandwidth: SteamCMD pulls the whole game install into the mounted steamcmd volume.

docker run -it --rm \
  --name space-engineers-init \
  -p 27016:27016/udp \
  -p 8080:8080/tcp \
  -v /opt/spaceengineers/instance:/home/steam/.local/share/SpaceEngineersDedicated \
  -v /opt/spaceengineers/saves:/home/steam/.local/share/SpaceEngineersDedicated/Saves \
  -v /opt/spaceengineers/mods:/home/steam/.local/share/SpaceEngineersDedicated/Mods \
  -v /opt/spaceengineers/steamcmd:/home/steam/steamcmd \
  7thcore/space-engineers-dedicated-server:latest

Expected output (abbreviated):

[INFO] Starting SteamCMD install of app 298740...
Success! App '298740' fully installed.
[INFO] Generating default SpaceEngineers-Dedicated.cfg
[INFO] Launching Space Engineers Dedicated Server through Wine...
wine: RLIMIT_NICE is <= 20, unable to use setpriority safely
Space Engineers Dedicated Server, build 1.207.021
...

When you see the server printing tick updates, the install has completed and a default config has been generated. Stop it with Ctrl+C so we can edit the config before the real run.

Step 5: Configure SpaceEngineers-Dedicated.cfg

The config file lives at /opt/spaceengineers/instance/SpaceEngineers-Dedicated.cfg on the host. Open it with nano:

sudo nano /opt/spaceengineers/instance/SpaceEngineers-Dedicated.cfg

You will see a large XML document. The fields you almost certainly want to change:

<?xml version="1.0" encoding="utf-16"?>
<MyConfigDedicated xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
  <SessionSettings>
    <GameMode>Survival</GameMode>
    <MaxPlayers>16</MaxPlayers>
    <MaxFloatingObjects>256</MaxFloatingObjects>
    <EnableCopyPaste>true</EnableCopyPaste>
    <AutoSaveInMinutes>5</AutoSaveInMinutes>
    <EnableOxygen>true</EnableOxygen>
    <EnableJetpack>true</EnableJetpack>
    <EnableVoxelDestruction>true</EnableVoxelDestruction>
  </SessionSettings>
  <ServerName>CloudCore SE Server</ServerName>
  <WorldName>MyColony</WorldName>
  <ServerDescription>Self-hosted Space Engineers on Ubuntu</ServerDescription>
  <ServerPort>27016</ServerPort>
  <SteamPort>8766</SteamPort>
  <AsyncSaving>true</AsyncSaving>
  <Scenario>EarthLikePlanet</Scenario>
  <IgnoreLastSession>false</IgnoreLastSession>
  <LoadWorld />
  <PauseGameWhenEmpty>true</PauseGameWhenEmpty>
  <Administrators>
    <string>YOUR_STEAM64_ID</string>
  </Administrators>
  <Banned />
  <Mods />
  <ServerPasswordHash />
  <ServerPasswordSalt />
  <RemoteApiEnabled>true</RemoteApiEnabled>
  <RemoteSecurityKey>CHANGE_ME_TO_A_LONG_RANDOM_STRING</RemoteSecurityKey>
  <RemoteApiPort>8080</RemoteApiPort>
</MyConfigDedicated>

Key fields to adjust:

• ServerName -- Shown in the public server list. Keep it under 60 characters.
• MaxPlayers -- Match this to your plan's RAM budget. 8 on 8 GB, 16 on 12 GB, 32 on 24 GB+.
• AutoSaveInMinutes -- Lower is safer, but each save pauses the simulation briefly. 5 is a good default.
• Administrators -- Paste your SteamID64 (find it at steamid.io). Admins can run /kick, /ban, and use creative tools.
• RemoteSecurityKey -- Generate a long random string: openssl rand -base64 32. Required if you ever want to manage the server via the remote API or tools like SEToolbox.
• PauseGameWhenEmpty -- Set to true to freeze physics when nobody is online. Massive CPU savings on quiet nights.
• Scenario -- Pick one of the built-in scenarios or leave blank to load a SaveGame from <LoadWorld>.

Step 6: Create a systemd Unit

Running docker run interactively is fine for testing, but production servers need to restart automatically after crashes and host reboots. We will wrap the container in a systemd unit.

Create the unit file:

sudo tee /etc/systemd/system/space-engineers.service > /dev/null <<'EOF'
[Unit]
Description=Space Engineers Dedicated Server (Docker)
Requires=docker.service
After=docker.service network-online.target
Wants=network-online.target
[Service]
Type=simple
Restart=always
RestartSec=15
TimeoutStartSec=0
ExecStartPre=-/usr/bin/docker stop space-engineers
ExecStartPre=-/usr/bin/docker rm space-engineers
ExecStart=/usr/bin/docker run --rm \
  --name space-engineers \
  -p 27016:27016/udp \
  -p 8080:8080/tcp \
  -v /opt/spaceengineers/instance:/home/steam/.local/share/SpaceEngineersDedicated \
  -v /opt/spaceengineers/saves:/home/steam/.local/share/SpaceEngineersDedicated/Saves \
  -v /opt/spaceengineers/mods:/home/steam/.local/share/SpaceEngineersDedicated/Mods \
  -v /opt/spaceengineers/steamcmd:/home/steam/steamcmd \
  --memory="10g" \
  --memory-swap="12g" \
  7thcore/space-engineers-dedicated-server:latest
ExecStop=/usr/bin/docker stop -t 60 space-engineers
[Install]
WantedBy=multi-user.target
EOF

Reload systemd and enable the unit so it starts on boot:

sudo systemctl daemon-reload
sudo systemctl enable --now space-engineers

Verify it is running:

sudo systemctl status space-engineers --no-pager

Expected output:

● space-engineers.service - Space Engineers Dedicated Server (Docker)
     Loaded: loaded (/etc/systemd/system/space-engineers.service; enabled)
     Active: active (running) since Thu 2026-04-16 12:00:00 UTC; 10s ago
   Main PID: 4567 (docker)

Follow the live log stream with:

sudo journalctl -u space-engineers -f

When you see Server is ready. Press Ctrl+C to exit. in the log, the world is live.

The --memory="10g" flag in the unit caps the container so a runaway simulation cannot OOM-kill the entire host. Adjust this to roughly 80% of your VPS RAM.

Step 7: Add Workshop Mods

Space Engineers mods are Steam Workshop items identified by a numeric ID. Find any mod in the Workshop and copy the ID from the URL (e.g. ?id=2333893162).

Stop the server before editing:

sudo systemctl stop space-engineers

Edit SpaceEngineers-Dedicated.cfg again and replace the empty <Mods /> tag with a populated block:

<Mods>
  <ModItem>
    <Name>2333893162.sbm</Name>
    <PublishedFileId>2333893162</PublishedFileId>
    <FriendlyName>Build Info</FriendlyName>
  </ModItem>
  <ModItem>
    <Name>1902970975.sbm</Name>
    <PublishedFileId>1902970975</PublishedFileId>
    <FriendlyName>Assertive Combat Systems</FriendlyName>
  </ModItem>
</Mods>

Restart the server:

sudo systemctl start space-engineers

On first start the server will download each mod via SteamCMD into /opt/spaceengineers/mods. Watch the logs:

sudo journalctl -u space-engineers -f | grep -i mod

You should see lines like Mod 2333893162 downloaded followed by Mods loaded successfully. If a mod fails to resolve, double-check the Workshop ID and make sure the mod targets the current SE build.

Step 8: Backups and Maintenance

Space Engineers saves the world as a folder of .sbs files inside /opt/spaceengineers/saves/<WorldName>/. Back these up regularly -- a corrupted save is one wrong explosion away.

A simple nightly cron backup:

sudo tee /etc/cron.daily/backup-space-engineers > /dev/null <<'EOF'
#!/bin/bash
TS=$(date +%Y%m%d-%H%M%S)
DEST=/opt/spaceengineers/backups
mkdir -p $DEST
tar -czf $DEST/se-saves-$TS.tar.gz -C /opt/spaceengineers saves
find $DEST -name "se-saves-*.tar.gz" -mtime +14 -delete
EOF
sudo chmod +x /etc/cron.daily/backup-space-engineers

This tarballs the SaveGames every night and keeps 14 days of history. For off-server backups, pipe it to rclone or rsync to S3/Backblaze.

To update the game itself, simply restart the container -- 7thcore/space-engineers-dedicated-server runs a SteamCMD update check on every start:

sudo systemctl restart space-engineers

To update the image (new Wine version, dependency fixes), pull and restart:

docker pull 7thcore/space-engineers-dedicated-server:latest
sudo systemctl restart space-engineers

Step 9: Connecting from the Client

On your gaming PC, launch Space Engineers and open the Join Game menu. Switch the filter from "LAN" to "Friends" or "Public" and click Direct Connect. Enter your VPS public IP followed by the port:

your-server-ip:27016

If you set a ServerPasswordHash, enter the password when prompted. You should appear in the lobby within a few seconds. From the F3 player list an administrator can promote, kick, or ban players.

Troubleshooting

FAQ

Can Space Engineers Dedicated Server run natively on Linux?

No. Keen Software House only ships a Windows binary for the Dedicated Server. On Ubuntu you run it through Wine, most easily packaged inside a Docker container that bundles a tested Wine prefix, .NET dependencies, and the SteamCMD installer. Keen have hinted at a native Linux build for Space Engineers 2, but for the current game Wine-in-Docker is the standard approach.

How much RAM does a Space Engineers server need?

Plan on 6-8 GB of RAM for a small 4-player world, 12-16 GB for 8-16 players with mods, and 24 GB+ for populated worlds with many grids, NPCs, and physics-heavy scenarios. Space Engineers is extremely memory-hungry because every grid, block, and voxel is simulated. Performance is almost always memory- and single-thread-CPU-bound, not disk-bound, so prioritise RAM and fast cores over storage size.

Do I need a Steam account on the server?

No. The Dedicated Server is a free download and can be installed through SteamCMD anonymously. The Docker image automates this step -- the first container start pulls the game into your mounted volume with no credentials required. You only need a Steam account if you want to download workshop mods that are tied to your library (most public mods are freely fetchable).

How do I add workshop mods?

Open SpaceEngineers-Dedicated.cfg and add each workshop item ID inside the <Mods> block (see Step 7 above). The server downloads mods automatically via SteamCMD on the next start and caches them in /opt/spaceengineers/mods. Restart the container after editing the config with sudo systemctl restart space-engineers. The order of mods in the config matters -- library mods that other mods depend on must appear first.

Which UDP port does Space Engineers use?

Port 27016/UDP is the default game port. If you run multiple instances on the same VPS, increment to 27017, 27018, and so on (change <ServerPort> in each config and map a new -p flag in your systemd unit). A separate TCP port (default 8080) can be exposed for the remote API if you enable RemoteApiEnabled=true. The Steam query port (8766/UDP) must also be reachable for the server to appear in public lobbies.

Is self-hosting cheaper than Nitrado or Citadel?

Yes, by a wide margin once mod counts or player counts grow. Managed Space Engineers hosts typically charge 15-25 EUR per month for a 10-slot server with modest RAM. A CloudCore Business VPS at 29.99 EUR gives you 12 GB RAM, full root access, unlimited slots, any mods you want, and the ability to run multiple unrelated services on the same box -- Discord bots, a website, a second game server. Across 12 months the savings usually exceed 150 EUR, and you own the whole stack.

Can I run other game servers alongside Space Engineers?

Absolutely. A 12 GB VPS has plenty of room for Space Engineers plus one or two lighter servers. Popular combinations: SE + a Rust server, SE + an ARK server, SE + a 7 Days to Die server, or SE + a Satisfactory server. Use Docker for each one so the dependency trees never collide, and cap each container's memory with --memory so one runaway server cannot kill the others.

Next Steps

You now have a production-grade Space Engineers server on Ubuntu 24.04. From here:

• Monitor RAM usage with docker stats space-engineers to catch memory creep early. If usage sits above 90% for hours at a time, upgrade to a larger CloudCore plan before the OOM killer does it for you.
• Enable the Remote API for tools like SEToolbox or Torch-compatible monitors. Point them at https://your-server-ip:8080 with the RemoteSecurityKey you generated.
• Add Programmable Block scripts via the Steam Workshop. Scripts are loaded per-grid, not server-wide, so players can share PB-heavy ships without server config changes.
• Run a second world on a different port (27017) with its own config, save directory, and systemd unit. Shared-nothing instances make it easy to host a PvE world and a PvP world on the same VPS.
• Set up Discord integration with a bot like Space Engineers Discord Connector to relay chat and player joins into your community server.

Need help sizing your server?

Our CloudCore support team runs Space Engineers on production customer VPSes every day and can recommend the right RAM/CPU mix for your player count, mod list, and world complexity. Launch a CloudCore Business VPS and open a ticket from the dashboard -- we will help you tune the config before your first raid night.