# Sons of the Forest Server Hosting - everything RE:NODE has published

> A Sons of the Forest 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/sons-of-the-forest, 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/sons-of-the-forest.

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

## What it is

Sons of the Forest servers. The game caps a lobby at eight, so the tiers buy performance rather than slots.

- Genres: Action, Adventure, Indie, Simulation
- Developer: Endnight Games Ltd
- Released: 22 Feb, 2024
- Steam: https://store.steampowered.com/app/1326470/

### What comes with every Sons of the Forest 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 Sons of the Forest 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.
- 3 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 Sons of the Forest plan do you need?

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

Storage matters more than people expect once mods and backups are involved - plans here run from 50 GB to 85 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/sons-of-the-forest or in the panel shop at https://panel.renode.space before quoting one.

| Plan | Price / month | Memory | CPU | NVMe disk | Databases | Backups | Ports |
|---|---|---|---|---|---|---|---|
| Advanced | $20 | 8 GB | 2 vCPU | 50 GB | 1 | 2 | 3 |
| Pro | $25 | 10 GB | 2.5 vCPU | 65 GB | 1 | 2 | 3 |
| Premium | $30 | 12 GB | 3 vCPU | 85 GB | 1 | 2 | 3 |


## 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

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

- [Sons of the Forest server not showing or can't join](https://www.renode.space/blog/sons-of-the-forest-server-connection-problems) (2026-10-15): Fix a Sons of the Forest dedicated server that is missing from the list or will not let players in: the three UDP ports, IpAddress, LanOnly, versions and logs.
- [Sons of the Forest server performance: RAM, CPU and lag](https://www.renode.space/blog/sons-of-the-forest-server-performance) (2026-10-15): How much RAM and CPU a Sons of the Forest server needs by player count, why it is heavy, the frame-rate targets, autosave hitches and long-session slowdowns.
- [Sons of the Forest settings and saves](https://www.renode.space/blog/sons-of-the-forest-server-settings-and-saves) (2026-10-07): Pick Sons of the Forest server settings that suit your group, change rules on an existing world, and move saves to, from and between dedicated server slots.
- [Sons of the Forest dedicated server setup](https://www.renode.space/blog/sons-of-the-forest-dedicated-server) (2026-09-21): Run a Sons of the Forest dedicated server: the install, dedicatedserver.cfg key by key, the three UDP ports, owners and admins, custom settings and saves.

---

### Sons of the Forest server not showing or can't join

Published 2026-10-15 by RE:NODE Team. https://www.renode.space/blog/sons-of-the-forest-server-connection-problems

When a Sons of the Forest dedicated server will not show up or will not let people in, the cause is nearly always one of five things, and the symptom tells you which. Missing from the list but joinable by address: the query port `27016` or `LanOnly`. Listed but every join times out: the game port `8766`, or `IpAddress` bound to the wrong interface. Joins, then hangs forever on the loading screen: the BlobSync port `9700`. Worked yesterday, rejects everyone today: a game patch and a server that was not updated. Rejects one person only: their password, their client version or their network. All three ports are UDP, and a rule that opens TCP instead is the most common way to do everything right and still fail.

This guide works through each of those in order, with the checks that separate them. The install, every key in `dedicatedserver.cfg` and the owner list are covered in the [Sons of the Forest dedicated server guide](https://www.renode.space/blog/sons-of-the-forest-dedicated-server); save slots and moving worlds are in [Sons of the Forest settings and saves](https://www.renode.space/blog/sons-of-the-forest-server-settings-and-saves). Here the only subject is getting players from the menu into the world.

#### Match the symptom to the cause

Start by being precise about what players see. "It doesn't work" covers half a dozen unrelated faults, and the fix for one of them does nothing for the others.

| What players see | Most likely cause | First check |
| --- | --- | --- |
| Not in the list, direct join works | Query port blocked, or list delay | UDP `27016` open |
| Not in the list, direct join fails | Server not reachable at all | Log, `IpAddress`, all ports |
| Listed, join times out | Game port blocked or wrong bind | UDP `8766`, `IpAddress` |
| Joins, stuck on loading | BlobSync port blocked | UDP `9700` |
| Rejected after a patch | Client and server builds differ | Run `app_update` |
| Wrong password message | Password typed or stored wrongly | JSON value, case |
| Visible to friends, not to host | Hairpin NAT at home | Join on the LAN address |

Two quick tests narrow it down faster than anything else. First, can anyone outside your network join by address? If yes, the server works and the problem is listing, a single client or your own LAN. Second, does the server log show the start-up network test passing? If it reports a closed port, believe it before you believe the router's web page.

#### The three ports, and what each one breaks

Sons of the Forest uses three UDP ports, all set in `dedicatedserver.cfg`:

dedicatedserver.cfg:

```json
{
  "IpAddress": "0.0.0.0",
  "GamePort": 8766,
  "QueryPort": 27016,
  "BlobSyncPort": 9700
}
```

Each one fails in its own recognisable way, which is useful, because it means you can usually name the closed port from the symptom alone.

- **`QueryPort` (`27016`)** is what Steam's master server and the in-game browser use to see the server, read its name and player count, and measure ping. Block it and the server still runs and still accepts direct joins, but it never appears in the list. If the list shows the server with no ping or a stale player count, the query traffic is getting through intermittently or not at all.
- **`GamePort` (`8766`)** carries the actual game session. Block it and the server can appear in the list - the query port still answers - but clicking join ends in a timeout.
- **`BlobSyncPort` (`9700`)** transfers world state to a joining player. Block it and the connection succeeds, the loading screen appears, and it never finishes. This is the one people miss, because most Steam games have only the first two and a checklist copied from another game will not include it.

All three must be UDP. Port forwarding pages on home routers often default to TCP or to "TCP/UDP"; check which one you picked. A forward of `8766` TCP does exactly nothing for this game. If the difference is new to you, [TCP vs UDP for game servers](https://www.renode.space/blog/tcp-vs-udp-for-game-servers) explains why games use UDP and why that makes testing harder.

You can change any of the three numbers. The usual reason is a second server on the same machine, and then all three must differ between the two servers - two servers sharing a BlobSync port produces exactly the stuck-on-loading symptom for whichever started second. When you change a port in the config, change the forward, the firewall rule and anything you have told players to type, all at once. A port changed in one place and not the others is a large share of "it broke after I tidied up" reports. The general picture of game, query and transfer ports is in [game server ports explained](https://www.renode.space/blog/game-server-ports-explained), and [query ports and A2S](https://www.renode.space/blog/query-ports-and-a2s) covers what the query port is actually answering.

On start the server runs its own accessibility test against the three ports and writes the result to the console. A failed test tells you which port it thinks is closed, or that a port is already in use. "Already in use" usually means a previous copy of the server never exited - a crashed process still holding the port - or another program on the machine is on that number. Find and stop the old process before changing anything else.

#### IpAddress: what the bind setting really does

`IpAddress` is the local address the server listens on. It is not the address players type, and it is not your public IP.

`0.0.0.0` means every interface on the machine, and on a home PC, a VPS or inside a container it is what you want. The mistake that comes up again and again is putting the public address here because it seems like the server ought to know its own address. On a machine behind a router, the public address does not belong to any interface on that machine - it belongs to the router - so the server tries to listen on an address it does not have. Depending on the build, that either fails at start or produces a server that runs and that nobody can reach.

There are two legitimate reasons to set something other than `0.0.0.0`:

- **A machine with several network interfaces**, such as a server with a public and a private network, where you want the game on one and not the other. Use the address of that interface exactly as the operating system shows it.
- **A machine with several public addresses**, where each game server should own one. Again, the address must be one the machine actually holds.

On Windows, `ipconfig` lists the addresses the machine has; on Linux, `ip -4 addr`. If the value in `IpAddress` is not in that output, it is wrong. A related trap is a home PC whose LAN address changes after a reboot because the router hands it out by DHCP. If you bound to `192.168.1.40` and the machine is now `192.168.1.52`, the server listens on nothing useful and the router forwards to an empty address. Use `0.0.0.0` in the config and give the PC a DHCP reservation in the router, so the forward always lands on the same machine.

The server also needs a public IPv4 address to register with Steam. A connection that has only IPv6, or whose IPv4 is shared behind carrier-grade NAT, can start the server without being able to list it or receive joins. The log will say it could not get a public address from Steam, or the network test will fail on every port at once. [IPv6 and game servers](https://www.renode.space/blog/ipv6-and-game-servers) covers why Steam games still assume IPv4.

#### LanOnly, hairpin NAT and testing from the right place

`LanOnly` set to `true` keeps the server off the public internet entirely. It does not register with Steam's public list, and players outside your network cannot join. It is the right setting for a LAN party and the wrong one for everything else, and because the server starts cleanly either way, it is worth checking before you go hunting through router menus.

The second trap at home is testing from inside your own network. Most consumer routers do not support hairpin NAT (also called NAT loopback): a PC on your LAN that connects to your own public address is not routed back inside. The result is a server that friends across town join without trouble and that the person hosting it cannot reach by the public IP. That is not a server fault. The host should join by the LAN address of the server PC, and everyone else by the public one.

The same effect breaks the server's own self-test. It probes its public address from inside the network, and without hairpin support that probe fails on a server that is perfectly reachable from outside. This is the only good reason to set `SkipNetworkAccessibilityTest` to `true`: you have confirmed with a player outside your network that joining works, and the test still says otherwise. Setting it to silence a test you have not understood just hides the error message while players keep failing.

So test from outside. A friend's PC, a phone tethered on mobile data with the game installed on a laptop, or a server elsewhere that can query Steam - any of those tells you the truth. The server's own machine and anything on its LAN cannot.

#### Hosting at home: forwards, firewalls and CGNAT

If the server runs on a PC at home, three layers stand between players and the game, and all three need the same three UDP ports.

1. **The router.** Forward UDP `8766`, `27016` and `9700` to the LAN address of the server PC. Some routers want a range per rule; three single-port rules is fine.
2. **The operating system firewall.** On Windows, the first time `SonsOfTheForestDS.exe` listens, Windows Defender Firewall asks whether to allow it. Dismiss that dialog, or tick only "private networks" while your network is marked public, and the inbound traffic is dropped without another word.
3. **The connection itself.** If your provider uses carrier-grade NAT, no forward you set will ever work, because your router does not hold the public address.

On Windows, an explicit inbound rule is more dependable than trusting the dialog. From an administrator prompt:

```bash
$ netsh advfirewall firewall add rule name="Sons of the Forest server" dir=in action=allow protocol=UDP localport=8766,27016,9700
```

On a Linux host running the server under Wine or Proton, with `ufw` as the firewall:

```bash
$ sudo ufw allow 8766/udp
$ sudo ufw allow 27016/udp
$ sudo ufw allow 9700/udp
```

If the server runs in Docker, each port also has to be published with its protocol, such as `-p 9700:9700/udp`. Docker publishes TCP by default, and a container started with `-p 9700:9700` has the same missing-UDP problem as a router forward set to TCP. [Firewall rules that matter](https://www.renode.space/blog/firewall-rules-that-matter) and the [ufw guide](https://www.renode.space/blog/ufw-firewall-guide) cover the wider picture.

To spot CGNAT, compare the WAN address shown on the router's status page with the address a site such as a "what is my IP" page reports. If they differ, or the router's WAN address sits in `100.64.0.0/10`, your connection is shared and inbound forwarding cannot work. The fixes are to ask the provider for a public IPv4 address, which some give on request and some charge for, or to run the server somewhere that has one. [NAT and CGNAT for game hosts](https://www.renode.space/blog/nat-and-cgnat-for-game-hosts) goes through the options, and [port forwarding vs hosted servers](https://www.renode.space/blog/port-forwarding-vs-hosted-servers) is the honest comparison of fighting this at home against renting.

On a hosted server most of this disappears. On RE:NODE, Sons of the Forest plans come with three port allocations, and they are already open to the internet; there is no router or Windows firewall in front of them. What you do need to check is that the three numbers in `dedicatedserver.cfg` match the allocations shown on the Network tab, because a config copied from a home server will carry the home port numbers with it.

#### Checking from outside: is Steam listing it at all?

The in-game browser is slow to refresh and filters aggressively, so "not in the list" in game does not always mean "not registered". Steam's public Web API answers the question directly. Put the server's public IPv4 address into this URL in any browser:

```text
https://api.steampowered.com/ISteamApps/GetServersAtAddress/v1/?addr=203.0.113.25
```

It returns every Steam game server registered from that address, with the ports Steam knows about. An empty list means the server has not registered with Steam: look at `LanOnly`, the public IPv4 problem and the server log. A result with your server in it means Steam has it, and a player who still cannot see it in game has a browser filter set, or a cached list, or the query port is blocked between Steam and the server so the browser cannot ping it.

The Steam client's own server browser is a second opinion. In Steam, open View, then Game Servers, go to Favourites and add the server by address and query port. If it answers there with a name and ping, query traffic reaches it. That is useful for isolating the game's browser from the network: if Steam's browser sees the server and the game does not, the problem is on the game side, usually a filter or a version difference.

#### Version mismatch after a patch

Client and server must run the same build. Steam updates players' copies of the game automatically, usually the day a patch ships. The dedicated server is a separate app (`2465200`) that updates only when someone runs SteamCMD against it. So the day after a patch, the server is on yesterday's build and everyone who has updated is turned away - often with a message that does not mention versions, or with a connection that simply ends.

The fix is to update the server, then restart it:

```bash
$ steamcmd +force_install_dir C:\sotf-server +login anonymous \
    +app_update 2465200 validate +quit
```

Do it before anyone tries to join, and take a copy of the save first, since patch day is also the most likely day for a save format change. [SteamCMD explained](https://www.renode.space/blog/steamcmd-explained) covers `validate` and installs, and [SteamCMD errors and fixes](https://www.renode.space/blog/steamcmd-errors-and-fixes) covers what to do when the update itself fails.

The opposite mismatch happens too. A player who has opted into a beta branch of the game in Steam's properties is on a different build from a server running the public branch. If exactly one person cannot join after everyone else can, ask them to check the game's Betas tab in Steam and to verify their files. The reverse - a server pinned to an old build while players move on - is how a server running a script with an old `-beta` argument quietly stops accepting anyone. [SteamCMD app ids and beta branches](https://www.renode.space/blog/steamcmd-app-ids-and-beta-branches) explains how that happens.

A habit worth building: when a patch is announced, update and restart the server on the same day, and tell the group. [Game server update day checklist](https://www.renode.space/blog/game-server-update-day-checklist) has the steps in order, and [automating game server updates](https://www.renode.space/blog/automating-game-server-updates) covers making it someone else's job - namely, a scheduled task.

#### Passwords that do not work

`Password` is a plain string in the JSON, up to 40 characters. Empty means no password. Three things go wrong with it:

- **Case and spacing.** The match is exact. A trailing space pasted from a chat message is part of the password.
- **JSON escaping.** A password containing a double quote or a backslash must be escaped as `\"` or `\\`, or the file stops parsing. Easier to pick a password without either.
- **A command-line override.** Every config key can be set on the command line with a `-dedicatedserver.` prefix, and the command line wins. If a panel or a start script passes `-dedicatedserver.Password`, changing the file does nothing. Check the start command before deciding the server is ignoring you.

The password applies at every restart, so a change is a stop and start away, and it does not touch the world. If one player cannot get in with a password that works for everyone else, have them type it rather than paste it. If nobody can, read the start-up log for the configuration line before suspecting the network.

#### Reading the server log

The console output is where every one of these problems announces itself, and it is worth reading top to bottom once on a server that works, so you know what normal looks like. Start the server with `-verboseLogging` while you are diagnosing; the extra detail is the difference between knowing and guessing. Set `LogFilesEnabled` to `true` if you also want the output written to files under the user data folder, with `TimestampLogFilenames` keeping each start in its own file.

What to look for, in order:

1. **The configuration being read.** A parse failure means malformed JSON - a trailing comma, a smart quote, an unescaped character in the password - and the server stops there. Fix the file and start again.
2. **The ports being opened.** An "in use" message means another process holds the number. Stop it, or move this server to free ports.
3. **The public address from Steam.** A failure here means no public IPv4 is available: IPv6-only connections, CGNAT, or Steam having a bad moment, in which case a restart a few minutes later is worth one try.
4. **The network accessibility test.** Each port is reported as reachable or not. A single closed port names your problem. All three closed usually means the forward points at the wrong machine, the firewall is dropping everything, or hairpin NAT is breaking the test itself.
5. **Players connecting.** With a join in progress, the log shows the connection arrive. If the game port connection appears and nothing follows, the BlobSync transfer is not getting through.

```diagram
title: Where a join fails, and which setting to check
player = Player | menu and browser
query = Query 27016 | listing and ping
game = Game 8766 | session
blob = BlobSync 9700 | world state
world = In the world
player -> query : not listed: query, LanOnly
query -> game : times out: game port, IpAddress
game -> blob : stuck loading: 9700
blob -> world
```

On RE:NODE the console shows the server's live output unfiltered, so the network test and every join appear as they happen, and the Startup tab is where any command-line overrides live. That is the first place to look when a value in the file seems to be ignored.

One more thing the log reveals: repeated restarts. A server that crashes on load, perhaps because of a damaged save, restarts and looks briefly "online" before vanishing again. To players that is indistinguishable from a network problem. If uptime in the console keeps resetting, the problem is the server, not the ports - [why your game server keeps restarting](https://www.renode.space/blog/why-your-game-server-keeps-restarting) is the place to start.

#### FAQ

##### Why does my server show up for friends but not for me?

You are on the same network as the server, and your router does not loop traffic to its own public address back inside. Join using the server PC's LAN address instead. Everyone outside your network uses the public address as normal.

##### Which ports do I need to forward for Sons of the Forest?

UDP `8766` for the game, UDP `27016` for the Steam query, and UDP `9700` for BlobSync, unless you changed them in `dedicatedserver.cfg`. All three must be UDP. Missing the third one causes the endless loading screen.

##### Should I put my public IP in IpAddress?

No. `IpAddress` is the local interface to listen on, and `0.0.0.0` means all of them. Only set a specific address when the machine has several and you want the server on one, and then use an address the machine itself holds.

##### Players got kicked back to the menu right after a game update. What happened?

Their game updated and the server did not. Stop the server, run `app_update 2465200` through SteamCMD, and start it again. Back up the save first, since patch days are when formats change.

##### Is it safe to turn on SkipNetworkAccessibilityTest?

Only after someone outside your network has joined successfully. The test fails falsely behind NAT without loopback support, and in that case skipping it is fine. If nobody can join, skipping it changes nothing except the message.

##### Can I run two servers on one machine?

Yes, if each has its own three ports and its own user data folder via `-userdatapath`. Two servers sharing any one port - BlobSync is the easy one to forget - will break joins on whichever started second.

Sons of the Forest servers on RE:NODE start at 8 GB in Germany with three port allocations already open - no router forwards, no CGNAT and no Windows firewall dialog to get past. The live console shows the network test and every join, and `dedicatedserver.cfg` is one click away in the browser editor.

[See Sons of the Forest plans](https://www.renode.space/game-servers/sons-of-the-forest)

---

### Sons of the Forest server performance: RAM, CPU and lag

Published 2026-10-15 by RE:NODE Team. https://www.renode.space/blog/sons-of-the-forest-server-performance

A Sons of the Forest dedicated server needs about 8 GB of memory and two fast cores for a small group, 10 GB for a settled group of four to six, and 12 GB with three cores for a full server of eight on a world that has been played for weeks. It is heavy because it keeps a large, detailed world resident and simulates every cannibal, animal and structure on one main thread, and on Linux it carries the extra weight of running a Windows binary under Wine. Two keys in `dedicatedserver.cfg` decide most of its CPU use - `ActiveTargetFramerate` and `IdleTargetFramerate` - and one, `SaveInterval`, decides when it stutters. The rest of the performance story is about time: a server that has been up for three days is slower than the same server fresh, and a scheduled restart fixes more lag than any setting.

This post is about sizing and keeping the server fast. The install, ports and every config key are in the [Sons of the Forest dedicated server guide](https://www.renode.space/blog/sons-of-the-forest-dedicated-server), and the mechanics of Wine itself are in [Wine and Proton for Windows-only servers](https://www.renode.space/blog/wine-and-proton-for-windows-only-servers). Nothing here repeats them more than it has to.

#### Why the server is heavy

People arrive at this game from The Forest, whose server ran comfortably in 3 GB, and are surprised to find the sequel wants more than twice that. Four things account for the difference.

- **The world is big and loaded.** The island is far larger and denser than the first game's, and the server holds the state of everything that has changed in it: felled trees, dropped items, killed enemies, opened containers, every log and stick of every structure. That state grows as the group explores and builds, and it does not shrink while the server runs.
- **AI runs on the server.** Cannibal groups, mutants, animals and companions are simulated by the server, not by the players' machines. More active players in more places means more AI awake at once, and the AI is the expensive part of every tick.
- **Building is physics.** Sons of the Forest's free-form building places individual logs and planks rather than prefabricated pieces, and the structural checks that decide whether something holds up are real work. A large base is thousands of objects, each one held in memory and synced to every client that joins.
- **It is a Unity game built for a client.** The dedicated server is the game with the renderer removed, not a purpose-built lean server. A lot of what a client keeps around stays in the server's memory too.

None of this is a defect. It is simply the cost of the game it is, and it means the low-memory tiers that suit Terraria or Valheim are the wrong starting point. The general version of this reasoning - working out what a game actually spends memory and CPU on - is in [CPU vs RAM for game servers](https://www.renode.space/blog/cpu-vs-ram-for-game-servers).

#### RAM and CPU by player count

Endnight does not publish hardware requirements for the dedicated server, so the figures below are planning numbers from running it, not an official table. They are for the whole server process and, on Linux, include the Wine layer.

| Group and world | RAM | CPU |
| --- | --- | --- |
| 1-3 players, fresh world | 8 GB | 2 cores |
| 4-6 players, one established base | 10 GB | 2-2.5 cores |
| 7-8 players, mature world | 12 GB | 3 cores |
| Creative or heavy-building world | 12 GB+ | 3 cores |

Some context for reading that table:

- **Memory is driven by the world more than by the head count.** Two players with an enormous base can use more than six players on a young world. Player count matters because more people spread out across the island wake more of it up at once, and each player who joins pulls more of the world into active use.
- **8 GB is the floor, not the comfortable middle.** A fresh server will idle well below it, which misleads people into buying less. Watch it after a week of play, not after an hour.
- **CPU is about one thread.** The main simulation loop is single-threaded in practice, so one fast core is worth more than four slow ones. The extra cores carry saving, networking and the BlobSync transfer to joining players, which is why two is the realistic minimum even though the game "only" uses one. [Reading game server CPU usage](https://www.renode.space/blog/reading-game-server-cpu-usage-single-thread) explains why a server can be at its limit while showing 40 percent.
- **Disk speed matters at two moments**: loading the world on start and writing it on every save. The install is in the 10-15 GB range and each save slot is tens of megabytes, so capacity is rarely the issue; latency is.

The eight-player cap is in the game, so there is no "16-player tier" to plan for. If you are wondering whether a bigger plan would help a server that already has headroom, it will not - see [how many players fit on a server](https://www.renode.space/blog/how-many-players-fit-on-a-server) for the general argument.

#### The frame-rate targets: ActiveTargetFramerate and IdleTargetFramerate

A server has no screen, but it still runs a game loop, and these two keys set how many times a second that loop tries to run. They are the closest thing Sons of the Forest has to a tick-rate setting, and they are the main lever on CPU use.

dedicatedserver.cfg (excerpt):

```json
{
  "IdleDayCycleSpeed": 0.0,
  "IdleTargetFramerate": 5,
  "ActiveTargetFramerate": 60,
  "SaveInterval": 600
}
```

| Key | Default | Applies when |
| --- | --- | --- |
| `ActiveTargetFramerate` | `60` | One or more players connected |
| `IdleTargetFramerate` | `5` | Nobody connected |

Note the names. Guides and forum posts sometimes call this "TargetFps" or "TargetFramerate"; neither key exists in the file. The server reads `ActiveTargetFramerate` and `IdleTargetFramerate`, and a misspelled key in a JSON config is ignored rather than rejected, so a typo here looks exactly like a setting that does nothing.

##### What the idle target does

With nobody online the server drops to five loops a second. That is why an empty Sons of the Forest server costs almost nothing in CPU, and why a server that is running hot with nobody on is a sign of something else - a save in progress, a stuck process or, on Linux, Wine itself misbehaving. Leave `IdleTargetFramerate` at `5`. There is no gain in raising it: with `IdleDayCycleSpeed` at `0.0` the world clock is frozen while empty anyway, and there is nothing for a faster idle loop to do.

##### What the active target does

With players on, the server aims for 60 loops a second. Each loop runs AI, physics and world updates and sends state to clients. When the CPU cannot keep up, the server simply runs fewer loops than the target, and players see it as enemies that move in steps, hits that land late and doors or structures that respond after a pause.

Lowering `ActiveTargetFramerate` is a legitimate trade on a CPU-limited server. At `30`, the server does roughly half the simulation work per second, and on a plan that is pinned at its CPU limit the result is often smoother play rather than worse, because a steady 30 feels better than a 60 target that keeps collapsing to 20 during fights. The cost is coarser updates: enemy movement and physics are sampled less often, which some players notice in close combat. Endnight does not document exactly how each subsystem responds to the target, so treat it as something to test with your own group.

Some rules of thumb:

- **Do not raise it above 60.** Clients do not benefit, and the server spends CPU it rarely has to spare.
- **Lower it in steps** - 60, then 45, then 30 - and play a session at each. Change one thing at a time so you know which change helped.
- **Lowering it does not save memory.** The world is the same size at any frame rate. If memory is the problem, this key is not the fix.
- **It can be set from the command line** as `-dedicatedserver.ActiveTargetFramerate "30"`, which is how many panels expose it without editing the file.

The general idea - what a tick or frame target means for a server, and why a stable rate beats a high one - is in [what tick rate actually means](https://www.renode.space/blog/what-tick-rate-actually-means).

#### Autosave and the save hitch

Every `SaveInterval` seconds - 600 by default - the server serialises the world and writes it to the save slot. On a young world that takes a moment. On a mature world with a large base it is a noticeable hitch: a second or more where everything on the server stops, followed by a brief rubber-band as clients catch up.

That hitch is the most common "random lag" report on a Sons of the Forest server, and it has a tell: it is regular. If the stutter arrives every ten minutes, close to the same minute past the hour, it is the save. Confirm it by watching the console for the save line at the moment people complain.

What you can do about it:

- **Accept it.** A one-second pause every ten minutes is the price of not losing ten minutes of work on a crash. Most groups, told what it is, stop minding.
- **Lengthen the interval** to `900` or `1200` if the hitch really is disruptive. You halve how often it happens and double what an unclean stop can lose. That trade is worth making only alongside reliable backups and clean restarts.
- **Do not shorten it to chase safety** on a big world. `300` on a world with a five-thousand-piece base means a visible pause every five minutes.
- **Fast disk shortens the pause** but does not remove it; much of the time goes on gathering and serialising state, not on the write itself. [What NVMe actually changes](https://www.renode.space/blog/what-nvme-actually-changes) is honest about where it helps.

The broader trade-offs of save timers, for this game and others, are in [game server autosave intervals](https://www.renode.space/blog/game-server-autosave-intervals).

> [!WARNING]
> A save that is killed half-way is worse than a missed save. If the server is restarted, stopped by a memory limit or crashes while writing, the slot can be left damaged. Keep copies of the `Saves` folder outside the server, and never schedule a restart for the same minute as a likely autosave.

#### The Windows-only binary and what Wine costs

Endnight ships the dedicated server for Windows only. On Linux, which is where most game hosting runs, it is started under Wine (or occasionally Proton), usually with a virtual display such as Xvfb because the Unity runtime expects one. The setup is covered in [Wine and Proton for Windows-only servers](https://www.renode.space/blog/wine-and-proton-for-windows-only-servers); what matters for sizing is the cost.

- **Memory**: a few hundred megabytes more than the same server would use on Windows, for the Wine server process, loaded Windows libraries and the virtual display. On a 12 GB plan that is noise; on an 8 GB plan it is part of why 8 GB is the floor.
- **CPU**: small in steady play, because the game's code runs natively and only system calls are translated. It shows up more in file-heavy moments - start-up, world load and saves - which are exactly the moments that already hitch.
- **Log noise**: Wine's own diagnostic output can be chatty. Setting `WINEDEBUG=-all` in the environment silences it and saves a little CPU and disk on a busy server.
- **Version sensitivity**: a game patch occasionally needs a newer Wine. If a server that ran smoothly starts stuttering or crashing straight after an update, and Windows hosts are not reporting the same, the Wine build is the first suspect.

On Windows itself none of this applies, but a Windows server costs more memory at idle than a Linux one plus Wine, so self-hosting on a Windows box is not the saving it looks like. [Linux vs Windows game servers](https://www.renode.space/blog/linux-vs-windows-game-servers) has the wider comparison.

> [!NOTE]
> Under Wine, how the server reacts to a stop signal depends on how the host passes it through. Test once: make a visible change, stop the server the way your panel does, start it and check the change survived. If it did not, every scheduled restart is losing up to one `SaveInterval` of progress.

#### Long sessions: why the server gets slower

Sons of the Forest servers degrade with uptime. A server that runs smoothly on Monday evening can be noticeably laggier by Thursday with the same players doing the same things, and a restart brings it back. Several things contribute:

- **World state accumulates.** Dropped items, corpses, cut logs and debris add up through a session. Some are cleaned up, plenty are not, and every one is something the server tracks.
- **Memory grows.** Long-running Unity servers tend to climb in memory over days, partly from the state above and partly from the managed runtime holding on to memory it has used. Whether that counts as a leak or as normal growth depends on the build, and it changes between patches. [Game server memory leaks](https://www.renode.space/blog/game-server-memory-leaks) explains how to tell the two apart.
- **Garbage collection gets more expensive.** A bigger heap means longer collection pauses, which show up as short, irregular stutters - unlike the save hitch, which is regular.
- **AI and physics drift.** Enemy groups and simulated objects that never quite settle keep costing CPU in areas nobody is in.

The fix is unglamorous: restart the server on a schedule. Once a day at a time nobody plays is right for most groups; a very active eight-player server may want two. A restart reloads the world from the last save, discards the accumulated junk and resets memory to its baseline.

A good restart sequence:

1. Warn players, if your group plays at odd hours. There is no server-side broadcast command, so this happens in Discord.
2. Let the server stop cleanly so it saves on the way out. Do not kill it.
3. Take a backup of the save once it has stopped, or immediately before the restart.
4. Start it and confirm the world loaded from the expected slot.

On RE:NODE the Schedules tab runs that as ordered tasks on a cron expression - a backup, then a restart power action - with backups stored off the machine they protect. The reasoning behind picking the time and frequency is in [restart schedules that help](https://www.renode.space/blog/restart-schedules-that-help).

#### Reading the graphs: memory or CPU

Before you buy a larger plan or start changing settings, work out which resource is actually short. The symptoms differ.

| Symptom | Likely limit | First thing to try |
| --- | --- | --- |
| Lag in fights, server CPU flat at the cap | CPU | Lower `ActiveTargetFramerate` |
| Stutter every ten minutes | Save | Expect it, or lengthen `SaveInterval` |
| Short random stutters, worse with uptime | Memory and GC | Daily restart |
| Server restarts on its own, world rolls back | Memory limit | More RAM, restart schedule |
| Fine for days, then slow | Accumulated state | Restart schedule |

A memory graph that climbs steadily over days and drops at each restart is normal. One that climbs to the limit within hours of a restart means the world has outgrown the plan. A CPU graph pinned at its limit only during play is a server that needs a faster or bigger share, or a lower frame target; one that is high with nobody online is a problem with the process, not the sizing.

On RE:NODE the console shows memory, CPU and disk graphs against the plan's limits, which is the comparison you want. CPU is a hard throttle to the share you bought: a server at 100 percent runs slower, and is never suspended for it. Memory works differently - at the limit the container is stopped and restarted clean rather than left to swap - which on this game means losing whatever happened since the last save. If that is happening, it is the strongest signal there is to move up a tier, and changing plan does not rebuild the server or touch the world. [Reading a server load graph](https://www.renode.space/blog/reading-a-server-load-graph) goes through the shapes in more detail, and [when to upgrade your plan](https://www.renode.space/blog/when-to-upgrade-your-plan) covers the decision itself.

#### Troubleshooting slow servers

**The server is laggy but the CPU graph is nowhere near the limit.** Look at a single core rather than the total. The main loop can be saturating one thread while the overall percentage looks relaxed. If it is, lowering `ActiveTargetFramerate` helps more than adding cores.

**Everyone rubber-bands at the same moment, every ten minutes.** That is the autosave on a big world. Check the console for the save line at the moment it happens.

**One player lags and nobody else does.** That is their connection or their machine, not the server. A server problem affects everyone in the same place at the same time. [Latency, jitter and packet loss](https://www.renode.space/blog/latency-jitter-and-packet-loss) helps them work out which.

**Joining takes several minutes and the server stutters while someone joins.** The joining player is pulling the world state over the BlobSync port. On a mature world that is a large transfer and costs the server work while it happens. It is normal, and it is worse the bigger the base.

**Memory hits the limit and the server restarts with a rollback.** The world needs more memory than the plan has, or the server has been up too long. Add a daily restart first; if it still reaches the limit within a day, move up a tier. [Why your game server keeps restarting](https://www.renode.space/blog/why-your-game-server-keeps-restarting) covers the other causes of unplanned restarts.

**Changing the frame target made no difference.** Check the spelling of the key and that the file is valid JSON. A mistyped key is silently ignored, and a broken file makes the server start with defaults. Run with `-verboseLogging` to see what was read.

**The server got slower straight after a game update.** Either the update itself is heavier, which happens and is not something you can configure away, or on Linux the Wine build has fallen behind. Compare notes with other server owners before changing anything on your side.

#### FAQ

##### Is 8 GB enough for a Sons of the Forest server?

For two to four players on a world that is not enormous, yes. It is the floor rather than a comfortable margin, and a long-lived world with a large base will outgrow it. Watch memory after a week of play, not on the first evening.

##### Does lowering ActiveTargetFramerate hurt gameplay?

A little, in exchange for stability. At `30` enemy movement and physics update less often, which some players notice in close combat. On a server that cannot hold 60 anyway, a steady 30 usually feels better than an unstable 60. Try it for a session before deciding.

##### Why is my empty server using almost no CPU?

Because of `IdleTargetFramerate`. With nobody connected the server runs at five loops a second and, with `IdleDayCycleSpeed` at zero, the world clock is frozen. That is intended, and there is no reason to change it.

##### Does running under Wine make the server slower?

Only slightly. The game's code runs natively; Wine adds a few hundred megabytes of memory and some overhead on file-heavy work such as saves. Lag on a Wine-hosted server is almost always the game's own load, not the translation layer.

##### How often should I restart a Sons of the Forest server?

Once a day at a quiet hour suits most groups. A busy eight-player server may benefit from twice a day. Always let it stop cleanly so it saves, and take a backup alongside the restart.

##### Will more CPU cores make the server faster?

Beyond two or three, rarely. The simulation leans on one main thread, so the speed of that core matters more than the number of them. Extra cores help with saving and with players joining, not with the main loop.

Sons of the Forest plans on RE:NODE start at 8 GB and two vCPU and go up to 12 GB and three, on NVMe in Germany, with the Windows server already running for you under the hood. Memory and CPU graphs sit in the console against your limits, and the Schedules tab will run a nightly backup and restart.

[See Sons of the Forest plans](https://www.renode.space/game-servers/sons-of-the-forest)

---

### Sons of the Forest settings and saves

Published 2026-10-07 by RE:NODE Team. https://www.renode.space/blog/sons-of-the-forest-server-settings-and-saves

A Sons of the Forest dedicated server has two kinds of settings, and mixing them up is the source of most confusion. Server settings in `dedicatedserver.cfg` - name, password, save interval, idle behaviour - apply every time the server starts. Game rules - `GameMode` and everything in `CustomGameModeSettings` - are read only when a save is created, then stored inside the save itself in `GameSetupSaveData.json`. So changing difficulty on an existing world means either starting a new slot or carefully editing that file, and moving a world between machines means copying a whole numbered slot folder, because the rules travel with it. This guide covers choosing rules for your group, what lives in a save folder, changing an existing world, and moving saves onto the server, off it and between slots.

The install, every `dedicatedserver.cfg` key, the ports and the owner list are in the [Sons of the Forest dedicated server guide](https://www.renode.space/blog/sons-of-the-forest-dedicated-server). This post builds on it.

#### Which settings apply when

| Setting | Lives in | Takes effect |
| --- | --- | --- |
| `ServerName`, `Password`, `MaxPlayers`, ports | `dedicatedserver.cfg` | Every start |
| `SaveSlot`, `SaveMode` | `dedicatedserver.cfg` | Every start |
| `SaveInterval`, `IdleDayCycleSpeed`, frame targets | `dedicatedserver.cfg` | Every start |
| `GameSettings` (tree regrowth, structure damage) | `dedicatedserver.cfg` | Every start |
| `GameMode` | `dedicatedserver.cfg`, then copied into the save | Only when a new save is created |
| `CustomGameModeSettings` | `dedicatedserver.cfg`, then copied into the save | Only when a new save is created |
| Owners | `ownerswhitelist.txt` | Every start |

The practical reading: you can change the server name or the save interval whenever you like with a restart. You can switch tree regrowth or structure damage on an existing world with a restart. You cannot change enemy aggression, season length or the survival penalties of an existing world from the config, and the server will not warn you that it ignored you.

Two more behaviours worth knowing before you choose:

- **Every key in `dedicatedserver.cfg` can be overridden on the command line** with a `-dedicatedserver.` prefix, such as `-dedicatedserver.SaveSlot "2"`. A panel's Startup tab often sets values this way, and a command-line value beats the file. If a change to the file appears to do nothing, check the start command.
- **The file is strict JSON.** No comments, no trailing comma after the last key, straight quotes only. A malformed file stops the start with a configuration error rather than falling back quietly.

#### Settings recipes for real groups

The presets - `Peaceful`, `Normal`, `Hard`, `HardSurvival`, `Creative` - cover a lot of groups. `Custom` is for when none of them fits. These are starting points, written as the fragment of `dedicatedserver.cfg` that matters. Copy the capitalisation of values from your own generated file if it differs; the documentation and the generated file have not always agreed.

##### A part-time group that mostly builds

Cannibals still visit, but nobody starves while they are at work and the base is safe from the worst raids.

```json
"GameMode": "Custom",
"IdleDayCycleSpeed": 0.0,
"SaveInterval": 300,
"GameSettings": {
  "Gameplay.TreeRegrowth": true,
  "Structure.Damage": false
},
"CustomGameModeSettings": {
  "GameSetting.Vail.EnemyAggression": "low",
  "GameSetting.Survival.PlayerStatsDamage": "off",
  "GameSetting.Survival.ColdPenalties": "off",
  "GameSetting.Environment.SeasonLength": "long",
  "GameSetting.Environment.DayLength": "long"
}
```

`IdleDayCycleSpeed` at `0.0` stops the clock when nobody is online, which matters more than any difficulty slider for a group that plays twice a week. Tree regrowth keeps the area around a long-lived base from turning into stumps.

##### A standard co-op story run

`"GameMode": "Normal"` with the default `GameSettings` is the game as designed, and the right choice for a group playing through the story together. The one change worth making is `SaveInterval`: the default 600 seconds means a crash can cost ten minutes, and a story run has more set pieces where that hurts.

##### A hard survival server

`"GameMode": "HardSurvival"` is the preset for groups who want the full grind. If you want it slightly less punishing, use `Custom` with `"GameSetting.Survival.ConsumableEffects": "hard"`, `"GameSetting.Survival.PlayerStatsDamage": "hard"`, `"GameSetting.Vail.EnemyHealth": "high"` and `"GameSetting.Survival.ReducedFoodInContainers": true`, leaving cold penalties at `normal`. Hard settings with long seasons make winter a real event rather than a short inconvenience.

##### A building server

`"GameMode": "Creative"` removes resource costs, or `Custom` with `"GameSetting.Survival.CreativeMode": true` and `"GameSetting.Vail.EnemySpawn": false` if you want to keep some other custom choices. Creative worlds with large builds are the heaviest thing you can ask this server to do, so expect memory to climb with structure count.

Whatever you pick, write it down with the date the world was created. In six months nobody will remember whether this world was made with low aggression, and the config file may no longer say.

#### What is inside a save slot

On the server, each world is a folder under the user data directory:

```text
Saves/DedicatedServer/Multiplayer/0000000001/
```

The folder name is the slot number padded to ten digits, and `SaveSlot` picks which one loads. Inside are a set of JSON files and a thumbnail. File names vary a little between builds, but on current builds you will find these:

| File | What it holds |
| --- | --- |
| `GameSetupSaveData.json` | The rules the world was created with: mode and custom settings |
| `GameStateSaveData.json` | Overall game state, including the game type and story progress |
| `SaveData.json` | The bulk of the world: items, structures, NPC state, Kelvin and Virginia |
| `PlayerInventorySaveData.json` | Inventory data |
| `PlayerStateSaveData.json` | Player position and stats |
| `WeatherSystemSaveData.json` | Weather and season state |
| `WorldItemManagerSaveData.json` | Items placed or dropped in the world |

The slot is one unit. Do not copy individual files between worlds - they reference each other, and a world assembled from two saves is a world that crashes on load. Copy, back up and restore whole folders.

Some player-specific data lives on each player's own machine rather than on the server, in a `MultiplayerClient` folder under their local saves. That is why inventories and positions sometimes behave unexpectedly after a world moves: the world came across, but each player's side of it did not.

#### Changing the rules of an existing world

There is no supported way to change `GameMode` or custom settings on an existing world. There is an unsupported one that the community uses widely: editing the save's JSON directly. It works because the rules are stored as plain text in the slot.

1. Stop the server and wait for the final save line in the console.
2. Take a backup of the whole slot folder. Not optional.
3. Open `GameSetupSaveData.json` in an editor that will not reformat it. Find the game mode value - for example `"StringValue":"Normal"` - and the individual settings, each stored as an entry with the setting name and its value.
4. If you changed the mode, change the matching `"GameType"` value in `GameStateSaveData.json` as well, so the two files agree.
5. Start the server and read the log. Join and check that the change took.

Community save editors such as SOTFEdit wrap the same edits in an interface, which is less error-prone than editing by hand for most changes. Either way, three warnings apply. The format is internal and Endnight can change it in any patch. Some changes do not make sense mid-game - switching to Peaceful will not remove the cannibals already placed in the world state. And a broken edit makes the slot unloadable, which is why step 2 exists.

> [!WARNING]
> The save files are minified JSON with long lines. Editors that "pretty print" on open, or that save with a byte order mark or Windows line endings changed, can produce a file the game refuses. Use an editor that leaves everything else untouched, and diff the file against your backup before you start the server.

#### Moving worlds onto, off and between slots

##### From your own hosted game to the server

A multiplayer world you hosted from the game client lives on your PC under:

```text
%USERPROFILE%\AppData\LocalLow\Endnight\SonsOfTheForest\Saves\<SteamID64>\Multiplayer\<world id>\
```

Stop the server, upload that folder into `Saves/DedicatedServer/Multiplayer/`, rename it to a free padded slot number such as `0000000002`, set `SaveSlot` to `2` and `SaveMode` to `Continue`, and start. Structures, story progress and the world come across. Tell your group to expect to arrive with less than they left with, for the reason above.

##### Single-player worlds

Single-player saves live in a `SinglePlayer` folder beside `Multiplayer`. Moving one onto a dedicated server is not a documented path. People do report success copying a single-player slot into the server's multiplayer folder in the same way, with mixed results depending on the build. If you try it, try it in a spare slot, with the original kept safe, and play for an hour before deciding the world is sound.

##### From the server back to a PC

To play a server world offline, or to hand it to someone else to host, reverse the process. Stop the server so the slot is saved, download the slot folder, and place it under your own `Saves\<SteamID64>\Multiplayer\` with a numeric folder name. It appears in the game's load list for hosted multiplayer. This is also the cleanest way to end a server without losing the world: download the last slot before the server goes away, because deleting a server on most hosts deletes its saves and backups with it.

##### Between slots on the same server

Slots make cheap experiments. Copy the current slot to the next free number, point `SaveSlot` at the copy, and try a mod, an edit or a risky boss fight. If it goes wrong, set `SaveSlot` back. The original never changed.

```diagram
title: Where a Sons of the Forest world can move
hosted = Hosted game | your PC, Multiplayer
server = Server slot | 0000000001
spare = Spare slot | 0000000002
backup = Backup copy | off the machine
offline = Offline play | another PC
hosted -> server : upload and rename
server -> spare : copy to experiment
server -> backup : scheduled
backup -> server : restore
server -> offline : download slot
```

#### Save timing, backups and rollback

The world is written every `SaveInterval` seconds and on a clean stop. A killed process, a crash or an out-of-memory stop loses everything since the last save. The built-in behaviour writes over the same slot each time, so it is not a backup: a world saved in a broken state replaces the good one.

A backup plan for this game is three things:

- **A scheduled copy of the save folder**, kept off the server, nightly for an active group. More often is pointless if nobody plays at night.
- **A manual copy before anything risky** - a game update, a save edit, a mod, a story boss.
- **A restore you have actually done.** Restore a backup into a spare slot once, load it and walk around. [Backups that actually restore](https://www.renode.space/blog/backups-that-actually-restore) and [testing a restore before you need it](https://www.renode.space/blog/testing-a-restore-before-you-need-it) explain why this matters more than the schedule.

To roll back, stop the server, replace the slot folder with the backup copy - the whole folder, not individual files - and start. Players lose everything since the backup, so announce it first.

On RE:NODE, backups are taken on demand or on a schedule, stored off the machine they protect, and restored with one button; they can also be downloaded, which covers the "keep a copy at home" step. A Schedules entry can run a backup at four in the morning and a restart straight after, each as an ordered task. The Restart button sends a clean stop, so the world saves first. If the server reaches its memory limit it is stopped and restarted clean rather than swapping, which is the unsaved-stop case - one more reason to bring `SaveInterval` down to 300 on a big world. Deleting a server deletes its backups too, locked ones included, so download the last one before you cancel.

#### Wipes and starting fresh

There are two ways to start a new world, and one of them destroys the old one.

`SaveMode` set to `New` regenerates the current slot on every start. It is the dangerous one: forget to set it back to `Continue` and the next restart wipes the world again.

The safer way is a new slot. Set `SaveSlot` to an unused number with `SaveMode` `New`, start once to generate the world, then immediately set `SaveMode` back to `Continue`. The old world is untouched in its own folder and you can return to it by changing one number. This is also the only clean way to apply new game rules, since they are read when a world is created. [Game server save files explained](https://www.renode.space/blog/game-server-save-files-explained) has the general picture across games.

#### Troubleshooting

**Custom settings changed in the config have no effect.** They only apply to a new save. Start a new slot or edit `GameSetupSaveData.json` on a backed-up copy.

**The world reset after a restart.** `SaveMode` is `New`, `SaveSlot` changed, or a command-line override set either. The old slot is still on disk.

**An uploaded world does not load and a new one generates.** The folder name is not the padded slot number matching `SaveSlot`, or the files sit one folder too deep inside it. The slot folder must contain the JSON files directly.

**The server refuses to start after a save edit.** The JSON is malformed. Restore the backup and redo the edit in an editor that leaves formatting alone.

**Players lost their inventories after a transfer.** Expected to some degree: part of each player's data lives on their own machine. Plan a supply chest for the first session on a moved world.

**The save takes long enough that players notice.** A large world with many structures. Keep `SaveInterval` at a value the group tolerates, and restart daily so memory stays flat - [restart schedules that help](https://www.renode.space/blog/restart-schedules-that-help).

#### FAQ

##### Can I change the difficulty of an existing Sons of the Forest server world?

Not from `dedicatedserver.cfg`, which only applies rules when a save is created. You can edit `GameSetupSaveData.json` and `GameStateSaveData.json` in the slot with the server stopped and a backup taken, or start a new slot with the rules you want.

##### Which settings can I change without starting a new world?

Everything outside `GameMode` and `CustomGameModeSettings`: name, password, player count, save interval, idle clock speed and the two `GameSettings` switches for tree regrowth and structure damage. A restart applies them.

##### How do I download my world from the server?

Stop the server so the slot saves, then download the numbered slot folder from `Saves/DedicatedServer/Multiplayer/`. Place it under your own `Saves\<SteamID64>\Multiplayer\` to host or play it from the game.

##### Can I run two worlds on one server?

One at a time. Each slot is its own world, and `SaveSlot` selects which loads. Switching is a stop, a change of one number and a start, and neither world is affected.

##### Why does my config file get ignored?

Either the JSON is malformed and the server reports a configuration error, or a `-dedicatedserver.` command-line argument is overriding the value. Command-line values win over the file.

##### Does the server keep its own backups?

It keeps the current save only, overwritten on every interval. Backups are something you take, by copying the slot folder elsewhere or using your host's backup feature.

Sons of the Forest servers on RE:NODE start at 8 GB with all three UDP ports allocated, `dedicatedserver.cfg` in the browser editor, and save slots reachable in the file manager or over SFTP. Backups on every tier are stored off the machine, downloadable, and restored with one button.

[See Sons of the Forest plans](https://www.renode.space/game-servers/sons-of-the-forest)

---

### Sons of the Forest dedicated server setup

Published 2026-09-21 by RE:NODE Team. https://www.renode.space/blog/sons-of-the-forest-dedicated-server

The Sons of the Forest dedicated server is a free SteamCMD download (app id `2465200`), it holds eight players, it wants 8 GB of memory and two cores to be comfortable, and it is configured entirely by one JSON file called `dedicatedserver.cfg`. There are two things worth knowing before you start. The server tool is a Windows build - there is no native Linux binary, so on Linux it runs under Wine or Proton, which is what most hosts are quietly doing for you. And because the configuration is JSON rather than the forgiving key-value format the first game used, a single stray comma makes the server boot with defaults and put the parse error somewhere in a log nobody reads. Everything else here is detail, and most of it lives in that one file.

#### What the dedicated server is and what it can do

Sons of the Forest supports three kinds of multiplayer: a host playing from their own copy of the game, an invite-only session, and a dedicated server. The dedicated server is a separate free application with no renderer, distributed through Steam as a tool rather than as part of the game, and it is the only one of the three where the world exists when nobody is playing.

What it gives you:

- **A persistent world.** The save is written on a timer and on a clean shutdown. Structures, cut trees, dead cannibals and the state of the story all survive a restart.
- **Up to eight players.** That is the game's cap, not a plan limit, and there is no supported way to raise it.
- **Game modes** - Normal, Hard, Hard Survival, Peaceful, Creative and Custom, chosen in the config.
- **Custom rules.** In Custom mode you get roughly two dozen individual switches for enemy health, damage, aggression, season length, day length, survival penalties and container loot.
- **Owner accounts**, which get the in-game admin panel with kick, ban and teleport.
- **A password**, which is the only access control short of running LAN-only.

What it does not have is as important. There is no RCON, no server console you can type commands into, no chat command set, no whitelist beyond the password, and no mod support of any kind that the developer acknowledges. Administration happens in the game, from a player marked as an owner. If that sounds thin compared with [The Forest's dedicated server](https://www.renode.space/blog/the-forest-dedicated-server), it is - the newer game shipped with less server tooling than the older one, and it has not caught up.

#### Requirements and resource usage

This is a heavy server for a co-op survival game, and the number that surprises people is memory. Sons of the Forest keeps a large amount of world state resident, and it grows with the area the group has explored and with everything they have built.

| Group | RAM | CPU | Notes |
| --- | --- | --- | --- |
| 2-4 players, early game | 8 GB | 2 cores | The floor, not a comfortable margin |
| 4-6 players, established base | 10 GB | 2-2.5 cores | The common case |
| 8 players, long-running world | 12 GB | 3 cores | Builds and explored area both cost |
| Creative mode, heavy building | 12 GB+ | 3 cores | Structure count is the driver |

Those numbers are for the whole container, and on Linux that includes the Wine layer and the virtual display the server insists on having. The reference Linux deployments ask for 8 GB as a minimum for a group of four and recommend more, which is why the plans for this game start where they do rather than at the 2 or 3 GB a co-op survival server used to mean.

- **CPU**: the simulation is dominated by one thread, as it is in nearly every Unity survival game. Clock speed decides whether a fight at the base stutters. A second and third core still help - saving, networking and the blob sync all happen alongside.
- **Disk**: the install is roughly 10-15 GB and each save slot is a `SaveData.zip` in the tens of megabytes, growing with the world. 50 GB is a sensible floor once you keep a few slots and some copies.
- **Network**: modest in normal play. The exception is a player joining, which pulls the current world state across the BlobSync port. On a mature world that is a real transfer and the reason a first join takes a while.

The honest version of the sizing question: if your plan has 8 GB, you have enough for a normal group and you should not expect to also be comfortable in Creative mode with a thousand structures. [CPU vs RAM for game servers](https://www.renode.space/blog/cpu-vs-ram-for-game-servers) covers how to tell which of the two you are actually short of before you pay for the wrong one.

#### Installing and the first start

The dedicated server is anonymous on SteamCMD, so you do not need a Steam account or a game server token:

```bash
$ steamcmd +force_install_dir C:\sotf-server +login anonymous \
    +app_update 2465200 validate +quit
```

If SteamCMD is new to you, [SteamCMD explained](https://www.renode.space/blog/steamcmd-explained) covers app ids, `validate` and keeping the install current. The executable is `SonsOfTheForestDS.exe`, with `StartSOTFDedicated.bat` beside it as the shipped launcher - worth knowing that the batch file is replaced on every update, so edits to it do not survive.

Run it once. The first start creates the user data folder, writes a default `dedicatedserver.cfg` and an empty `ownerswhitelist.txt`, tells you it has done so, and stops. That is expected behaviour rather than a failure: the server will not run until both files exist and you have had a chance to edit them.

On Windows that folder is:

```text
C:\Users\<user>\AppData\LocalLow\Endnight\SonsOfTheForestDS\
```

It holds `dedicatedserver.cfg`, `ownerswhitelist.txt` and a `Saves` directory. You can move the whole thing with a command-line argument, which is what you want if you run more than one server on a machine:

```text
SonsOfTheForestDS.exe -userdatapath "C:/sotf-server/userdata"
```

Two other arguments are worth knowing. `-verboseLogging` turns on the detailed log, which is the difference between diagnosing a start-up failure in two minutes and guessing. And every config key can be overridden on the command line with a `-dedicatedserver.` prefix, which is how panels set values without rewriting your file:

```text
SonsOfTheForestDS.exe -dedicatedserver.ServerName "Kelvin's Revenge" -dedicatedserver.MaxPlayers "6"
```

On a panel-based host you skip all of this. The server exists after payment clears, the config file is already there, and the same values appear as fields on the Startup tab. What you still do yourself is the editing described below - on RE:NODE that is the in-browser file editor, which will colour the JSON and make an unbalanced brace obvious, or SFTP if you would rather work locally.

#### dedicatedserver.cfg, key by key

One JSON object, no sections, no comments allowed. The defaults the server writes on first start:

dedicatedserver.cfg:

```json
{
  "IpAddress": "0.0.0.0",
  "GamePort": 8766,
  "QueryPort": 27016,
  "BlobSyncPort": 9700,
  "ServerName": "Sons Of The Forest Server (dedicated)",
  "MaxPlayers": 8,
  "Password": "",
  "LanOnly": false,
  "SaveSlot": 1,
  "SaveMode": "Continue",
  "GameMode": "Normal",
  "SaveInterval": 600,
  "IdleDayCycleSpeed": 0.0,
  "IdleTargetFramerate": 5,
  "ActiveTargetFramerate": 60,
  "LogFilesEnabled": false,
  "TimestampLogFilenames": true,
  "TimestampLogEntries": true,
  "SkipNetworkAccessibilityTest": false,
  "GameSettings": {},
  "CustomGameModeSettings": {}
}
```

What each of the interesting ones does:

| Key | Default | What it does |
| --- | --- | --- |
| `ServerName` | Sons Of The Forest Server | The name in the browser |
| `MaxPlayers` | `8` | Documented range is 1 to 8 |
| `Password` | empty | Empty means anyone can join. Maximum 40 characters |
| `LanOnly` | `false` | `true` hides the server from the internet entirely |
| `SaveSlot` | `1` | Which save folder to load and write |
| `SaveMode` | `Continue` | `Continue` loads the slot, `New` starts over in it |
| `GameMode` | `Normal` | See the next section |
| `SaveInterval` | `600` | Seconds between world saves |
| `IdleDayCycleSpeed` | `0.0` | How fast time passes with nobody online |
| `IdleTargetFramerate` | `5` | Tick target when empty |
| `ActiveTargetFramerate` | `60` | Tick target with players on |
| `LogFilesEnabled` | `false` | Write logs to disk as well as the console |
| `SkipNetworkAccessibilityTest` | `false` | Skip the start-up port check |

> [!WARNING]
> `SaveMode` set to `New` does what it says every single time the server starts. Leave it on `New` after a first run and the next restart wipes the slot and generates a fresh world. Set it to `Continue` as soon as the world exists, and take a copy of the save before you ever touch it again.

`IdleDayCycleSpeed` at `0.0` freezes the clock while the server is empty, which is almost always what a group of friends wants - nobody comes back to find the winter has passed. Set it to `1.0` if you want time to keep moving. `IdleTargetFramerate` at `5` is the reason an empty server barely uses CPU, and it is worth leaving alone.

`SkipNetworkAccessibilityTest` deserves a note. On start the server tests whether its ports are reachable from outside and complains if they are not. On a host that sits behind a NAT or a filtering layer, that test can fail on a server that works perfectly. If everything else is correct and the test is the only thing failing, setting it to `true` is legitimate. Setting it to `true` because you have not opened your ports is not.

#### Game modes and custom game settings

`GameMode` takes one of `Normal`, `Hard`, `HardSurvival`, `Peaceful`, `Creative` or `Custom`. The first five are presets. `Custom` is the one that reads `CustomGameModeSettings`.

> [!WARNING]
> `GameMode` and everything in `CustomGameModeSettings` are read **when a save is created**, not when it is loaded. Change them on a world that already exists and the server will start, report no error, and carry on with the rules it was made with. If you want different rules on an existing world you are starting a new one.

Two switches live in the always-on `GameSettings` block and apply whatever mode you run:

```json
"GameSettings": {
  "Gameplay.TreeRegrowth": true,
  "Structure.Damage": true
}
```

`Gameplay.TreeRegrowth` grows felled trees back over time, which matters a great deal on a long-lived server where a base area otherwise becomes a stump field. `Structure.Damage` controls whether cannibals can break what you built - switch it off and base defence stops being a thing you have to think about, which some groups want and others consider the whole game.

With `GameMode` set to `Custom`, the rest becomes available. These are the keys, all prefixed `GameSetting.`:

| Key | Values |
| --- | --- |
| `GameSetting.Vail.EnemySpawn` | `true`, `false` |
| `GameSetting.Vail.EnemyHealth` | `low`, `normal`, `high` |
| `GameSetting.Vail.EnemyDamage` | `low`, `normal`, `high` |
| `GameSetting.Vail.EnemyArmour` | `low`, `normal`, `high` |
| `GameSetting.Vail.EnemyAggression` | `low`, `normal`, `high` |
| `GameSetting.Vail.EnemySearchParties` | `low`, `normal`, `high` |
| `GameSetting.Vail.AnimalSpawnRate` | `low`, `normal`, `high` |
| `GameSetting.Environment.StartingSeason` | `spring`, `summer`, `autumn`, `winter` |
| `GameSetting.Environment.SeasonLength` | `short`, `default`, `long`, `realistic` |
| `GameSetting.Environment.DayLength` | `short`, `default`, `long`, `realistic` |
| `GameSetting.Environment.PrecipitationFrequency` | `low`, `default`, `high` |
| `GameSetting.Survival.ConsumableEffects` | `normal`, `hard` |
| `GameSetting.Survival.PlayerStatsDamage` | `off`, `normal`, `hard` |
| `GameSetting.Survival.ColdPenalties` | `off`, `normal`, `hard` |
| `GameSetting.Survival.StatRegenerationPenalty` | `off`, `normal`, `hard` |
| `GameSetting.Survival.ReducedFoodInContainers` | `true`, `false` |
| `GameSetting.Survival.SingleUseContainers` | `true`, `false` |
| `GameSetting.Survival.BuildingResistance` | `low`, `normal`, `high` |
| `GameSetting.Survival.CreativeMode` | `true`, `false` |
| `GameSetting.Survival.PlayersImmortalMode` | `true`, `false` |
| `GameSetting.Survival.OneHitToCutTree` | `true`, `false` |
| `GameSetting.Construction.NoCuttingsSpawn` | `true`, `false` |
| `GameSetting.FreeForm.ForcePlaceFullLoad` | `true`, `false` |
| `GameSetting.Multiplayer.Cheats` | `true`, `false` |

A worked example - a building-focused server where the cannibals still turn up but the survival grind is off:

```json
"GameMode": "Custom",
"CustomGameModeSettings": {
  "GameSetting.Vail.EnemySpawn": true,
  "GameSetting.Vail.EnemyAggression": "low",
  "GameSetting.Survival.PlayerStatsDamage": "off",
  "GameSetting.Survival.ColdPenalties": "off",
  "GameSetting.Environment.SeasonLength": "long",
  "GameSetting.Survival.OneHitToCutTree": true
}
```

Two things about that list are worth knowing before you copy from it. Endnight's documentation writes the values in lower case while the file the server generates uses capitalised forms such as `"Normal"`; copy the form out of your own generated file and you will not have to find out which the parser prefers. And the official table and the official example disagree on whether the last-but-one key is `OneHitToCutTree` or `OneHitToCutTrees`, which is a good illustration of why `-verboseLogging` earns its place - the log tells you which keys the server actually accepted.

#### Ports and connecting

Three ports, all UDP, all needed:

| Port | Protocol | Purpose |
| --- | --- | --- |
| `8766` | UDP | Game traffic |
| `27016` | UDP | Steam query - the server browser |
| `9700` | UDP | BlobSync - world state to joining players |

```diagram
title: The three ports a Sons of the Forest client uses
player = Player | Steam client
query = Query port | UDP 27016
blob = BlobSync port | UDP 9700
game = Game port | UDP 8766
server = Server | up to 8 players
save = SaveData.zip | per SaveInterval
player -> query : find and ping
player -> blob : world state on join
player -> game : play
query -> server
blob -> server
game -> server
server -> save : on a timer
```

The BlobSync port is the one people miss, because it has no equivalent in most games and the two Steam ports look like the complete set. A server with `8766` and `27016` open but not `9700` behaves in a very specific and confusing way: it appears in the browser, it accepts the connection, and then the player hangs on the loading screen forever. If that is what you are seeing, it is port `9700`. [Game server ports explained](https://www.renode.space/blog/game-server-ports-explained) goes through why games end up with separate game, query and transfer ports.

Players find the server through Multiplayer, then Dedicated Servers, where the list can be filtered by name. Joining by address is done from the same screen. If you have put a name on the address, the list still shows the IP - a domain helps people remember it rather than helping them find it, and [connecting a domain to a game server](https://www.renode.space/blog/connecting-a-domain-to-a-game-server) has the A record you need.

#### Owners, admins and moderation

There is no admin command set. Instead, `ownerswhitelist.txt` in the user data folder lists the Steam IDs that get the in-game admin panel, one per line:

ownerswhitelist.txt:

```text
# One SteamID64 per line. Lines starting with # are comments.
# Jane
76561198012345678
76561198087654321
```

It has to be the 17-digit SteamID64. A vanity URL, a friend code or a Steam ID3 will be ignored without complaint. The file is generated on the first run and read at start-up, so add the IDs and restart - editing it on a running server does nothing. Note that the server refuses to start until the file exists, which is one of the two reasons a very first run stops immediately.

An owner in game opens the pause menu, goes to the player list, and from there can promote a player to administrator, demote one to guest, and kick, ban or unban guests. That is the whole toolkit. There is no admin password, no scheduled messages, no chat filter and no record of who did what. For a public server that is genuinely thin, and the practical answer is to run with a password and hand it out rather than to run open and try to police it.

#### Saves, save slots and backups

The world lives under the user data folder:

```text
Saves/DedicatedServer/Multiplayer/0000000001/
```

Each slot is its own world, and the folder name is the slot number padded to ten digits - slot 1 is `0000000001`. `SaveSlot` in the config picks which one the server loads, so keeping a second world is a matter of stopping the server, changing the number and starting again.

That padding is also the trick to moving a world onto the server. A session you hosted yourself from the game client lives under `AppData\LocalLow\Endnight\SonsOfTheForest\Saves\<SteamID64>\Multiplayer\`, in a folder named with a numeric world id. Stop the server, copy that whole folder into `Saves/DedicatedServer/Multiplayer/`, rename it to the padded slot number, set `SaveSlot` to match and `SaveMode` to `Continue`, and start. The world comes across; player inventories and positions generally do not, so tell people to expect to wake up empty-handed. A session you joined rather than hosted lives under `MultiplayerClient` and is not the full world - that one is not portable.

What you need to know about when it is written:

- **On the timer.** Every `SaveInterval` seconds, 600 by default. Ten minutes of progress is the default exposure.
- **On a clean stop.** Stopping the server normally saves first. Watch for the save line in the console before you assume it did.
- **Not on a kill.** A killed process, an out-of-memory stop or a host crash loses everything since the last timer save.

Shortening `SaveInterval` to `300` costs a brief hitch every five minutes and halves what a crash can take. On a big world the hitch is noticeable, so that is a trade rather than a free win. The built-in behaviour is not a backup either way: it overwrites the same slot, so a world that saves in a broken state saves over the good one.

Real backups are copies of the `Saves` folder kept somewhere else, on a schedule, tested occasionally. [Backups that actually restore](https://www.renode.space/blog/backups-that-actually-restore) is about the testing half, which is the half people skip. On RE:NODE the plans include backup slots, backups are stored off the machine they protect, restoring is one button, and the Schedules tab will take a nightly copy on a cron expression. Worth pairing with the memory behaviour: if the server hits its limit the container is stopped and restarted clean rather than left to swap, and a clean restart of a Sons of the Forest server still costs you whatever happened since the last save.

#### Updates, performance and troubleshooting

Client and server must be on the same build. After a game patch, run `app_update` before anyone tries to join, because the error a mismatched client gets is not helpful. Save compatibility across patches has generally held, but a major update is exactly the moment to take a manual backup first.

**The server does not appear in the list.** Check all three UDP ports, check `LanOnly` is `false`, then wait - the list is slow to refresh. Joining directly by address is the test that separates a browser problem from a server problem.

**Players connect and then hang on loading.** Port `9700` is closed. This is the single most common failure and it looks nothing like a port problem.

**The server refuses to start and names the config.** The JSON did not parse. `The configuration couldn't be read without error` means malformed JSON - a trailing comma after the last key, or a smart quote pasted in from a web page. A message naming a single setting means a value out of range. Run the file through any JSON validator before restarting.

**`UDP 8766 is closed` or similar, from the self-test.** On start the server probes its own public address to check each port, and that probe only succeeds if your network reflects traffic back to itself. Behind NAT without hairpin support it fails on a server that works perfectly. Confirm from outside that a player can join, then set `SkipNetworkAccessibilityTest` to `true`.

**`Failed to get public ip from Steam`.** The server needs a routable public IPv4 address. IPv6 alone is not supported.

**The world reset.** `SaveMode` is `New`, or `SaveSlot` changed. The old slot is still on disk - stop the server, set the values back, and it returns.

**Memory climbs steadily.** Normal on a world being actively explored and built. A scheduled daily restart keeps it flat, which is the argument in [restart schedules that help](https://www.renode.space/blog/restart-schedules-that-help). If it climbs to the limit in hours rather than days, the world has outgrown the plan.

**The start-up network test fails but the server works.** Set `SkipNetworkAccessibilityTest` to `true`, after you have confirmed players can actually join.

#### FAQ

##### How many players can a Sons of the Forest server hold?

Eight. The cap is in the game, so no host can sell you more, and `MaxPlayers` above eight is ignored. Setting it lower is useful if you want to keep the group small and the memory use down.

##### Does the dedicated server run on Linux?

Not natively. Endnight ships a Windows build only, so on Linux it runs under Wine or Proton. That works well enough that most hosting is done exactly that way, but it does mean the paths in any guide are Windows paths and the log is a Windows log.

##### Why does my server need 8 GB when The Forest ran in 3?

Because it is a much larger world with far more simulated detail, built on a newer engine. The first game's server is genuinely light; this one is not. Budget 8 GB for a normal group and 10 to 12 for a long-lived eight-player world.

##### Can I move an existing world onto the dedicated server?

A multiplayer world you hosted yourself, yes. Copy the numbered folder from your `Saves\<SteamID64>\Multiplayer` directory into the server's `Saves/DedicatedServer/Multiplayer`, rename it to the ten-digit slot number, and point `SaveSlot` at it. Structures and world state come over; inventories usually do not. A single-player save or a world you only joined is a different shape and will not transfer.

##### Are there admin commands or RCON?

No. There is no RCON port, no console command set and no chat commands. Administration is the in-game panel, available to the Steam IDs listed in `ownerswhitelist.txt`, and it covers kick and ban and nothing else.

##### Does Sons of the Forest support mods on a dedicated server?

There is no supported mod API, and nothing the developer documents. Community loaders exist and break with every patch, and a modded server is a server that needs every player running the same unofficial code. For a group of friends that is workable; for anything public it is not worth the maintenance.

Sons of the Forest servers on RE:NODE start at 8 GB on NVMe in Germany, with all three UDP ports allocated and `dedicatedserver.cfg` already in place - edit it in the browser with syntax highlighting, or over SFTP. Backup slots are included on every tier and restoring a save is one button.

[See Sons of the Forest plans](https://www.renode.space/game-servers/sons-of-the-forest)

## 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.
