# Unturned Server Hosting - everything RE:NODE has published

> A Unturned server on RE:NODE: plans, how the panel runs it, and every tutorial RE:NODE has published about it.

Generated from https://www.renode.space/game-servers/unturned, the live catalogue, the deploy docs, the panel guides and the RE:NODE blog. English. Source of truth for anything that changes: https://www.renode.space/game-servers/unturned.

Contents: what it is, plans and prices, panel how-to, tutorials, rules for the assistant.

## What it is

Unturned servers with RocketMod already installed. Free to play, so your whole group can join without buying anything.

- Genres: Action, Adventure, Casual, Indie
- Developer: Smartly Dressed Games
- Released: 7 Jul, 2017
- Steam: https://store.steampowered.com/app/304930/

### You supply one thing yourself

Unturned is only sold with a credential its publisher issues to a person, so you need to own the game yourself and provide it after checkout. We cannot create it for you and we never share one between customers. Your server is built immediately; the game installation waits until you paste it into the Setup tab, then runs itself.

### What comes with every Unturned server

- Configured before you see it: The install runs, the configuration is written and the server starts. No first-boot checklist, and nothing left on a default password shared with every other Unturned server on the internet.
- The real console: Live output, command input and the server's own logs - not a filtered summary. Web-server noise is folded behind a counter you can switch off.
- Files and SFTP: A full file manager with an editor, plus SFTP credentials. Upload mods, edit configs, pull a world down to your machine.
- 2-2 backup slots: Taken on demand or on a schedule, restored with a button. Deleting a server takes its backups with it, on purpose.
- 2 ports allocated: Add and remove ports yourself from the Network tab, including the query and RCON ports where the game wants them.
- People on the same server: Invite friends or staff with granular permissions - console only, files only, no billing - through subusers, roles and teams.

### Which Unturned plan do you need?

Memory is what decides whether a server holds together, so start there. The Starter tier gives 2 GB and 1 vCPU, which suits a private group. The Advanced tier at 4 GB is where most public servers sit, and Premium at 8 GB exists for the servers that stay full.

Storage matters more than people expect once mods and backups are involved - plans here run from 10 GB to 30 GB of NVMe. Moving up or down a tier later does not rebuild your world; it changes the limits on the container you already have.

If you are not sure, take the middle tier. It is cheaper to move up after a busy weekend than to spend one explaining lag to your players.

More game servers: https://www.renode.space/ai/game-servers.md

### General questions

### Getting started

**How quickly is my server ready?**

Game, app, web and database servers are created the moment payment clears, usually inside a minute. The game or runtime is installed and started for you, and the console is live in your browser while it happens. VDS and dedicated servers are prepared by hand and delivered within 24 hours.

**Do I need to configure anything before it works?**

No. The install runs, the configuration is written, and admin passwords are generated for your server rather than shared with everybody else's. The exception is four games whose publisher issues a credential to a person - those say so on the shop before you pay, and ask for it on a Setup tab afterwards.

**Which games need a key from me?**

Counter-Strike 2 needs a Steam game-server token, Don't Starve Together a Klei cluster token, FiveM a Cfx.re licence, and DayZ, Project Zomboid, 7 Days to Die, Arma 3 and Unturned need a Steam account or token of your own. We cannot create any of them and we never share one between customers. Your server is built immediately and the installation waits until you paste yours in.

**Can I try before buying?**

There is no free tier. The entry plans start at $1.50 a month precisely so that trying something costs about as much as a coffee.

**Can Claude or ChatGPT set my project up?**

Yes, and the panel gives it what it needs. On a server's Console tab, pick a purpose and press Connect AI: the panel copies a private link with the runtime, the port the code must read from SERVER_PORT, the code path, the GitHub branch, the databases and the limits. Paste it into Claude, ChatGPT or any assistant that can open links; the same link followed by /mcp works as an MCP server URL. It stops by itself after 7 days unused. You can also connect Claude, or any MCP client, to your whole account at https://panel.renode.space/api/client/mcp. Linked repositories get a pre-flight check that shows what will break before a deploy, no AI needed. No password or token is ever shown to the assistant - the AI setup page explains it all.

### Running the server

**Do I get full file access?**

Yes - a complete file manager with an in-browser editor, plus SFTP credentials. There is no plan on which the file manager is disabled or read-only.

**Can I install mods and plugins?**

Yes. Upload them through the file manager or SFTP, or use the game's own workshop support where it has any. Nothing here whitelists which mods you are allowed to run.

**Can other people help me run it?**

Yes. Invite subusers with granular permissions - console only, files only, no billing - or build a team with a role and grant it access to several servers at once. Permissions are a union, so nobody loses access they were given elsewhere.

**What happens if my server runs out of memory?**

New servers are configured so the kernel stops the container and it restarts clean, rather than swapping and dragging the whole machine down. If a server restarts repeatedly we warn you on the server page and open a support ticket before anything is suspended - you get told twice before it stops.

**Is the CPU limit a hard limit?**

Yes, and it cannot be breached: the container is throttled to the share you bought. A server sitting at 100% is slow, not broken, and is never suspended for it.

### Backups and safety

**Are backups included?**

Every plan carries backup slots - two on the entry tiers, more further up. Take them on demand or on a schedule, and restore with a button rather than a support ticket.

**Where are backups stored?**

Off the machine they protect. A backup sitting on the same disk as the thing it is insuring covers you deleting your world and covers nothing at all about the disk failing.

**What happens to my backups if I cancel?**

Deleting a server deletes its backups with it, deliberately and including locked ones. Download anything you want to keep first - the panel lets you.

### Billing

**How do I pay?**

PayPal, card, your wallet balance, or bank transfer. Every method produces a proper invoice you can download or print, with our details and the bank account on it while it is unpaid.

**Can I pay in Georgian lari?**

The panel displays every figure in lari at the National Bank of Georgia's published rate, marks converted figures as approximate, and always shows the amount that will actually be charged. Invoices stay in the currency they were raised in, because an invoice is a demand for a specific amount.

**What happens when my subscription is due?**

An invoice is raised and emailed to you seven days before expiry, and again on the day. Paying it settles that same document rather than raising a second one.

**Can I upgrade or downgrade later?**

Yes, and it does not rebuild anything. Changing plan changes the limits on the container you already have - your world, files and database stay exactly where they are.

**Do you offer refunds?**

There is no automatic refund button. If a server cannot do what it was sold to do, open a ticket and we will sort it out - including refunding you. We would rather fix the plan than argue about the policy.

### Support and the honest bits

**How do I get help?**

Open a ticket from the panel - it reaches every member of staff and every administrator, not a queue aimed at nobody in particular. Attach a screenshot if it helps; attachments are private to your ticket rather than sitting at a guessable public URL. Discord is there for faster, less formal questions.

**Where are the servers?**

Germany, on hardware we run. That is one location: if you need players in another region on a low ping, say so before buying rather than after.

**Is there an uptime guarantee?**

We measure node availability every five minutes and report it in the panel rather than printing a number with four decimal places we have not earned. If something is down you will usually hear it from us first.

**Who actually runs this?**

A small team that writes the panel, the shop and the automation itself. When something is wrong the fix is a code change, which is why the list of things wrong keeps getting shorter.

## Plans and prices

Read from the live catalogue at 2026-10-15 02:50 UTC. Prices are in US dollars per month; checkout also takes Georgian lari and bills for 1, 3, 6, 12 or 24 months. Prices change - re-check on https://www.renode.space/game-servers/unturned or in the panel shop at https://panel.renode.space before quoting one.

- You supply: Steam game server token - Valve issues one free token per server to any Steam account. Create one for app ID 304930 (Unturned) and paste it here. Unturned will not start without it, which is why we hold the installation until it is set. (https://steamcommunity.com/dev/managegameservers)

| Plan | Price / month | Memory | CPU | NVMe disk | Databases | Backups | Ports |
|---|---|---|---|---|---|---|---|
| Starter | $6 | 2 GB | 1 vCPU | 10 GB | 1 | 2 | 2 |
| Standard | $9 | 3 GB | 1.5 vCPU | 15 GB | 1 | 2 | 2 |
| Advanced | $12 | 4 GB | 2 vCPU | 20 GB | 1 | 2 | 2 |
| Pro | $16 | 6 GB | 2.5 vCPU | 25 GB | 1 | 2 | 2 |
| Premium | $20 | 8 GB | 3 vCPU | 30 GB | 1 | 2 | 2 |


## Panel how-to

From the panel guides at https://www.renode.space/guides.

### Ordering a server

Ordering takes about a minute and happens in three screens: find what you want to run, pick a plan, and pay. Pay by card or PayPal and the server is set up the moment the payment goes through - you can watch it install in its console.

- Takes: About a minute
- Pay with: Card, PayPal or bank transfer
- Billed for: 1, 3, 6, 12 or 24 months
- Prices in: US dollars or Georgian lari

Open the shop and find what you want to run:

1. Sign in to the panel and open the shop. The tabs along the top are the product lines: VDS, Game Servers, App Hosting, Web Hosting and Databases.
2. Find your game - there is a search box - and press View plans. The card already shows the lowest price and the range of memory on offer.

Compare the plans and pick one:

3. Every plan lists its memory, CPU and NVMe storage, roughly how many players it suits, and what is included - updates, backup slots, file and SFTP access.
4. Press Get Started on the one you want. Not sure? Start smaller: you can move to a bigger plan later without losing your world.

Choose how long, then pay:

5. Pick a billing period - 1, 3, 6, 12 or 24 months. The total for the whole period is shown before you pay, so there are no surprises.
6. Pay with PayPal, or press Debit or Credit Card - paying by card does not need a PayPal account. The server is created as soon as the payment completes.

Paying by bank transfer instead: Prefer to pay from your bank? Choose bank transfer at checkout. The server is set up once the payment arrives, usually the next working day.

1. Switch the payment tab to Bank transfer. The account details for Bank of Georgia and TBC Bank appear, each with a Copy button.
2. Press Order & get invoice, then pay that invoice from your banking app, quoting the reference on it.

After you pay:

- The server appears under My Servers and installs itself. Open it to watch the install in the console.
- Your orders, invoices and subscriptions are under Finances in the side menu.
- Stuck at any step? Open Support in the side menu and raise a ticket.

### The console

Live output, a command line, power controls and the resource graphs. It is the server's own output rather than a filtered summary - if the game prints it, you see it.

- Start, stop, restart and kill, with the current state always visible.
- Command history with the arrow keys, and tab completion for common commands.
- Web-server noise - the internet knocking on doors that are not there - is folded behind a count you can switch off. A real error always prints.
- Graphs for memory, CPU and disk against your limits, so whether it is the plan or the mod is answerable.

### Files and SFTP

A complete file manager with an editor in the browser, plus SFTP credentials for the tools you already use. Upload a modpack, fix a config, pull a world down to your machine.

- Drag files in, or upload a folder. Archives can be unpacked in place.
- Edit any text file with syntax highlighting and save without downloading it.
- PDFs and images preview in the panel rather than downloading first.
- SFTP on the same credentials - use FileZilla, WinSCP or your editor's remote mode.

### Backups

Take one before you try something. Restore it when the something goes wrong. Lock the ones that matter so they are not rotated away.

- Slots on every plan - two on the entry tiers, more further up.
- Take one on demand, or on a schedule you set.
- Download any backup to your own machine.

> Important: Deleting a server deletes its backups, including the locked ones. A lock stops you removing a backup by accident; it is not a claim on the disk after the server is gone. Download what you want to keep before you cancel.

### Subusers, roles and teams

Give somebody the console without giving them your files, or the files without your billing. Three separate ideas, kept apart deliberately.

- A role holds permissions - what may be done.
- A team holds people.
- A grant joins a team to a server with a role, so adding a moderator to the team gives them the same access everywhere at once.
- Invite by link, by a join code, or by email address - and require approval on the codes if you would rather vet people.
- Access can be time-boxed, and expiry stops working immediately rather than overnight.

### Scheduled tasks

Restart nightly, back up before the restart, announce it to players first. Tasks run in order with delays between them, so a schedule can be a small routine rather than one action.

- Send a console command - a warning to players, a save, a world flush.
- Take a backup.
- Power actions: start, stop, restart.

### Games that need a key from you

A few games want a credential their publisher issues to a person - a Steam game-server token, a Steam account that owns the server files, a Klei cluster token, a Cfx.re licence. We cannot create one and we never share one between customers.

> Note: Those games say so on the shop before you pay. Your server is built immediately, and the game installation is held until you paste the value into a Setup tab, because installing without it produces a server with no game files in it and no explanation.

## Tutorials

5 posts, newest first. Each one follows in full after the list.

- [Unturned OpenMod plugins and permissions](https://www.renode.space/blog/unturned-openmod-plugins) (2026-10-07): OpenMod on an Unturned server: how it differs from RocketMod, installing it beside Rocket, NuGet plugins, YAML roles and permissions, and load errors.
- [Unturned server Config.json and Commands.dat](https://www.renode.space/blog/unturned-server-config-commands-dat) (2026-10-07): What every section of the Unturned server config controls - Browser, Server, Items, Zombies, Vehicles, Players, Gameplay - and how it fits with Commands.dat.
- [Unturned workshop maps and mods on a server](https://www.renode.space/blog/unturned-workshop-maps-and-mods) (2026-10-07): Adding Steam Workshop maps and mods to an Unturned server: WorkshopDownloadConfig.json, map names, asset packs, ID conflicts, update shutdowns and join errors.
- [Unturned Commands.dat and RocketMod plugins](https://www.renode.space/blog/unturned-commands-and-rocketmod) (2026-09-21): Every Unturned server command, what belongs in Commands.dat versus the console, and installing RocketMod (LDM): permissions groups, cooldowns, plugins and OpenMod.
- [Unturned server setup with maps and RocketMod](https://www.renode.space/blog/unturned-server-setup) (2026-06-26): Setting up an Unturned dedicated server: Commands.dat, the gameplay config, ports and the GSLT, workshop maps and mods, admins, RocketMod and the usual errors.

---

### Unturned OpenMod plugins and permissions

Published 2026-10-07 by RE:NODE Team. https://www.renode.space/blog/unturned-openmod-plugins

OpenMod is the newer of Unturned's two plugin frameworks. It installs as a module beside the game, keeps its files in an `OpenMod` folder inside your server instance, installs plugins as NuGet packages with `openmod install <PackageId>`, and controls who can run what through two YAML files: `openmod.roles.yaml` and `openmod.users.yaml`. It does not replace RocketMod. It is designed to run alongside it, can load Rocket plugins through a compatibility layer, and can share Rocket's permission data. The practical rule for choosing: most existing Unturned plugins are published for RocketMod, so start there, and add OpenMod when a plugin you want is only published for it or you are writing your own.

This guide covers how the two frameworks differ, installing OpenMod on a server that already has Rocket, installing plugins, the permission system in detail, how the Rocket bridge works, and the faults you will meet. The Rocket side is covered in [Unturned Commands.dat and RocketMod plugins](https://www.renode.space/blog/unturned-commands-and-rocketmod).

#### OpenMod and RocketMod compared

| | RocketMod (LDM) | OpenMod |
| --- | --- | --- |
| Where it comes from | Ships with the server in `Extras`, maintained alongside the game | Separate project, installed from its releases |
| Plugin format | DLLs in `Rocket/Plugins/` | NuGet packages, or DLLs in `OpenMod/plugins/` |
| Configuration | XML | YAML |
| Permissions | Groups in `Permissions.config.xml` | Roles and users in YAML files |
| Plugin catalogue | Large, years of plugins | Smaller |
| Design | Simple, synchronous | Modern .NET: dependency injection, async, shared services |

RocketMod's history matters for this comparison: the original project was archived, and the version you get today is Legally Distinct Missile, maintained by Smartly Dressed Games and bundled with the dedicated server. It is stable and almost every plugin targets it.

OpenMod was written by one of Rocket's original maintainers with modern .NET practice: plugins are packages with declared dependencies, services such as economy or permissions are shared through interfaces instead of each plugin rolling its own, and configuration is YAML. For a plugin author, that is a nicer platform. For a server owner, what matters is that a plugin you want exists for it, and that its dependencies resolve.

Running both is normal. A typical server uses Rocket for the large catalogue of established plugins and OpenMod for a few that are only published there.

#### Installing OpenMod

On RE:NODE, Unturned servers ship with RocketMod already in the `Modules` folder, so you are always installing OpenMod beside Rocket rather than instead of it. There are two routes.

##### The installer plugin

The easiest is a small Rocket plugin that installs OpenMod for you.

1. Stop the server and take a backup of the instance folder.
2. Download the OpenMod installer plugin for RocketMod from the OpenMod project's releases, and put the DLL in `Servers/<ServerID>/Rocket/Plugins/`.
3. Start the server and wait for Rocket to load the installer.
4. In the console, run `openmod install` and follow the output.
5. Restart when it tells you to.

##### Manual install

1. Stop the server and back up.
2. Download the Unturned module from the OpenMod project's releases.
3. Extract it so that its module folder sits directly inside the server's `Modules` directory, next to `Rocket.Unturned`.
4. Start the server.

```text
U3DS/
  Modules/
    Rocket.Unturned/
    OpenMod.Unturned/
  Servers/
    MyServer/
      Rocket/
      OpenMod/
```

The first start after installing is slow. OpenMod downloads its own components as NuGet packages, which needs outbound internet from the server and takes a while on the first run. Watch the console rather than the clock, and run `modules` once it settles to confirm both modules are loaded.

> [!NOTE]
> Version matters. OpenMod's Unturned module is built against particular game versions, and a major game update can break it until a new release is out. If OpenMod stops loading after an Unturned update, check the project's releases before debugging anything else.

#### What the OpenMod folder contains

After the first start, OpenMod creates its working folder in the instance:

```text
Servers/MyServer/OpenMod/
  openmod.yaml              core settings
  openmod.unturned.yaml     Unturned-specific settings, including the Rocket bridge
  openmod.roles.yaml        roles and their permissions
  openmod.users.yaml        players, their roles and personal permissions
  logging.yaml              log levels and outputs
  packages/                 NuGet packages, including installed plugins
  plugins/                  plugin DLLs added by hand, and each plugin's config
  logs/                     OpenMod's own logs
```

The exact set of files grows a little with each release. Two habits keep it manageable: edit only with the server stopped or reload afterwards, and keep this folder in your backups - it holds every permission you have granted.

#### Installing plugins

OpenMod plugins are normally published as NuGet packages, and the console installs them by package ID:

```text
openmod install <PackageId>
openmod install <PackageId> <version>
openmod remove <PackageId>
help openmod
```

The package ID is on the plugin's page. Installing pulls the package and its dependencies into `packages/`, and most plugins need a restart to load. `help openmod` lists the sub-commands your version supports, which is worth checking because they have changed between releases.

A plugin distributed as a plain DLL goes into `OpenMod/plugins/` instead, with any libraries it needs.

On first load, a plugin typically creates its own folder of files - a `config.yaml` for settings and a `translations.yaml` for messages. The usual routine:

1. Install the plugin and restart.
2. Read the console. Confirm the plugin loaded without errors.
3. Stop the server, edit the plugin's generated config, start again.
4. Grant its permissions to a role (next section).
5. Test as a normal player, not as an admin.

That fourth step is where most "the plugin does not work" reports end, exactly as with Rocket.

#### Roles, users and permissions

OpenMod permissions are strings in the form `<ComponentId>:<permission>`. The component is the plugin or framework that owns the permission, so `OpenMod.Core:commands.help` is the core framework's permission to run `help`. A plugin's page should list its permissions; if it does not, its commands usually follow the pattern `<PluginId>:commands.<command>`.

Roles live in `openmod.roles.yaml`:

Servers/MyServer/OpenMod/openmod.roles.yaml:

```yaml
roles:
- id: default
  displayName: Default
  priority: 0
  isAutoAssigned: true
  parents: []
  permissions:
  - OpenMod.Core:commands.help
  data: {}
- id: vip
  displayName: VIP
  priority: 10
  isAutoAssigned: false
  parents:
  - default
  permissions:
  - Example.Kits:commands.kit
  - Example.Kits:kits.vip
  data: {}
```

| Field | What it does |
| --- | --- |
| `id` | The role's name, used everywhere else |
| `isAutoAssigned` | Everyone gets this role without being listed |
| `parents` | Roles this one inherits from |
| `priority` | Decides which role wins when two disagree |
| `permissions` | Permission strings granted by this role |

The structure your server generated is the authority for field names; follow it rather than this example if they differ.

Three features do most of the work:

- **Inheritance.** `vip` lists `default` as a parent, so a VIP has everything a default player has plus their own permissions.
- **Wildcards.** `Example.Kits:kits.*` grants every kit permission the plugin defines.
- **Negation.** A permission prefixed with `!` explicitly denies it, which lets a role inherit a wildcard and then remove one item from it.

Individual players are in `openmod.users.yaml`, keyed by their Steam ID, with the roles they hold and any personal permissions. You can edit it by hand with the server stopped, but the console commands are safer while it is running, because they write the file and reload in one step. OpenMod provides `permission` and `role` commands for adding and removing permissions and roles; run `help permission` and `help role` for the exact syntax your version expects.

The principle is the same as for panel accounts: give each role only what it needs. Moderators need kick and ban, not item spawning. [Subusers and least privilege](https://www.renode.space/blog/subusers-and-least-privilege) makes the general argument.

#### Running OpenMod alongside Rocket

The two frameworks can cooperate in three ways, configured in `openmod.unturned.yaml`.

**Loading Rocket plugins.** OpenMod can host Rocket plugins through its compatibility layer, so a server could in principle run everything through OpenMod. In practice most servers leave Rocket plugins under Rocket, because that is where they are tested.

**Shared permissions.** The Rocket bridge can make OpenMod read Rocket's `Permissions.config.xml`, or keep the two systems separate. If you already have a well-built Rocket permissions file, letting OpenMod use it saves maintaining two sets of groups. If you are starting fresh, OpenMod's YAML roles are easier to read.

**Shared economy.** Plugins that charge or pay players need one balance per player, not one per framework. The bridge can route economy calls to a single system so a shop plugin under one framework and a jobs plugin under the other see the same money.

The setting names and options have changed between releases, so read the comments in your generated `openmod.unturned.yaml` before changing anything. Decide one thing early and write it down: which framework owns permissions on your server. Two systems each believing they are in charge is how a player ends up with a command in one and not the other.

```diagram
title: One server, two frameworks
player = Player command
rocket = RocketMod | Rocket plugins
openmod = OpenMod | packages and plugins
bridge = Rocket bridge | permissions, economy
perms = One permission source
player -> rocket : Rocket command
player -> openmod : OpenMod command
rocket -> bridge
openmod -> bridge
bridge -> perms : chosen in config
```

#### A worked example: adding one OpenMod plugin to a Rocket server

Suppose a server has run on Rocket for a year, with a tidy `Permissions.config.xml` holding `default`, `vip` and `moderator` groups, and the owners want one plugin that is only published for OpenMod. This is the order that avoids an evening of confusion.

First, take a backup of the whole instance folder and lock it, so there is a known-good point to go back to. Install OpenMod with the installer plugin and let the first start finish, however long it takes. Run `modules` and confirm both frameworks are listed before touching anything else.

Second, decide who owns permissions. With an established Rocket setup, the sensible choice is to let the bridge in `openmod.unturned.yaml` point OpenMod at Rocket's permission data, so the existing groups keep working and nobody maintains two lists. Read the comments in that file, make the change, and restart.

Third, install the plugin with `openmod install` and restart again. Read the console for the plugin's load line and any dependency errors. Stop the server, open the plugin's generated config, set it up, and start.

Fourth, grant the plugin's permission. With Rocket owning permissions, that means adding the permission to the right group in `Permissions.config.xml`, in the form the bridge expects - the comments in its config say how - and reloading with `/p reload`. With OpenMod owning them, it means adding it to a role in `openmod.roles.yaml`. This is the step that is easiest to put in the wrong file, which is why the decision in step two matters.

Finally, test with an ordinary player account in each group. Admins bypass enough checks that testing as one proves very little. If a VIP can use the command and a default player cannot, the setup is right.

Write down what you did - which framework owns permissions, which plugins live where - somewhere your other admins will find it. Six months later, someone will add a plugin and wonder why its command does nothing, and the note will save them an hour.

#### Security and choosing plugins

OpenMod plugins are code that runs with full access to your server: player data, the save, and anything the server process can reach. NuGet packaging makes them easy to install, and that makes it easy to install something you have not looked at.

- **Prefer plugins with public source.** OpenMod's ecosystem is largely open source; read what a plugin does before trusting it with your server.
- **Pin versions.** `openmod install <PackageId> <version>` installs a specific version, so a later update cannot change behaviour without you choosing it.
- **Remove what you stopped using.** An unused plugin is still running code.
- **Back up before installing.** Plugins that store data can write to the save or to their own files, and there is no undo.

There is no whitelist of permitted plugins on RE:NODE; what you install is what runs, which is the right default for a server you own and a reason to be selective. [Keeping a modded server clean](https://www.renode.space/blog/keeping-a-modded-server-clean) covers the wider habits, and [backups that actually restore](https://www.renode.space/blog/backups-that-actually-restore) covers testing that your backups work before you need one.

#### Troubleshooting

**OpenMod never finishes its first start.** It is downloading packages. If it fails outright, the console shows a NuGet error, usually a network failure or a package that does not exist for this version.

**`modules` does not list OpenMod.** The module folder is nested too deep, or was extracted into the instance folder instead of the server's `Modules` directory.

**A plugin installed but its commands do nothing.** Permissions. Add the plugin's permission to a role, reload or restart, and test as a non-admin.

**A plugin fails to load with a missing dependency.** Install the dependency package named in the error, or install a plugin version built for your OpenMod version.

**Everything broke after an Unturned update.** OpenMod's module needs a release built for the new game version. Check the project's releases; restore the backup if you need the server up meanwhile.

**Permissions work in Rocket but not OpenMod, or the reverse.** The bridge in `openmod.unturned.yaml` decides which system is used. Pick one and make the other follow it.

**Two plugins charge players from different balances.** The economy is not shared. Configure the bridge so both frameworks use one economy.

#### FAQ

##### Should I use OpenMod or RocketMod?

Start with RocketMod, which ships with the server and has the larger plugin catalogue. Add OpenMod when a plugin you want is only published for it, or when you are writing your own plugins and want its modern design.

##### Can OpenMod and RocketMod run at the same time?

Yes. OpenMod is designed to sit beside Rocket, and its Unturned module includes a bridge for permissions and economy. Most servers that use OpenMod also run Rocket.

##### Where are OpenMod permissions stored?

In `OpenMod/openmod.roles.yaml` for roles and `OpenMod/openmod.users.yaml` for individual players, inside the server instance folder. Back that folder up with the save.

##### How do I install an OpenMod plugin?

Run `openmod install <PackageId>` in the server console and restart. Plugins distributed as DLLs go into `OpenMod/plugins/` instead. Then grant the plugin's permissions to a role.

##### Does OpenMod need internet access from the server?

Yes, for installing. Packages and OpenMod's own components come from NuGet. Once installed, a server runs from the downloaded packages.

##### Do players need to install anything for OpenMod plugins?

No. Plugins run on the server only. Players need nothing beyond any workshop content the server uses, which is handled separately - see [Unturned workshop maps and mods](https://www.renode.space/blog/unturned-workshop-maps-and-mods).

Unturned servers on RE:NODE start at 2 GB with RocketMod already in place, so OpenMod installs beside it. The file manager and SFTP reach the `OpenMod` folder and its YAML files, the console has history and tab completion for `openmod install`, and backup slots on every tier cover your permission files along with the save. The login token stays yours, entered on the Setup tab.

[See Unturned plans](https://www.renode.space/game-servers/unturned)

---

### Unturned server Config.json and Commands.dat

Published 2026-10-07 by RE:NODE Team. https://www.renode.space/blog/unturned-server-config-commands-dat

An Unturned server is configured by two files in `Servers/<ServerID>/Server/`. `Commands.dat` says what the server is: its name, map, port, slots, owner, password, difficulty mode and login token, one command per line, read at boot. The gameplay config - `Config.json` on older instances, a commented `Config.txt` on servers created on newer builds - says how the game plays, in sections: `Browser` and `Server` for presentation and connection, then a full block for each difficulty (`Easy`, `Normal`, `Hard`) holding `Items`, `Vehicles`, `Zombies`, `Animals`, `Barricades`, `Structures`, `Players`, `Objects`, `Events` and `Gameplay`. The server only reads the difficulty block that matches `Mode` in `Commands.dat`, which is the reason most edits that "do nothing" do nothing.

This guide walks through the config file section by section - what each group of keys controls, which ones are worth changing and what to leave alone - and shows where it overlaps with `Commands.dat`. The full list of `Commands.dat` lines is in [Unturned Commands.dat and RocketMod plugins](https://www.renode.space/blog/unturned-commands-and-rocketmod), and the install, ports and token are in [Unturned server setup](https://www.renode.space/blog/unturned-server-setup).

#### Two files, and which one wins

| Question | File |
| --- | --- |
| Server name, map, port, slots | `Commands.dat` |
| Difficulty block in use | `Commands.dat` (`Mode`) |
| PvE or PvP, perspective, cheats | `Commands.dat` |
| Loot, zombies, vehicles, damage, decay | Config, in the block for the current `Mode` |
| Server list icon, description, monetisation | Config, `Browser` |
| Anti-cheat switches, ping and timeout limits | Config, `Server` |
| Login token | Either: `GSLT` in `Commands.dat` or `Login_Token` in `Browser` |

Put the login token in one place, not both, so you only have one to change when you rotate it. [Steam game server tokens explained](https://www.renode.space/blog/steam-game-server-tokens-gslt) covers creating one against Unturned's app ID `304930`.

Both files share the same editing rule: stop the server first. Unturned writes its configuration and save state on shutdown, and a file edited while the server runs is liable to be overwritten by the copy the server holds in memory.

`Config.json` and `Config.txt` hold the same settings with the same names. The newer text format adds comments and is easier to read; the JSON format is what most older guides show. Edit whichever your instance has. Creating the other one alongside it does not switch formats - the server reads the file it expects and ignores the stray one.

#### Generating a fresh file and reading defaults

The defaults change between game versions as the developer rebalances, so the most reliable reference is a file your own build has generated:

1. Stop the server.
2. Rename the existing config to keep it as a backup.
3. Start the server once and stop it. A fresh config with current defaults appears.
4. Compare it with your old one and copy your changes across.

Doing this after a major game update is worth the five minutes. New keys appear, and an old config simply lacks them - the server falls back to built-in defaults for anything missing, which is safe but means you never see the new options.

#### Browser: how the server presents itself

Servers/MyServer/Server/Config.json:

```json
"Browser": {
    "Icon": "https://example.com/icon.png",
    "Thumbnail": "https://example.com/thumb.png",
    "Desc_Hint": "Vanilla+ survival, weekly wipes",
    "Desc_Full": "Rules and Discord link in the welcome message.",
    "Desc_Server_List": "Vanilla+ survival, active admins",
    "Login_Token": "",
    "Monetization": "None"
}
```

| Key | What it does |
| --- | --- |
| `Icon` | URL of a small image shown beside the server in the list |
| `Thumbnail` | URL of a larger image shown in the server's details |
| `Desc_Hint` | Short line shown when hovering or selecting |
| `Desc_Full` | Longer description on the server's info screen |
| `Desc_Server_List` | The line shown in the list itself |
| `Login_Token` | The game server login token, if not in `Commands.dat` |
| `Monetization` | Declares whether the server sells anything |

Images are fetched by players from the URLs you give, so host them somewhere reliable with a direct image link. The server list shows them small, and a clear icon helps a server stand out more than any description.

`Monetization` exists because the server browser lets players filter by it. Declare it honestly: a server that sells gameplay advantages and claims otherwise is the kind of thing that gets reported, and [monetising a game server within the rules](https://www.renode.space/blog/monetising-a-game-server-within-the-rules) covers what is reasonable to sell in the first place. The accepted values are listed in the comment of a `Config.txt`, or in the developer's documentation for JSON configs.

Newer builds have added fields here over time, such as links shown on the server's info page. If your file lacks them, regenerate it as described above.

#### Server: connection and anti-cheat

| Key | What it does |
| --- | --- |
| `VAC_Secure` | Valve Anti-Cheat on. Keep it on for a public server |
| `BattlEye_Secure` | BattlEye on. Keep it on for a public server |
| `Max_Ping_Milliseconds` | Ping above which players are kicked |
| `Timeout_Queue_Seconds` | How long a queued connection may take |
| `Timeout_Game_Seconds` | How long a silent connection is kept in game |
| `Max_Packets_Per_Second` | Rate limit on what one client may send |
| `Enable_Scheduled_Shutdown` | Shut down at a set time, with warnings |
| `Enable_Update_Shutdown` | Shut down with warnings when a game update is released |

The exact set of keys in this section has grown across versions; your generated file is the list for your build.

The anti-cheat switches are the important ones. Turning BattlEye off is sometimes suggested as a fix for a connection problem; it does fix the symptom, and it also removes the main defence against cheat clients on a public server. Find the real cause instead.

The ping limit does the same job as `Timeout` in `Commands.dat`, and the name in `Commands.dat` is misleading - it is a maximum ping, not a timeout. A lower limit keeps players with poor connections from lagging everyone near them; a higher one keeps distant friends connected. On a server in Germany for European players, a few hundred milliseconds is a reasonable ceiling.

The shutdown options are useful together with a host that restarts the server. Find out first whether a clean exit on your host is followed by an automatic start, or whether the server waits to be started; if it waits, a scheduled restart from the panel is the more predictable choice. On RE:NODE the Schedules tab runs that as ordered tasks - a warning, a delay, `save`, a restart - which also re-reads both config files on the way up.

#### The difficulty blocks and Mode

Everything below lives three times in the file: once under `Easy`, once under `Normal`, once under `Hard`. Only the block matching `Mode` in `Commands.dat` is used.

Commands.dat:

```text
Mode Normal
```

Config.json:

```json
"Normal": {
    "Items": { "Spawn_Chance": 0.35, "Respawn_Time": 50.0 },
    "Zombies": { "Spawn_Chance": 0.2, "Respawn_Night_Time": 30.0 },
    "Vehicles": { "Respawn_Time": 300.0 }
}
```

The defaults differ between blocks - `Hard` has fewer items and tougher zombies than `Easy` - so starting from the block nearest what you want and adjusting is easier than rebuilding one from scratch. The examples below use the `Normal` names; the keys are identical in every block.

#### Items: loot

| Key | What it does |
| --- | --- |
| `Spawn_Chance` | Chance a loot point holds an item. `0.35` on Normal |
| `Respawn_Time` | Seconds before a looted point can refill. `50` on Normal |
| `Despawn_Dropped_Time` | Seconds before items players dropped vanish |
| `Despawn_Natural_Time` | Seconds before naturally spawned, untouched items vanish |
| `Quality_Full_Chance` | Chance an item spawns in perfect condition |
| `Quality_Multiplier` | Condition of spawned items |
| `Gun_Bullets_Full_Chance`, `Gun_Bullets_Multiplier` | Ammunition loaded in found guns |
| `Magazine_Bullets_Full_Chance`, `Magazine_Bullets_Multiplier` | Ammunition in found magazines |
| `Has_Durability` | Whether items wear out |

The temptation is to raise `Spawn_Chance`. At `1.0` every loot point is full, and the game's whole loop - travelling, risking towns, finding things - collapses in an evening. If you want a faster server, shorten `Respawn_Time` so places refill sooner, or raise the bullet multipliers so the guns people find are usable. Both speed the game up without making exploration pointless.

`Despawn_Dropped_Time` matters for performance and for arguments. Long values leave piles of dropped items in towns; short ones mean a player who dies far from home finds nothing when they get back.

#### Zombies and animals

| Key | What it does |
| --- | --- |
| `Spawn_Chance` | Chance a zombie spawn point is used. `0.2` on Normal |
| `Respawn_Day_Time`, `Respawn_Night_Time` | Seconds before a killed zombie returns, by day and night |
| `Respawn_Beacon_Time` | The same during a horde beacon |
| `Damage_Multiplier`, `Armor_Multiplier` | How hard they hit and how much they absorb |
| `Crawler_Chance`, `Sprinter_Chance`, `Flanker_Chance` | Shares of special zombie types |
| `Burner_Chance`, `Acid_Chance` | More special types |
| `Loot_Chance` | Chance a zombie drops loot |
| `Min_Drops`, `Max_Drops` | How many items a zombie drops |
| `Can_Target_Barricades`, `Can_Target_Structures`, `Can_Target_Vehicles` | What zombies attack |
| `Slow_Movement`, `Can_Stun` | Movement and stun behaviour |

Night respawn is much faster than day respawn by default - thirty seconds against six minutes - which is what makes Unturned nights dangerous. Most of the feel of a server's PvE comes from that pair and from `Spawn_Chance`. The special-type chances are small numbers and small changes go a long way.

`Can_Target_Barricades` and `Can_Target_Structures` decide whether zombies damage bases. Turning them off makes building safe from zombies, which some PvE servers want and most survival servers do not.

`Animals` has a smaller version of the same idea: `Respawn_Time`, damage and armour multipliers, and per-map-size instance limits.

#### Vehicles

| Key | What it does |
| --- | --- |
| `Respawn_Time` | Seconds before a destroyed vehicle respawns. `300` on Normal |
| `Decay_Time`, `Decay_Damage_Per_Second` | How unused vehicles deteriorate |
| `Has_Battery_Chance`, `Min_Battery_Charge`, `Max_Battery_Charge` | Batteries in found vehicles |
| `Has_Tire_Chance` | Chance of tyres |
| `Unlocked_After_Seconds_In_Safezone` | Locked vehicles left in a safe zone become usable by others |
| `Armor_Multiplier` and damage multipliers | Durability against guns and melee |
| `Max_Instances_Tiny` to `Max_Instances_Insane` | Vehicle cap by map size |

The instance limits are worth knowing about: the cap that applies depends on the map's size class, and on busy servers a low cap is why nobody can find a car. Raising it costs some performance, since every vehicle is simulated and saved.

#### Barricades and structures

| Key | What it does |
| --- | --- |
| `Decay_Time` | Seconds a base can go without its owners nearby before it decays |
| `Armor_Lowtier_Multiplier`, `Armor_Hightier_Multiplier` | Durability of weak and strong building tiers |
| `Gun_Lowcal_Damage_Multiplier`, `Gun_Highcal_Damage_Multiplier` | Damage from small and large calibre weapons |
| `Melee_Damage_Multiplier`, `Melee_Repair_Multiplier` | Melee damage and repair speed |

`Barricades` covers placed items such as doors, walls placed as barricades, storage and traps; `Structures` covers floors, walls and roofs. Both have the same keys.

`Decay_Time` is the setting that keeps a map from filling with abandoned bases. The default is a week in seconds (`604800`). On a busy public server, shorter decay keeps space free; on a friends' server where people play once a fortnight, lengthen it or bases vanish between sessions. Tell players the number, because nothing feels more unfair than a base that decayed without anybody knowing it could.

The damage multipliers are raiding balance. Raising `Armor_Hightier_Multiplier` makes metal bases much harder to raid; lowering gun damage against structures makes raids depend on explosives. Change one at a time and watch how raids go for a week.

#### Players and gameplay

| Key | What it does |
| --- | --- |
| `Experience_Multiplier` | Experience gained |
| `Lose_Skills_PvP`, `Lose_Skills_PvE` | Share of skills lost on death |
| `Lose_Items_PvP`, `Lose_Items_PvE` | Share of inventory dropped on death |
| `Lose_Clothes_PvP`, `Lose_Clothes_PvE` | Whether clothing is dropped |
| `Can_Break_Legs`, `Can_Start_Bleeding` | Injury mechanics |
| `Spawn_With_Max_Skills` | New characters start fully skilled |
| `Allow_Instakill_Headshots` | Headshots always kill |
| `Allow_Per_Character_Saves` | Separate saves for each of a player's characters |

`Gameplay` holds interface and rule switches: `Crosshair`, `Hitmarkers`, `Ballistics`, `Chart`, `Satellite`, `Compass`, `Group_Map`, `Group_HUD`, `Allow_Static_Groups`, `Allow_Dynamic_Groups`, `Max_Group_Members`, `Friendly_Fire`, `Can_Suicide`, `Allow_Shoulder_Camera`, and timers such as `Timer_Exit`, `Timer_Respawn` and `Timer_Home`.

The death settings define a server's character as much as loot does. Losing every item but no skills is the classic survival setting; keeping items on PvE deaths but not PvP deaths is a common compromise that makes zombies less frustrating without making PvP toothless.

`Max_Group_Members` limits how many players can be in one group. On a PvP server, a cap stops one large group dominating the map, though players can still cooperate outside the group system.

#### Objects and events

`Objects` controls how the world resets after use: `Fuel_Reset_Multiplier` and `Water_Reset_Multiplier` for pumps and wells, `Resource_Reset_Multiplier` for trees and rocks, `Resource_Drops_Multiplier` for how much a tree or rock gives, and `Rubble_Reset_Multiplier` for destructible objects. Raising `Resource_Drops_Multiplier` is a gentle way to speed up building without touching loot.

`Events` controls weather and airdrops: rain and snow frequency and duration, `Use_Airdrops`, `Airdrop_Frequency_Min` and `Airdrop_Frequency_Max`, and the arena mode's timers. Weather keys have been reworked in newer builds, so trust your generated file. Airdrops are a good lever for a PvP server, because they create a reason to fight in predictable places.

#### A worked example: a faster survival server

Settings make more sense as a set. Here is how a server for a group who play a few evenings a week might be built from the `Normal` block, and why each choice is made.

The group wants progress to feel quicker without the map becoming a supermarket. So `Items.Spawn_Chance` stays close to its default, and `Items.Respawn_Time` comes down, so a town that was looted on Monday has something in it on Wednesday. The gun and magazine bullet multipliers go up a little, so a found rifle can actually be used, which removes one of the most frustrating parts of the early game without handing anyone an arsenal.

Zombies stay dangerous at night - the short `Respawn_Night_Time` is part of what makes Unturned what it is - but `Damage_Multiplier` comes down slightly, because a small group cannot afford to lose a member to every bad corner. `Can_Target_Barricades` stays on, so bases still need defending.

On death, `Lose_Items_PvE` drops to a partial loss and skills are kept on PvE deaths, so being caught by a horde is a setback rather than a restart, while PvP deaths keep the full penalty so fighting still has stakes. `Experience_Multiplier` goes up modestly to match the shorter play time.

Bases get a longer `Decay_Time` in both `Barricades` and `Structures`, because this group sometimes misses a week, and nothing kills enthusiasm like returning to an empty plot. `Resource_Drops_Multiplier` in `Objects` goes up so building is less of a grind.

None of these is extreme, and that is the point: several modest changes in the right places make a server feel considerably faster while keeping the game's tension intact. Change them with the server stopped, restart, play for a week, and adjust. Keep the previous file beside the new one so you can compare when someone asks what changed - and take a backup before each round of edits, which on any host is cheaper than reconstructing a config from memory.

#### Troubleshooting

**My loot changes do nothing.** You edited a block that does not match `Mode` in `Commands.dat`. Edit the matching block or change `Mode`.

**My edits disappeared.** The server was running when you saved, and wrote its copy over yours on shutdown.

**The server fails to start after an edit.** Invalid JSON - a missing comma or a trailing one. The console points at the problem.

**New settings mentioned in patch notes are missing.** Your config predates them. Regenerate a fresh file and copy your changes across.

**The server is invisible in the list.** No login token in either file, or an invalid one. Joining by IP still works, which proves the server itself is fine.

**Players are kicked for high ping.** `Max_Ping_Milliseconds`, or `Timeout` in `Commands.dat`. Raise it if they are legitimate distant players.

#### FAQ

##### What is the difference between Commands.dat and Config.json?

`Commands.dat` sets what the server is: name, map, port, slots, difficulty mode and access. The config sets how the game plays: loot, zombies, vehicles, building, death and interface rules. They never contradict each other, apart from a few overlapping items like the login token.

##### Why does my server use Config.txt instead of Config.json?

Servers created on newer builds generate a commented `Config.txt`. Older servers keep their `Config.json`. The keys are the same; edit the one your instance has.

##### Which difficulty block should I edit?

The one named by `Mode` in `Commands.dat`. A server with `Mode Normal` reads only the `Normal` block.

##### How do I make loot more generous without ruining the game?

Shorten `Items.Respawn_Time` and raise the bullet multipliers rather than pushing `Spawn_Chance` towards `1.0`. Places refill faster and guns are usable, while towns still need visiting.

##### How long do bases last when players stop playing?

Until `Decay_Time` in the `Barricades` and `Structures` sections passes without the owners nearby - a week by default. Lengthen it for groups who play rarely.

##### Do I need to restart after changing the config?

Yes. Both files are read at boot. Stop the server, edit, start again.

Unturned servers on RE:NODE start at 2 GB with both UDP ports allocated and RocketMod installed. The in-browser editor with syntax highlighting handles `Commands.dat` and the config, SFTP is on every server, and backup slots on every tier mean a config experiment can be undone with a button. The login token stays yours, entered on the Setup tab.

[See Unturned plans](https://www.renode.space/game-servers/unturned)

---

### Unturned workshop maps and mods on a server

Published 2026-10-07 by RE:NODE Team. https://www.renode.space/blog/unturned-workshop-maps-and-mods

An Unturned server gets workshop content from one file: `WorkshopDownloadConfig.json` in the server's instance folder. Put the numeric workshop IDs of a map and its asset packs in `File_IDs`, set `Map` in `Commands.dat` to the map's internal name, and restart. The server downloads every item at boot, and when a player joins it sends them the same list, so their client downloads it from Steam automatically - nobody has to subscribe by hand. Almost every workshop problem on an Unturned server is one of four things: a missing dependency, a wrong map name, two mods using the same IDs, or a workshop item that updated while the server was running.

This guide covers the file and every field in it, maps and the name that loads them, content mods, dependencies, what happens when an item updates, and the errors players actually see. For the rest of the server - `Commands.dat`, ports and the login token - see [Unturned server setup](https://www.renode.space/blog/unturned-server-setup).

#### How workshop content reaches a server and its players

Workshop items for Unturned are hosted by Steam, under the game's app ID `304930`. The dedicated server does not need anyone's Steam account to fetch them: it reads the ID list at boot, downloads anything missing or out of date, and loads the assets.

```diagram
title: One ID list feeds the server and every player
cfg = WorkshopDownloadConfig | File_IDs
server = Unturned server | downloads at boot
steam = Steam Workshop | app 304930
client = Joining player
cfg -> server : read on start
steam -> server : items and children
server -> client : required item list
steam -> client : the same items
```

When a player connects, the server tells them which items it is running. The client compares that with what it has, downloads anything missing from Steam, and loads in. A player's first join to a heavily modded server can take a while for exactly this reason.

That handshake is why the ID list is the right place for workshop content rather than files copied into folders by hand. Content copied manually onto a server is not in the list, so clients are never told to fetch it, and they arrive in a world full of things they cannot load.

#### WorkshopDownloadConfig.json, field by field

The file sits at `Servers/<ServerID>/WorkshopDownloadConfig.json` and is created on the server's first start. Stop the server before editing it. A typical file:

Servers/MyServer/WorkshopDownloadConfig.json:

```json
{
    "File_IDs": [
        1234567890,
        1234567891,
        2345678901
    ],
    "Ignore_Children_File_IDs": [],
    "Query_Cache_Max_Age_Seconds": 600,
    "Max_Query_Retries": 2,
    "Use_Cached_Downloads": true,
    "Should_Monitor_Updates": true,
    "Shutdown_Update_Detected_Timer": 600,
    "Shutdown_Update_Detected_Message": "Workshop file update detected, shutdown in: {0}"
}
```

| Field | What it does |
| --- | --- |
| `File_IDs` | The workshop items to download and load. Numbers, comma-separated |
| `Ignore_Children_File_IDs` | Items to skip even if something in `File_IDs` lists them as required |
| `Query_Cache_Max_Age_Seconds` | How long the server trusts its last look at item details |
| `Max_Query_Retries` | Retries when Steam does not answer |
| `Use_Cached_Downloads` | Reuse items already downloaded if they are current |
| `Should_Monitor_Updates` | Watch for workshop updates while running |
| `Shutdown_Update_Detected_Timer` | Seconds of warning before shutting down for an update |
| `Shutdown_Update_Detected_Message` | The warning shown to players; `{0}` is replaced with the time left |

The fields and their defaults have grown over several updates, so treat the file your server generated as the reference for your build. The ones you will touch are `File_IDs` and the update fields.

The workshop ID is the number at the end of the item's Steam page address, after `?id=`. It is a number, not a name, and JSON wants it without quotes. A missing comma between IDs, or a trailing comma after the last one, makes the file invalid; the server then either ignores it or fails to start, and the console says which. [SFTP and the file manager](https://www.renode.space/blog/sftp-and-the-file-manager) covers editing it, and an in-browser editor with syntax highlighting makes the stray comma easier to spot before you restart.

#### Maps: the ID and the name

A workshop map needs two things: its ID in `File_IDs`, and its name in `Commands.dat`.

Servers/MyServer/Server/Commands.dat:

```text
Map Example Island
```

The name is the map's internal name - the name of the map's folder inside the workshop item - not necessarily the title on its workshop page. Most map authors state the exact name to use on the page. If they do not, look in the downloaded item after the server has fetched it: the map folder's name is the value you want.

If the server cannot find the map you named, it does not fail. It loads PEI, the small default map, and starts normally. A server that keeps starting on PEI after you added a map has one of three problems: the name does not match exactly, the workshop item did not download (check the console at boot for the download), or the map was added to `File_IDs` but the server was not restarted.

The official maps - PEI, Washington, Russia and Yukon among them - ship with the game and need no workshop entry. Curated maps, the community maps featured inside the game, are hosted on the workshop. Recent server builds can resolve a curated map from its name, but adding its workshop ID to `File_IDs` is the dependable way to make sure the server has it.

Only one map runs at a time. Changing `Map` gives you a different world with its own save; the old map's save stays on disk under its own name, so switching back later returns to it.

#### Asset packs and dependencies

Many large maps are not one workshop item. They come as a map item plus one or more asset packs: the buildings, props, vehicles and items the map uses, published separately so they can be updated or shared between maps.

If the server or a player is missing an asset pack, the map loads without those objects. Players see gaps in the world, floating red error text where objects should be, or a kick on join when the server and client disagree about what exists.

Two mechanisms handle this.

**Required items.** A workshop item can list other items it requires. When the server downloads it, it pulls those children in as well. This is why many maps work with only the map's own ID listed.

**`Ignore_Children_File_IDs`.** Occasionally a required child is one you do not want - an outdated pack, or one you are replacing with a different version. Listing it here skips it.

Not every author sets required items correctly. Read the map's workshop page for anything it says to install alongside it, add those IDs explicitly, and check the console at boot to confirm everything downloaded. Listing an ID that would also be pulled in as a child does no harm.

Workshop collections are a convenient way for players to subscribe to a set of items, but whether a collection ID behaves like a list of IDs on the server has varied between builds. Listing items individually is predictable and makes it obvious what the server is running.

#### Content mods: items, vehicles and the ID problem

Content mods - new guns, vehicles, clothing, buildables - are added exactly like maps: workshop ID in `File_IDs`, restart. The server loads their assets alongside the game's own.

The old trouble with Unturned mods is IDs. Every item, vehicle and object in the game has a numeric ID within its category, and legacy mods picked their own numbers. Two mods that both define item `30000` conflict, and one of them wins - so a player spawns, buys or loots something that turns out to belong to the other mod. Newer assets also carry a GUID, which is unique by design, but plenty of popular content still depends on numeric IDs, and spawn tables, shops and plugins frequently refer to items by number.

The defence is mostly attention:

- **Read the server log at boot.** Asset conflicts are reported while assets load. A clean log with your mod list is worth checking after every addition.
- **Add one mod at a time.** Restart, check the log, check in game, then add the next.
- **Prefer maintained mods.** An active author resolves reported conflicts; an abandoned one will not.
- **Check plugin configs against IDs.** Kits, shops and loot plugins refer to item IDs. When you add or remove a mod, the IDs your plugin configs list may now point at something else, or at nothing.

Mods that a map depends on are a special case: removing them breaks the map. Mods nothing depends on can be removed, but anything players own from that mod vanishes - from inventories, storage and vehicles. Removal is a decision to announce, not a quick fix.

#### Updates while the server is running

Workshop authors update their items whenever they like. The danger is the gap: the server is running the old version, a player joins, Steam gives them the new one, and the two sides disagree. Depending on what changed, the player is kicked with a mismatch, or joins and then sees errors.

`Should_Monitor_Updates` is the built-in answer. With it on, the server watches its items, and when one updates it warns players with `Shutdown_Update_Detected_Message` and shuts down after `Shutdown_Update_Detected_Timer` seconds. On the next start it downloads the update, and server and players agree again.

That only works if something starts the server again. Check how your host treats a clean exit: on some setups the server comes straight back, on others it waits to be started. If it waits, a server that shuts itself down for a mod update at 4am stays down until somebody notices. The alternatives are to keep monitoring on and make sure it is restarted, or to turn it off and pick up updates with a nightly restart at an hour when nobody plays.

On RE:NODE the Schedules tab can run that nightly routine as ordered tasks: a `say` command warning players, a delay, `save`, a restart, then a backup. A restart re-reads `WorkshopDownloadConfig.json` and fetches any updated items on the way up. [Restart schedules that help](https://www.renode.space/blog/restart-schedules-that-help) covers choosing the hour.

> [!WARNING]
> A workshop update can break a server as well as fix one. An author can change IDs, remove items or require a newer game version. Keep backups of the instance folder from before each change, and if an update breaks things, restoring the save and temporarily removing that item is faster than waiting for the author.

#### Server size and download time

Workshop content costs the server memory and disk, and costs players download time.

| Content | Memory impact | Disk |
| --- | --- | --- |
| Official map, no mods | Baseline, around 2 GB server | A couple of GB install |
| Curated map | Small to moderate | Hundreds of MB |
| Large community map with asset packs | Moderate to large | Up to several GB |
| Large map plus many content mods | Large | Several GB |

The map is usually the biggest single factor, because a large map holds far more objects than an official one. Content mods add up when there are many of them. The [setup guide](https://www.renode.space/blog/unturned-server-setup) has a full sizing table by player count.

Downloads hit players more than the server. A server with several gigabytes of workshop content means a long first join for every new player, and a full re-download of anything that updates. Keep the list to what the server actually uses, and mention the download size in your server description so new players know to wait. [Steam Workshop mods on dedicated servers](https://www.renode.space/blog/steam-workshop-mods-on-dedicated-servers) covers how downloads work across games, including items that get unlisted.

#### Troubleshooting

**The server always loads PEI.** The `Map` name does not match the internal map name, the map did not download, or the server was not restarted after the change.

**Players see red error text and missing buildings.** A missing asset pack. Find what the map requires on its workshop page and add the IDs.

**Players are kicked on join with a workshop or asset mismatch.** An item updated and the server has not restarted. Restart it; turn on `Should_Monitor_Updates` or schedule nightly restarts.

**The server ignores WorkshopDownloadConfig.json.** The JSON is invalid - usually a missing or trailing comma - or the file was edited while the server ran and overwritten on shutdown.

**An item spawns as the wrong thing.** Two mods share a numeric ID. Check the boot log for conflicts and remove one of them.

**First joins take a very long time.** Players are downloading the workshop list. Trim unused items and state the download size in the server description.

**A plugin's kit or shop gives the wrong items.** Item IDs changed after a mod was added or removed. Update the plugin config.

#### FAQ

##### Do players need to subscribe to my workshop maps?

No. The server sends its item list on join and the client downloads everything from Steam automatically. Players only need to wait for the download on their first join.

##### Where do I find a map's internal name?

On the map's workshop page, where most authors state it. Otherwise, look at the folder name inside the downloaded workshop item on the server. That folder name is what goes after `Map` in `Commands.dat`.

##### Can I add mods without restarting?

No. `WorkshopDownloadConfig.json` is read at boot. Add the ID, then restart, ideally at a quiet hour.

##### Why does my map load without its buildings?

It depends on an asset pack the server or player does not have. Add every item the map's page says it needs to `File_IDs`, restart, and check the boot log.

##### Can I put a workshop collection ID in the file?

Listing individual item IDs is the dependable method. How collections behave on a server has varied between builds, and an explicit list makes it clear what you are running.

##### What happens to players' items if I remove a mod?

Anything that came from that mod disappears from inventories, storage and vehicles. Announce removals, and keep a backup from before the change in case you need to undo it.

Unturned servers on RE:NODE start at 2 GB with both UDP ports allocated and RocketMod already installed. The file manager edits `WorkshopDownloadConfig.json` with syntax highlighting, the Schedules tab handles nightly save, restart and backup, and there is no whitelist of permitted mods - what you list is what runs. The login token stays yours, entered on the Setup tab.

[See Unturned plans](https://www.renode.space/game-servers/unturned)

---

### Unturned Commands.dat and RocketMod plugins

Published 2026-09-21 by RE:NODE Team. https://www.renode.space/blog/unturned-commands-and-rocketmod

Unturned has one command system and three ways to reach it: a line in `Commands.dat`, a line typed into the server console, or a line typed into chat by an administrator with `/` or `@` in front of it. Which of the three works for a given command is not arbitrary - every command is classified as boot-time, runtime, or both, and a few also require cheats to be switched on. Get that classification straight and most of the confusion around Unturned server administration disappears. The other half of the job is RocketMod, which adds its own parallel command system with its own permissions file, and which quietly fixes the most annoying omission in the vanilla server: it has an autosave and the base game does not.

#### How Unturned reads a command

Commands are case-insensitive. When a command takes more than one parameter, the parameters are separated by forward slashes, which reads strangely the first time: `ban 76561198012345678/Cheating/86400` is a name, a reason and a duration, not a path.

Where a command can be issued depends on its classification:

- **Config.** Only read at boot, from `Commands.dat`. `Map`, `Port`, `Owner`, `Cheats`, `PvE` and `Password` are in this group. Typing them into a running console does nothing useful.
- **Runtime.** Only work while the server is up: `kick`, `ban`, `teleport`, `say`, `day`, `weather`.
- **Any.** Work in both places. `MaxPlayers`, `Name`, `Welcome`, `Save` and `Shutdown` can sit in `Commands.dat` or be typed live.
- **Runtime cheat.** Work at runtime and only if `Cheats` is present in `Commands.dat`: `give`, `vehicle`, `animal`, `experience`.

`Commands.dat` lives at `Servers/<ServerID>/Server/Commands.dat`, one command per line, read once as the server boots. Lines starting with `//` are comments. The gameplay numbers - loot rates, zombie health, vehicle respawns - are not here; they are in the separate difficulty config covered in the [Unturned server setup guide](https://www.renode.space/blog/unturned-server-setup). `Commands.dat` decides what the server is. The config decides how it plays.

> [!WARNING]
> Stop the server before editing `Commands.dat`. Unturned writes server state on shutdown, and a file edited while the process is running is liable to be overwritten by it.

#### Commands.dat: everything you can set at boot

The config-only commands, the ones that must be in the file because there is nowhere else to put them:

| Command | Default | What it does |
| --- | --- | --- |
| `Map` | `PEI` | Internal level name. A name it cannot find silently loads PEI |
| `Port` | `27015` | Query port. Game traffic is always this plus one |
| `Owner` | - | A SteamID64 with permanent administrator rights |
| `Password` | - | Join password, stored as a SHA-1 hash only |
| `Mode` | `Normal` | `Easy`, `Normal` or `Hard`; picks which config block applies |
| `PvE` | off | Present disables player-versus-player combat |
| `Perspective` | - | `First`, `Third`, `Both` or `Vehicle` |
| `Cheats` | off | Present allows cheat commands for administrators |
| `Filter` | off | Rejects players with non-English, non-alphanumeric names |
| `Gold` | off | Server joinable only by Gold Upgrade owners |
| `Whitelisted` | off | Server joinable only by permitted players |
| `Hide_Admins` | off | Hides admin labels from players |
| `GSLT` | - | Game Server Login Token |
| `Bind` | `0.0.0.0` | Bind to one internal address instead of all of them |
| `GameMode` | - | A custom game mode class name |
| `Sync` | off | Lets players share save data between your servers |

And the ones that work in the file or live in the console:

| Command | Default | Range | What it does |
| --- | --- | --- | --- |
| `Name` | `Unturned` | 5-50 chars | Server name in the browser |
| `MaxPlayers` | `8` | 1-200 | Slot count |
| `Queue_Size` | - | 0-64 | How many players may wait for a slot |
| `Timeout` | `750` | 50-10000 | Maximum ping in milliseconds before a kick |
| `Chatrate` | `0.25` | 0-60 | Seconds a player must wait between chat messages |
| `Cycle` | `3600` | - | Length of one day-night cycle in seconds |
| `Welcome` | - | - | `Text/R/G/B`, shown on join |
| `Log` | `N/N/N/N` | - | `Chat/Join-Leave/Death/Anticheat`, each `Y` or `N` |
| `Loadout` | - | - | `SkillsetID/ItemID/ItemID...`; skillset `255` means all |
| `Votify` | off | - | `Allowed/PassCooldown/FailCooldown/Duration/Percentage/Players` |

A worked file for a small survival server, with the comments the game itself allows:

Servers/MyServer/Server/Commands.dat:

```text
// identity
Name Thursday Survival
Owner 76561198012345678
Welcome Rules are in Discord. No offline raiding./255/200/0

// world
Map Washington
Mode Normal
Perspective Both
MaxPlayers 24
Queue_Size 8
Cycle 3600

// connection
Port 27015
Timeout 400
Chatrate 1.0
Filter
Log Y/Y/Y/Y

// listing
GSLT 0123456789ABCDEF0123456789ABCDEF
```

Four of those repay a second look. `Timeout` is not a timeout at all - it is a maximum ping, and `750` is generous enough that a player at the far end of the world stays connected while lagging visibly for everyone near them. Dropping it to `400` on a regional server is a real quality improvement and an unpopular one.

`Log Y/Y/Y/Y` turns on chat, join and leave, death and anti-cheat logging, and it is off by default. Turn it on before you need it, because the first time you want to know who blew up a base, the logs either exist or they do not. [Logs worth keeping](https://www.renode.space/blog/logs-worth-keeping) covers what to retain and for how long.

`Password` is worth one warning of its own: the game stores it as a SHA-1 hash, so treat it as a door key for a group of friends and never reuse a password you use anywhere else.

`Port` takes two consecutive ports, `27015` for queries and `27016` for game traffic. Running a second server on the same machine means `Port 27017`, not `27016`, or the two collide. [Game server ports explained](https://www.renode.space/blog/game-server-ports-explained) has the general version of this trap. The `GSLT` line is a credential you create yourself against Unturned's app id `304930` - [Steam game server tokens explained](https://www.renode.space/blog/steam-game-server-tokens-gslt) covers what one is, who may create one and what gets one banned.

#### Runtime commands: moderation, cheats and the console

These are typed into the server console, or into chat by an administrator with `/` or `@` in front. The moderation set:

| Command | Syntax | Effect |
| --- | --- | --- |
| `admin` | `<SteamID or Player>` | Grant administrator rights |
| `unadmin` | `<SteamID or Player>` | Revoke them |
| `kick` | `<Player>/<Reason>` | Disconnect a player |
| `ban` | `<Player>/<Reason>/<Duration>` | Ban; blank duration means 31536000 seconds |
| `unban` | `<SteamID>` | Lift a ban |
| `bans` | | Print the ban list |
| `slay` | `<Player>/<Reason>` | Kill and ban in one step |
| `kill` | `<Player>` | Kill without banning |
| `permit` | `<SteamID>/<Tag>` | Add to the allow list |
| `unpermit` | `<SteamID>` | Remove from it |
| `permits` | | Print the allow list |
| `players` | | Who is connected |
| `spy` | `<Player>` | Request a screenshot, saved as `Spy.jpg` |
| `investigate` | `<Player>` | Print a player's SteamID64 |

The world and housekeeping set:

| Command | Syntax | Effect |
| --- | --- | --- |
| `save` | | Force a proper save right now |
| `shutdown` | `<Delay>/<Explanation>` | Save, disconnect everyone, stop |
| `say` | `<Text>/<R>/<G>/<B>` | Broadcast to chat; defaults to green |
| `day` / `night` | | Jump the clock |
| `time` | `<Seconds>` | Set a precise point in the cycle |
| `weather` | `<None or Storm or Blizzard or GUID>` | Force the weather |
| `airdrop` | | Call a dropship immediately |
| `teleport` | `<Player>/<Player, place, wp or bed>` | Move somebody |
| `debug` | | Print server state to the console |
| `modules` | | List loaded modules, useful for checking Rocket loaded |
| `help` | `[Command]` | List commands, or explain one |

And the cheat set, which needs `Cheats` in `Commands.dat`: `give`, `vehicle`, `animal`, `experience`, `reputation`, `flag`, `quest`. Leaving `Cheats` on for a public server is a decision, not an oversight - it means every administrator can spawn anything, and the only record of it is whatever you set `Log` to.

`save` deserves emphasis because the vanilla server has no autosave at all. Nothing writes player structures, vehicles and inventories to disk on a timer. `shutdown` saves; a kill, a crash or an out-of-memory stop does not. Until you install RocketMod, which adds one, a scheduled `save` is the only thing standing between your server and a lost week.

#### Admins, whitelists and bans

Three plain text files sit in `Servers/<ServerID>/Server/`, one identifier per line:

```text
Adminlist.dat     administrators
Blacklist.dat     bans
Whitelist.dat     the allow list, used when Whitelisted is set
```

The `Owner` command in `Commands.dat` is separate and stronger: it grants permanent administrator rights to one SteamID64 without touching `Adminlist.dat`, and it is the right place for your own account. Everyone else goes through `admin` at runtime, which writes to the list for you.

`Whitelisted` in `Commands.dat` flips the server to allow-list-only. From that point nobody joins unless their ID is in `Whitelist.dat` or was added with `permit`. The `Tag` parameter on `permit` is a label for your own benefit - it shows up when you print the list, which on a 200-slot whitelist is the difference between a usable file and a wall of numbers.

Getting a player's SteamID64 is easiest with `investigate <name>` while they are connected. Copying it from a profile URL works too, but half of Unturned's player base has a vanity URL rather than a numeric one, and people paste the vanity string into `Adminlist.dat` and wonder why nothing happened.

#### Installing RocketMod (LDM)

RocketMod is the plugin framework almost every Unturned plugin targets. Its history matters for one practical reason: the original maintainers stopped work in December 2019 and released the source under the MIT licence, Smartly Dressed Games forked it to keep it in step with the game, and in June 2020 the fork was rebranded **Legally Distinct Missile** at the original author's request. LDM is the version you want. It keeps compatibility with existing plugins and carries fixes for legacy Rocket problems including multithreading exceptions and a teleportation exploit.

You do not need to download it. The dedicated server ships it:

1. Stop the server.
2. Copy the `Rocket.Unturned` folder from the server's `Extras` directory.
3. Paste it into the server's `Modules` directory.
4. Start the server, and watch for Rocket in the startup log. `modules` in the console confirms it loaded.

On first start Rocket creates its own folder inside the instance, and from then on this is where plugin work happens:

```text
Servers/MyServer/Rocket/
  Rocket.config.xml              core settings, RCON, automatic shutdown
  Rocket.Unturned.config.xml     the Unturned-specific module settings
  Permissions.config.xml         groups, members, permissions
  Commands.config.xml            enable, disable and re-prioritise commands
  Rocket.en.translation.xml      message strings
  Plugins/                       plugin DLLs and their config files
  Libraries/                     shared dependencies
  Logs/                          Rocket.log, rotated on start
```

Unturned servers on RE:NODE ship with RocketMod already in place, so the module is installed and this folder exists after the first boot - you add plugins through the file manager or over SFTP. There is no allow-list of permitted plugins; what you upload is what runs, which is also a good reason to look at a plugin's source before you hand it your server.

#### Rocket.config.xml and what it turns on

Four blocks matter. The shipped defaults, with the things worth changing marked by their consequences:

Servers/MyServer/Rocket/Rocket.config.xml:

```xml
<RocketSettings>
  <RCON Enabled="false" Port="27115" Password="changeme"
        EnableMaxGlobalConnections="true" MaxGlobalConnections="10"
        EnableMaxLocalConnections="true" MaxLocalConnections="3" />
  <AutomaticShutdown Enabled="false" Interval="86400" />
  <WebConfigurations Enabled="false" Url="" />
  <WebPermissions Enabled="false" Url="" Interval="180" />
  <LanguageCode>en</LanguageCode>
  <MaxFrames>60</MaxFrames>
</RocketSettings>
```

`RCON` is off by default with a password of `changeme`, and if you turn it on without changing that you have published a remote console to the internet. Rocket's RCON is a plain TCP socket on port `27115`; it is not encrypted and it is not rate-limited beyond the connection counts above. Turn it on only if something actually needs it, change the password, and restrict who can reach the port. [RCON safely](https://www.renode.space/blog/rcon-safely) covers the general rules, and they apply here with more force than usual.

`AutomaticShutdown` with `Interval="86400"` is a once-a-day restart, off by default. It is a reasonable thing to switch on for a survival server, though a scheduled restart from your panel gives you a warning message and a backup first, which this does not. [Restart schedules that help](https://www.renode.space/blog/restart-schedules-that-help) covers picking a time.

The Unturned-side module file is the more interesting one:

Servers/MyServer/Rocket/Rocket.Unturned.config.xml:

```xml
<UnturnedSettings>
  <RocketModObservatory KickLimitedAccounts="true"
                        KickTooYoungAccounts="true"
                        MinimumAge="604800" />
  <AutomaticSave Enabled="true" Interval="1800" />
  <CharacterNameValidation>true</CharacterNameValidation>
  <LogSuspiciousPlayerMovement>true</LogSuspiciousPlayerMovement>
  <EnableItemBlacklist>false</EnableItemBlacklist>
  <EnableItemSpawnLimit>false</EnableItemSpawnLimit>
  <MaxSpawnAmount>10</MaxSpawnAmount>
  <EnableVehicleBlacklist>false</EnableVehicleBlacklist>
</UnturnedSettings>
```

`AutomaticSave` is the headline: enabled, every 1800 seconds. Installing RocketMod gives an Unturned server the half-hourly autosave it otherwise lacks entirely. If your server is busy and building-heavy, halve that interval; the save is brief and half an hour of lost construction is not.

`KickLimitedAccounts` and `KickTooYoungAccounts` with `MinimumAge="604800"` reject Steam accounts that are limited or less than seven days old. On a public server this removes a meaningful share of throwaway griefing accounts for free, and it also blocks the occasional legitimate new player, so it is a trade rather than a win.

#### Permissions: groups, inheritance and cooldowns

`Permissions.config.xml` is where most "the plugin does not work" reports actually end. A plugin's commands are not available to anybody until a group holds their permission node, and the node is simply the command's name.

Servers/MyServer/Rocket/Permissions.config.xml:

```xml
<RocketPermissions>
  <DefaultGroup>default</DefaultGroup>
  <Groups>
    <Group>
      <Id>default</Id>
      <DisplayName>Guest</DisplayName>
      <Color>white</Color>
      <Members />
      <Permissions>
        <Permission>p</Permission>
        <Permission>compass</Permission>
        <Permission>rocket</Permission>
      </Permissions>
    </Group>
    <Group>
      <Id>vip</Id>
      <DisplayName>VIP</DisplayName>
      <Color>FF9900</Color>
      <ParentGroup>default</ParentGroup>
      <Members>
        <Member>76561198012345678</Member>
      </Members>
      <Permissions>
        <Permission>kit.*</Permission>
        <Permission Cooldown="120">heal</Permission>
        <Permission Cooldown="30">v</Permission>
      </Permissions>
    </Group>
  </Groups>
</RocketPermissions>
```

Four mechanics are doing all the work here:

- **`DefaultGroup`** names the group everyone lands in without being listed anywhere. Whatever it holds, every player has.
- **`ParentGroup`** gives inheritance. `vip` inherits everything `default` has and adds its own, so you never repeat a node.
- **`Members`** is a list of SteamID64s. This is the only place a player is tied to a group, other than the `/p` command.
- **`Cooldown`** is per-permission and in seconds. `Cooldown="120"` on `heal` means a VIP can heal once every two minutes. This is the feature that makes a perks system survivable, and it is set nowhere else.

Wildcards work on dotted nodes: `kit.*` grants every kit a kit plugin defines, where `kit.starter` would grant one. Colours take a name or a hex value without a leading hash.

Changes to this file are picked up with `/p reload` rather than a restart. `/p <player> <group>` moves somebody between groups live, which is how you hand out a rank without opening a file at all. The same least-privilege thinking that applies to panel accounts applies here - [subusers and least privilege](https://www.renode.space/blog/subusers-and-least-privilege) makes the general argument, and it is the same argument: nobody needs `tp` because they moderate chat.

```diagram
title: Where a slash command is handled
player = Player types a command
rocket = Rocket module | command registry
perms = Permissions.config.xml | group, inheritance, cooldown
vanilla = Unturned console | built-in commands
run = Command runs
player -> rocket : /heal
rocket -> perms : is this group allowed?
perms -> run : yes, if off cooldown
player -> vanilla : /kick
vanilla -> run : admin only
```

Rocket's own commands are governed by that file. The vanilla commands in the earlier tables are not: they check administrator status and nothing else. Two systems, side by side, and a player can be a Rocket VIP with no vanilla powers or a vanilla admin with no Rocket permissions.

The built-in Rocket commands, all of which are permission nodes you can hand out:

| Command | Syntax | Effect |
| --- | --- | --- |
| `p` | `<player> [group]` or `reload` | Set a player's group, or reload the file |
| `rocket` | `<plugins or reload>`, `<load or unload or reload> <plugin>` | Manage plugins without a restart |
| `i` | `<id> [amount]` | Give yourself an item |
| `v` | `<id>` | Give yourself a vehicle |
| `more` | `<amount>` | More of what is in your hands |
| `heal` | `[player]` | Heal yourself or someone else |
| `god` / `vanish` | | Invulnerability, invisibility |
| `tp` | `<player, place or x y z>` | Teleport yourself |
| `tphere` | `<player>` | Teleport someone to you |
| `home` | | Back to your last bed |
| `broadcast` | `<color> <message>` | Announce something |
| `investigate` | `<player>` | Their SteamID64 |
| `compass` | `[direction]` | The direction you are facing |
| `exit` | | Leave without the disconnect cooldown |
| `rwho` / `rkick` / `rflush` | | List, kick and flush RCON clients |

#### Plugins and OpenMod

A plugin is a `.dll` dropped into `Rocket/Plugins/`. On first load it writes `<PluginName>.configuration.xml` and `<PluginName>.en.translation.xml` beside itself, which is your cue that it loaded at all - no config file means no load, and `Rocket/Logs/Rocket.log` will say why. Shared dependencies go in `Libraries/`. `rocket reload <plugin>` picks up a changed configuration without stopping the server.

The order of operations that avoids most grief:

1. Stop the server, or at least know you will reload afterwards.
2. Drop the DLL into `Plugins/` and start the server.
3. Read the log. Confirm the plugin loaded and wrote its config.
4. Stop, edit the config it generated, start again.
5. Grant its permission nodes to a group in `Permissions.config.xml`.
6. Test as a non-admin account. Admins bypass enough that testing as one proves nothing.

Step five is the one that gets skipped, and it produces the classic symptom: a plugin that loads cleanly, logs nothing, and ignores every command typed at it. Before you conclude a plugin is broken, check its node is in a group the tester belongs to.

OpenMod is the newer framework, written by one of Rocket's original maintainers, and it does not replace RocketMod - it runs alongside it and can host Rocket plugins through a compatibility layer. The easy install is the OpenMod installer plugin: drop it into `Rocket/Plugins/`, restart, run `/openmod install` and follow the prompts. The manual route copies an `OpenMod.Unturned` folder into `Modules/` and takes a long first start while it downloads its own components. Pick whichever framework the plugins you actually want are published for; there is no need to choose ideologically.

Whatever you install, take the backup first. Player structures, vehicles and inventories live in the instance's save files and a plugin that deletes them has no undo. Back up the instance folder on a schedule and restore one occasionally to prove the backup works, because [a backup nobody has restored is a hypothesis](https://www.renode.space/blog/backups-that-actually-restore). The general hygiene for a modded server - pinning versions, reading source, removing what you stopped using - is in [keeping a modded server clean](https://www.renode.space/blog/keeping-a-modded-server-clean), and workshop content follows its own rules covered in [Steam Workshop mods on dedicated servers](https://www.renode.space/blog/steam-workshop-mods-on-dedicated-servers).

#### Troubleshooting

**A command in `Commands.dat` does nothing.** It is a runtime command. `kick`, `ban`, `say` and `teleport` only exist while the server is up.

**The server keeps loading PEI.** `Map` does not match an installed level name. It is the internal name, not the display name, and a missing workshop map produces the same result.

**Edits to `Commands.dat` disappear.** The server was running when you saved. Stop, edit, start.

**Rocket did not load.** Run `modules` in the console. If `Rocket.Unturned` is not listed, the folder was not copied from `Extras` into `Modules`, or it was copied one level too deep.

**A plugin loaded but its commands are ignored.** Permissions, nine times out of ten. Add the node to a group in `Permissions.config.xml`, run `/p reload`, and test as a normal player.

**A plugin wrote no config file.** It did not load. `Rocket/Logs/Rocket.log` will name the missing dependency or the version mismatch.

**Players are kicked the moment they join.** `KickLimitedAccounts` or `KickTooYoungAccounts` in `Rocket.Unturned.config.xml`, or `Filter` in `Commands.dat` rejecting their name, or `Whitelisted` with an empty allow list.

**Progress is lost after a crash.** Vanilla Unturned has no autosave. Install RocketMod for its 30-minute `AutomaticSave`, shorten the interval, and schedule a `save` command as well.

**RCON refuses connections or accepts the wrong ones.** Port `27115`, a password that is still `changeme`, and connection limits that are lower than you think. Check all three before assuming a firewall.

#### FAQ

##### What is the difference between Commands.dat and the config file?

`Commands.dat` sets what the server is - name, map, port, slots, owner, password, token. The difficulty config sets how the game plays - loot chance, zombie damage, vehicle respawn times. They never overlap, and almost every "which file do I edit" question is answered by that split.

##### Is RocketMod still maintained?

Yes, as Legally Distinct Missile, maintained by Smartly Dressed Games since the original team stepped away in December 2019. It ships with the dedicated server in the `Extras` folder, so the copy you install is always current with the game build.

##### Why does my plugin load but do nothing?

Its commands have no permission node granted to the group the player is in. Open `Permissions.config.xml`, add the command's name as a `Permission` in the right group, and run `/p reload`. Test as a non-admin, because administrators bypass enough checks to hide the problem.

##### Can I run RocketMod and OpenMod together?

Yes. OpenMod was designed to sit alongside Rocket rather than replace it, and it can run Rocket plugins through a compatibility layer. The installer plugin route sets both up in a few minutes.

##### Does Unturned autosave?

Not in vanilla. The base server saves on a clean `shutdown` and when you type `save`, and at no other time. RocketMod adds an `AutomaticSave` every 1800 seconds, which is the single best reason to install it even on a server with no plugins.

##### How do I limit a perk without giving it away?

Use the `Cooldown` attribute on the permission rather than a plugin setting: `<Permission Cooldown="120">heal</Permission>` allows one heal every two minutes. Cooldowns are per-permission and per-group, so the same command can be generous for staff and rationed for donors.

Unturned servers on RE:NODE start at 2 GB with RocketMod already installed, both UDP ports allocated, an in-browser editor and SFTP for `Commands.dat` and the `Rocket` folder, a console with command history, and backup slots on every tier. The Steam login token stays yours: you enter it on the Setup tab.

[See Unturned plans](https://www.renode.space/game-servers/unturned)

---

### Unturned server setup with maps and RocketMod

Published 2026-06-26, updated 2026-09-21 by RE:NODE Team. https://www.renode.space/blog/unturned-server-setup

Unturned asks almost nothing of a server, which makes it a good first one to run. Two gigabytes and one core will carry a full group on an official map, the whole configuration lives in a handful of files under one folder, and the dedicated server installs anonymously in about a minute. The mistakes people make are all in the same two places: workshop content that the server has and the client does not, and a missing Game Server Login Token that leaves the server running perfectly and invisible to everyone. This guide covers the install, every file that matters, the ports, the workshop, RocketMod and the errors in between.

#### What you are running

The Unturned 3 dedicated server is its own Steam application, app id `1110390`, installed anonymously and landing in a folder called `U3DS`. It does not need a copy of the game and it does not need a licence. The client's app id is `304930`, which matters in two places: workshop downloads, and the login token.

Everything about one server lives inside a single instance folder, and you can run several instances from one install by giving each a different name:

```text
U3DS/
  ServerHelper.sh              Linux start script
  ServerHelper.bat             Windows start script
  Servers/
    MyServer/                  one instance
      Server/
        Commands.dat           what the server is
        Config.json            how the game plays (older servers)
        Config.txt             how the game plays (3.25.8.0 and newer)
        Adminlist.dat          SteamID64 per line
        Blacklist.dat
        Whitelist.dat
      WorkshopDownloadConfig.json workshop items to fetch at boot
      Rocket/                  RocketMod, if installed
```

That split is the mental model for the whole game. `Commands.dat` decides what the server **is** - its name, port, map, slots and owner. The gameplay config decides how the game **plays** - loot, zombies, vehicles, damage. Two files, two jobs, and almost every question about Unturned hosting is really a question about which of them you should be editing.

#### Requirements and resource usage

| Server | RAM | CPU | Notes |
| --- | --- | --- | --- |
| 8-12 players, official map, vanilla | 2 GB | 1 core | Genuinely enough, not a starting figure |
| 16-24 players, curated map | 3-4 GB | 1.5 cores | Larger maps hold more objects |
| 24-40 players, RocketMod plugins | 4-6 GB | 2 cores | Plugins and saved structures add up |
| Large workshop map plus mod packs | 6-8 GB | 2-2.5 cores | The map is usually the memory |

The variable is the map, not the player count. Official maps like Washington and PEI are small and cheap; big community maps hold far more objects and load far more assets. A server's memory use also creeps up as players build - every structure and barricade is saved and simulated - so a server that fits in 2 GB in week one may want 3 GB by month three.

Disk is modest: the server install is a couple of gigabytes, and workshop content is usually a few hundred megabytes per large map. Unturned plans here start at 2 GB with 10 GB of disk, which is the honest size for this game rather than an upsell. If you are trying to work out a slot count, [how many players fit on a server](https://www.renode.space/blog/how-many-players-fit-on-a-server) covers the general method.

#### Installing the server and starting it

```bash
$ steamcmd +force_install_dir /home/unturned/U3DS +login anonymous \
    +app_update 1110390 validate +quit
$ cd /home/unturned/U3DS
$ ./ServerHelper.sh +InternetServer/MyServer
```

On Windows the same thing is `ServerHelper.bat +InternetServer/MyServer`. Replace `InternetServer` with `LanServer` for a local-only test. The instance name after the slash is the folder under `Servers/`, and it is created on first run along with the config files - so start the server once, stop it, and then edit what it generated rather than writing the files from scratch. [SteamCMD explained](https://www.renode.space/blog/steamcmd-explained) covers `validate`, update scripts and what the app id arguments mean.

> [!NOTE]
> Stop the server before editing any of these files. Unturned writes its config and its save data on shutdown, so edits made while it is running are overwritten the moment you stop it.

#### Commands.dat: the server's identity

`Commands.dat` is a plain list, one command per line, read once at boot. A complete file for a small survival server:

Servers/MyServer/Server/Commands.dat:

```text
Name Thursday Survival
Owner 76561198012345678
Port 27015
Map Washington
MaxPlayers 24
Mode Normal
Perspective Both
Welcome Read the rules in Discord. No raiding offline bases.
Password
Queue_Size 8
Filter
Cheats
GSLT 0123456789ABCDEF0123456789ABCDEF
```

The commands worth knowing:

| Command | Effect |
| --- | --- |
| `Name` | Server name in the browser, up to 50 characters |
| `Owner` | A SteamID64 that gets permanent admin |
| `Port` | Query port; the game runs on this plus one |
| `Map` | Internal map name, not the display name |
| `MaxPlayers` | Slot count |
| `Mode` | `Easy`, `Normal` or `Hard` - picks which difficulty config applies |
| `PvE` | Present means PvE; absent means PvP |
| `Perspective` | `First`, `Third`, `Vehicle` or `Both` |
| `Password` | Join password; leave the value blank for none |
| `Queue_Size` | How many players may wait for a slot |
| `Cheats` | Present enables cheat commands, absent disables them |
| `Filter` | Rejects players whose names contain junk characters |
| `Gold` | Restricts the server to Gold Upgrade owners |
| `Loadout` | Skillset and starting items for new spawns |
| `Welcome` | Message shown on join |
| `GSLT` | The login token, if you do not put it in the config file |

`Mode` is the one that surprises people. It does not just change a damage number - it selects which difficulty block of the gameplay config the server uses, so a `Mode Hard` server ignores the numbers you carefully edited under Normal.

`Map` takes the internal name. Official and curated maps ship with the game and need nothing else; if the server cannot find the name you gave it, it silently loads PEI instead. A server that keeps booting into PEI has a typo, not a bug.

#### The gameplay config: Config.txt and Config.json

Servers created on build 3.25.8.0 or later get `Config.txt`, a commented plain-text file with sections in braces. Older instances have `Config.json` holding the same settings as JSON. The structure is the same either way: a `Browser` section for how the server presents itself, a `Server` section for connection behaviour, and a block per difficulty - `Easy`, `Normal`, `Hard` - each containing `Items`, `Vehicles`, `Zombies`, `Animals`, `Barricades`, `Structures`, `Players`, `Objects`, `Events` and `Gameplay`.

The settings people actually change, with their Normal-difficulty defaults:

| Setting | Default | What it does |
| --- | --- | --- |
| `Items.Spawn_Chance` | `0.35` | Chance that a spawn point holds an item |
| `Items.Respawn_Time` | `50.0` | Seconds before a looted point can refill |
| `Items.Despawn_Dropped_Time` | `600.0` | Seconds before dropped items vanish |
| `Items.Quality_Multiplier` | `1.0` | Condition of items that spawn |
| `Zombies.Spawn_Chance` | `0.2` | Chance a zombie spawn point is used |
| `Zombies.Respawn_Day_Time` | `360.0` | Seconds before a killed zombie returns in daylight |
| `Zombies.Respawn_Night_Time` | `30.0` | The same at night |
| `Zombies.Damage_Multiplier` | `0.75` | How hard zombies hit |
| `Zombies.Armor_Multiplier` | `1.25` | How much damage they absorb |
| `Vehicles.Respawn_Time` | `300.0` | Seconds before a destroyed vehicle respawns |

Those defaults are the Normal block's. Change `Mode` in `Commands.dat` and a different set applies, which is the most common reason an edit "does nothing".

The `Browser` section holds `Icon` and `Thumbnail` - URLs to small images shown in the server list - plus the description fields, a `Monetization` declaration you should fill in honestly if you sell anything, and `Login_Token`. The `Server` section holds `VAC_Secure` and `BattlEye_Secure`, both of which should stay on for a public server, along with ping and timeout limits.

A word on loot multipliers, since raising them is the first thing everyone does: `Items.Spawn_Chance` at `1.0` does not make your server generous, it makes it pointless. Every building is full, nobody needs to travel, and the game is over in an evening. If you want a faster server, cut `Items.Respawn_Time` instead so places refill sooner while a run through town still means something.

#### Ports, the GSLT and connecting

| Port | Protocol | Purpose |
| --- | --- | --- |
| `27015` | UDP | Server list queries, set by `Port` |
| `27016` | UDP | Game traffic, always `Port` + 1 |

Both are UDP, and both must be reachable. If you run two instances on one machine, space the `Port` values by at least two - 27015 and 27017 - or the second server's game port collides with the first server's query port. Unturned plans here come with two allocations, which is exactly this pair. [Game server ports explained](https://www.renode.space/blog/game-server-ports-explained) covers what a query port is for and how to tell which of the two is blocked.

The token is the other half of being visible. Since build 3.21.31.0, a server without a Game Server Login Token is hidden from the internet server list - it runs, people can still join by IP, and it will never be found by anyone browsing. Create one at Steam's game server account page using **app id 304930**, then put it in one place, not both:

```text
GSLT 0123456789ABCDEF0123456789ABCDEF
```

in `Commands.dat`, or as `Login_Token` in the `Browser` section of the config file. The token belongs to your Steam account, it can be banned if the server misbehaves, and each running server needs its own. [Steam game server tokens explained](https://www.renode.space/blog/steam-game-server-tokens-gslt) covers the rules, and [monetising a game server within the rules](https://www.renode.space/blog/monetising-a-game-server-within-the-rules) covers what you may sell before that token becomes a liability.

On RE:NODE the token is yours to create: the server is built as soon as payment clears, and the install waits on the Setup tab until you paste it in. That is deliberate. A host that hands you a token has given you somebody else's credential.

#### Workshop maps and content

Workshop items belong in the config, not in the file system. Add the IDs to `WorkshopDownloadConfig.json` in the instance folder and the server downloads them at boot and hands the list to joining players, who fetch the same items from Steam automatically:

Servers/MyServer/WorkshopDownloadConfig.json:

```json
{
    "File_IDs": [
        1205209275,
        1440592288
    ]
}
```

Install a map by hand instead and players are sent to a world they cannot load, which reads to them as a broken server rather than a missing download.

```diagram
title: How a workshop map reaches a joining player
ids = WorkshopDownloadConfig | File_IDs array
server = Unturned server | downloads at boot
steam = Steam Workshop
client = Player | downloads on join
ids -> server : read at start
steam -> server : content
server -> client : required id list
steam -> client : the same items
```

Three rules keep this painless:

- **Curated maps need no extra setup** and are the sensible starting point. They ship with the game on both ends, so there is nothing to download and nothing to mismatch.
- **Many community maps are two items**, a terrain and an asset pack. Include only one and players see floating red error text where objects should be. Read the map's workshop page for what else it requires.
- **Restart after every change.** The IDs file is read at boot, and a workshop item that updated mid-session is not picked up until the server restarts.

Mod content follows the same path - an item pack is a workshop id like any other. [Steam Workshop mods on dedicated servers](https://www.renode.space/blog/steam-workshop-mods-on-dedicated-servers) covers how those downloads work across games, including what happens when an author unlists an item you depend on.

#### Admins, RocketMod and plugins

Vanilla administration is a console and three text files. `Adminlist.dat`, `Whitelist.dat` and `Blacklist.dat` each hold one SteamID64 per line, and the `Owner` command in `Commands.dat` grants permanent admin without touching them. The console commands worth memorising:

| Command | Effect |
| --- | --- |
| `admin <player>` | Grant admin to a connected player |
| `unadmin <player>` | Remove it |
| `kick <player> <reason>` | Kick |
| `ban <player> <reason> <duration>` | Ban, duration in seconds |
| `unban <steamid>` | Lift a ban |
| `players` | List who is connected |
| `save` | Write the world to disk now |
| `shutdown` | Clean stop, with a save |
| `day` / `night` | Set the time of day |

Anything past that is a plugin framework. RocketMod is the long-standing one: it installs as a module in the server's `Modules` folder, and once it has started it creates a `Rocket` folder inside your instance with `Rocket.config.xml`, a `Plugins` folder and `Permissions.config.xml`. Plugins are DLLs dropped into `Rocket/Plugins`, and each generates its own configuration file on first load.

The thing that catches everyone with RocketMod is permissions. A plugin that loads correctly but whose commands do nothing is almost always a permissions problem: commands must be granted to a group in `Permissions.config.xml` before anyone but an admin can run them. Check that file before you conclude the plugin is broken. OpenMod is the more modern alternative and can run alongside RocketMod through an installer plugin, which is worth knowing if a plugin you want is only published for one of them.

Unturned servers on RE:NODE ship with RocketMod already in place, so the module is installed and the `Rocket` folder exists on first boot - you add plugins through SFTP or the file manager. There is no allow-list of permitted plugins; what you upload is what runs, which is also a reason to read a plugin's source before you give it your server. [Commands.dat and RocketMod in detail](https://www.renode.space/blog/unturned-commands-and-rocketmod) goes further into both.

Whatever you install, keep the save. Player structures, vehicles and inventories live in the instance's save files, and there is no undo for a plugin that deletes them. Back up the instance folder on a schedule and restore one occasionally to prove it works - [backups that actually restore](https://www.renode.space/blog/backups-that-actually-restore) exists because a backup nobody has restored is a hypothesis. A nightly restart is worth having too; [restart schedules that help](https://www.renode.space/blog/restart-schedules-that-help) covers picking an interval.

#### Troubleshooting

**The server runs but nobody can find it in the list.** No Game Server Login Token, or a banned one. Test by joining directly by IP; if that works, the token is the problem.

**The server always loads PEI.** The `Map` name is wrong or its workshop item did not download. Map names are internal names, and they are case-sensitive in practice.

**Players get kicked to a red error screen on join.** Missing workshop content. Usually a map's asset pack that is not in `WorkshopDownloadConfig.json`.

**Config edits do nothing.** Either the server was running when you saved them and overwrote them on shutdown, or you edited the wrong difficulty block for the `Mode` in `Commands.dat`.

**Two servers on one machine fight over a port.** Space `Port` values by two, not one. The game port is always the query port plus one.

**A plugin loads but its commands are ignored.** Permissions, in `Rocket/Permissions.config.xml`, nine times out of ten.

**Memory climbs over weeks.** Player-built structures. That is normal growth rather than a leak, and it is the usual reason a 2 GB server eventually wants 3 GB. Changing tier changes the limit on the server you already have, so the world stays where it is.

#### FAQ

##### How much RAM does an Unturned server need?

2 GB is enough for a dozen players on an official map, and that is not a hedge - Unturned is one of the lightest survival games to host. Budget 4 GB if you are running a large community map with mods, and expect slow growth as players build.

##### Do I need my own Steam login token?

Yes, for any public server. Since build 3.21.31.0 a server without one is hidden from the internet server list. The token is created against app id 304930 on your own Steam account and goes in `Commands.dat` or the config file, not both.

##### Config.json or Config.txt - which one do I have?

Servers created on build 3.25.8.0 or later use `Config.txt`; older instances keep `Config.json`. The settings are the same and so is the structure. Edit whichever one is in your instance folder rather than creating the other.

##### Why do my loot settings have no effect?

Because the config has a separate block for each difficulty and the server only reads the one matching `Mode` in `Commands.dat`. Edit the block that matches, or change `Mode`.

##### Can players join without subscribing to my workshop maps?

They do not need to subscribe manually. The server sends the required item list on join and the client downloads it from Steam automatically - as long as every required id, including asset packs, is in `WorkshopDownloadConfig.json`.

##### Is RocketMod still the right choice?

It is still the most widely supported framework and most existing plugins target it, which is why it ships preinstalled here. OpenMod is newer and can run alongside it. Pick whichever the plugins you actually want are published for.

Unturned servers on RE:NODE start at 2 GB - genuinely enough here, and the plan says so rather than upselling you - with RocketMod already installed, both UDP ports allocated, SFTP and an in-browser file editor for `Commands.dat` and the config, and backup slots on every tier. The login token stays yours: you enter it on the Setup tab.

[Compare the smaller plans](https://www.renode.space/game-servers/unturned)

## Rules for the assistant

- Never ask the user for a password, token, API key or `.env` contents, and tell them not to paste one into this chat. Describe where a secret goes instead.
- Secrets reach the server through the panel: `.env` is uploaded through the Files tab, startup variables are set on the Startup tab. `.env` never goes in the repository.
- An app server has exactly one reachable port. Read it from `SERVER_PORT` (also `PORT` when the panel starts a linked repository) and bind `0.0.0.0`; never hard-code a port.
- On every panel-managed server (everything except VDS and dedicated servers, which come with full root) only `/home/container` persists, and the process runs unprivileged: no root, `sudo`, `apt`, `systemd` or Docker.
- Memory is a hard limit; a process that reaches it is killed with no error message. Suggest a bigger plan only after ruling out a leak.
- Do not suggest changing the server's startup command or image to work around a code problem - fix the code or the repository.
- Prices and plans above were read when this file was generated. Send the user to the page linked at the top before quoting a price as current.
- For a specific server, the panel's Connect AI link (Console tab) gives the exact runtime, port, path and branch. Prefer it over these general rules when the user has one.
- If something here does not answer the question, the full deploy docs are at https://www.renode.space/llms-full.txt and support is at https://www.renode.space/contact.