# Terraria Server Hosting - everything RE:NODE has published

> A Terraria 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/terraria, 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/terraria.

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

## What it is

Terraria servers, world generated on first boot. Pick the size and difficulty from the Startup tab.

- Genres: Action, Adventure, Indie, RPG
- Developer: Re-Logic
- Released: 16 May, 2011
- Steam: https://store.steampowered.com/app/105600/

### What comes with every Terraria 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 Terraria 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.
- 1 port 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 Terraria plan do you need?

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

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

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

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

### General questions

### Getting started

**How quickly is my server ready?**

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

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

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

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

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

**Can I try before buying?**

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

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

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

### Running the server

**Do I get full file access?**

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

**Can I install mods and plugins?**

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

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

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

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

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

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

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

### Backups and safety

**Are backups included?**

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

**Where are backups stored?**

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

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

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

### Billing

**How do I pay?**

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

**Can I pay in Georgian lari?**

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

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

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

**Can I upgrade or downgrade later?**

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

**Do you offer refunds?**

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

### Support and the honest bits

**How do I get help?**

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

**Where are the servers?**

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

**Is there an uptime guarantee?**

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

**Who actually runs this?**

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

## Plans and prices

Read from the live catalogue at 2026-10-15 03:31 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/terraria or in the panel shop at https://panel.renode.space before quoting one.

| Plan | Price / month | Memory | CPU | NVMe disk | Databases | Backups | Ports |
|---|---|---|---|---|---|---|---|
| Starter | $3 | 512 MB | 0.5 vCPU | 5 GB | 1 | 2 | 1 |
| Standard | $5 | 1 GB | 0.8 vCPU | 10 GB | 1 | 2 | 1 |
| Advanced | $7 | 2 GB | 1 vCPU | 15 GB | 1 | 2 | 1 |
| Pro | $10 | 3 GB | 1.5 vCPU | 20 GB | 1 | 2 | 1 |
| Premium | $13 | 4 GB | 2 vCPU | 30 GB | 1 | 2 | 1 |


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

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

- [Terraria server RAM: vanilla to Calamity](https://www.renode.space/blog/how-much-ram-does-a-terraria-server-need) (2026-10-07): Terraria server memory by world size, players, TShock and tModLoader mod lists, why world generation is the real peak, and how to size a Calamity server properly.
- [Calamity modded Terraria server](https://www.renode.space/blog/terraria-calamity-modded-server) (2026-10-07): Run Calamity and other big tModLoader mods on a dedicated server: RAM by mod list, enabled.json, mod sides, configs, world generation and keeping clients in sync.
- [TShock server: groups and permissions](https://www.renode.space/blog/terraria-tshock-server-guide) (2026-10-07): Run a Terraria server on TShock: install, the setup code, accounts, the group ladder, permissions, regions, item bans, server-side characters and config.json.
- [Terraria world backup and server transfer](https://www.renode.space/blog/terraria-world-backup-and-transfer) (2026-10-07): Find your Terraria .wld files, move a world to a dedicated server and back, handle tModLoader .twld and TShock data, and keep backups you can restore.
- [Terraria server config and commands](https://www.renode.space/blog/terraria-server-config-and-commands) (2026-09-21): Every setting in a Terraria serverconfig.txt, the console commands the vanilla server has, world creation and secret seeds, journey permissions and TShock.
- [Terraria and tModLoader server setup](https://www.renode.space/blog/terraria-and-tmodloader-server) (2026-08-14): A vanilla Terraria server is tiny; tModLoader is not. Real memory numbers, every serverconfig.txt key, TCP 7777, console commands and safe worlds.

---

### Terraria server RAM: vanilla to Calamity

Published 2026-10-07 by RE:NODE Team. https://www.renode.space/blog/how-much-ram-does-a-terraria-server-need

A vanilla Terraria server needs 512 MB to 1 GB of memory for a small or medium world with up to four players, and about 1 GB for a large world with eight. TShock with a stack of plugins, or a vanilla server pushed to sixteen players, is comfortable at 2 GB. tModLoader changes the answer completely: 2 to 3 GB for a handful of quality-of-life mods, 4 GB for Calamity with its usual companions, and up to 6 GB at peak for large content packs that add their own world generation. The peak is the important word. A Terraria server reaches its highest memory use when it creates a world, not when people play in it, which is why the first modded world on an undersized plan is the one that fails.

#### What a Terraria server holds in memory

Terraria is unusual among sandbox games in one respect that decides its sizing: the server loads the entire world into memory and keeps it there. There is no chunk loading and unloading as players move. Every tile of the map, every wall, every liquid, every chest and every sign is resident from start to shutdown.

That makes the world size the first input, and it is a known number:

| World size | Dimensions (tiles) | Tiles in total |
| --- | --- | --- |
| Small | 4200 x 1200 | about 5 million |
| Medium | 6400 x 1800 | about 11.5 million |
| Large | 8400 x 2400 | about 20 million |

A large world holds four times the tiles of a small one, and the tile data is the bulk of a vanilla server's memory. That is why world size moves the vanilla figure more than players do.

The rest of vanilla memory is bounded in a way most games are not. Terraria stores active NPCs, projectiles and dropped items in fixed-size tables - 200 NPCs, 1,000 projectiles, 400 items at once - and a world can hold at most 8,000 chests. Memory for those does not grow when an invasion fills the screen; CPU does. The things that do grow are player connections and their buffers, and on tModLoader everything the mods add.

#### RAM by world, players and server type

| Server | RAM | vCPU | Notes |
| --- | --- | --- | --- |
| Vanilla, small or medium world, 1-4 players | 512 MB - 1 GB | 0.5 | Plenty |
| Vanilla, large world, 5-8 players | 1 GB | 0.75 | The common case |
| Vanilla, 8-16 players, events and invasions | 2 GB | 1-1.5 | Spikes rather than sustained load |
| TShock with a stack of plugins | 2 GB | 1-1.5 | Plugins and their database cost more than players |
| tModLoader, quality-of-life mods | 2-3 GB | 1 | Mods load into the same process |
| tModLoader, Calamity and companions | 4 GB | 1-1.5 | The usual big modded server |
| tModLoader, large content packs with worldgen | 6 GB peak | 1.5-2 | Peak is world creation |

Those figures agree with the longer [Terraria and tModLoader server guide](https://www.renode.space/blog/terraria-and-tmodloader-server), which also covers installation. Two things are worth drawing out.

**Players are cheap.** The default `maxplayers` is 8 and the setting accepts up to 255, but each extra player adds network buffers and a little state, not a slice of the world - the world is already fully loaded. What more players change is CPU during events, when the server updates every NPC and projectile on one thread.

**Modded servers are a different category.** A Calamity server for four people uses several times what a vanilla server for sixteen does, and the gap is entirely the mods.

#### The world size setting

World size is chosen once, at creation. On a dedicated server it is the `autocreate` value in `serverconfig.txt`, used when the named world does not exist yet:

serverconfig.txt:

```properties
world=/home/container/worlds/Hallowed_Acres.wld
autocreate=3
worldname=Hallowed_Acres
difficulty=1
maxplayers=8
port=7777
password=change-me
secure=1
npcstream=60
```

`autocreate=1` is small, `2` medium and `3` large. `difficulty` is `0` classic, `1` expert, `2` master and `3` journey. `npcstream` reduces how often enemies appear to skip across the screen for players; lowering it smooths movement at the cost of a little more bandwidth, and it does not change memory. [Terraria server config and commands](https://www.renode.space/blog/terraria-server-config-and-commands) goes through every key.

Large is the right choice for a group of six to eight who want room, and the memory cost over medium is a few hundred megabytes on vanilla. For a group of two or three, medium plays better and costs less. On modded servers the choice matters more, because content mods add biomes, structures and ores to every world, and their generation passes scale with world size.

#### World generation is the peak

When a Terraria server creates a world, it builds the whole thing in memory through dozens of generation passes - terrain, caves, biomes, ores, structures, dungeons, temples, chests and their loot - and only then writes the `.wld` file. During that process it holds working data on top of the world itself. On vanilla the overhead is modest. On tModLoader, every mod that adds generation passes adds its own working data, and large content mods add many.

The consequences:

1. **A plan that runs a world can fail to create it.** If the server is stopped partway through generation, look at memory before anything else.
2. **Generation takes longer than people expect.** A large modded world can take several minutes. Watch the console percentages rather than assuming it has hung.
3. **There is a cheap way round it.** Generate the world in the game client on your own PC, with exactly the same mods and versions, then upload the `.wld` file (and its `.twld` companion on tModLoader) to the server. The server then only has to run the world, never build it.

> [!TIP]
> On a tModLoader server, the `.twld` file beside each world holds the mod data for that world - modded tiles, items in chests, mod world state. Always upload, move and back up the `.wld` and `.twld` together. A `.wld` alone loads with every modded item and block missing.

#### tModLoader: what mods cost

tModLoader runs mods inside the server process on a modern .NET runtime. A dedicated server skips most graphics work, but it still loads every mod's code, registers its items, NPCs, tiles, projectiles and buffs, and holds whatever state the mod keeps. Costs differ widely by type.

- **Quality-of-life mods** - magic storage, recipe browsers, boss checklists, auto-trash - add little each. Magic Storage is the exception that grows: it holds a lot of items in one system, and a server's whole hoard ends up in it.
- **Content mods** add hundreds or thousands of new items, enemies and tiles. Calamity is the reference case; Thorium and similar packs behave the same way.
- **Companion and add-on mods** for the big content mods add their own content on top.
- **Worldgen mods** add structures and biomes, and their cost lands mostly at creation.

The practical workflow:

1. Pick the mod list and versions with the group before starting, and keep server and clients on exactly the same list.
2. Start the server once with nobody online and note idle memory after the world loads. That is your floor.
3. Generate the world or upload one generated locally.
4. Watch memory during the first boss fight with everyone online. Floor plus that spike plus a margin is your plan.

[Calamity and large mods on a server](https://www.renode.space/blog/terraria-calamity-modded-server) covers installing the big packs and keeping clients in sync.

#### TShock and plugins

TShock is a server-side framework for vanilla Terraria that adds user accounts, groups and permissions, region protection, anti-cheat checks and a large set of admin commands. It runs on the vanilla server and keeps its data in a database, SQLite by default. Clients need nothing.

Its memory cost is modest: the framework, its database connection, and whatever its plugins hold. Plugins that log every tile change, track statistics or run minigames hold more. A TShock server with a dozen plugins sits comfortably at 2 GB for most communities. It also gives you admin tools vanilla lacks - `/butcher` to clear hostile NPCs after an event goes wrong, for example - which is useful for CPU problems rather than memory ones. [The TShock server guide](https://www.renode.space/blog/terraria-tshock-server-guide) covers setup and permissions.

#### One world per server

A Terraria server process runs one world at a time. That surprises groups who want a main world plus a separate world for farming, a Hardmode test world or a boss rush, and it has a direct effect on sizing.

There are two ways to run several worlds:

1. **One server, switch worlds.** Stop the server, change `world=` in `serverconfig.txt` to the other `.wld` file, and start it again. Memory stays the same as for one world - only one is loaded - but nobody can be in both at once, and switching takes a restart.
2. **Several servers.** Run a separate server per world, each with its own port and its own memory. Every one carries the whole of its world in memory, so two large vanilla worlds need roughly twice the memory of one, and two Calamity worlds need twice the modded figure.

For most groups the first option is right. A world nobody is playing in does not need to be running, and the Terraria client lets players move their characters between worlds freely - characters are stored on each player's machine, not on the server, unless the server enforces server-side characters through TShock.

That last point matters for sizing too. Server-side characters in TShock store each player's inventory in the server's database rather than on their machine, which adds a little memory and disk per player and makes the server responsible for backing up characters as well as worlds. For an anti-cheat-minded public server it is worth it; for friends it is usually unnecessary.

On tModLoader, every world on a server shares the same enabled mod list, because mods are loaded per server process, not per world. A group that wants a vanilla world and a Calamity world needs either two servers or a change of `enabled.json` and a restart between them.

#### CPU, events and what is not a memory problem

Terraria's lag usually comes from CPU during events, not from memory. The server updates every active NPC and projectile each tick on one thread, and a Frost Moon with sixteen players present, a boss with a screen full of projectiles, or a modded boss with hundreds of them is a heavy few minutes. Memory sits flat while it happens, because those tables are fixed in size.

So when players report lag:

- **During invasions, bosses and events**, it is CPU. A higher tier helps if the CPU graph is flat at its limit; fewer simultaneous events and fewer farms with dozens of statues help in any case.
- **All the time on a modded server**, check whether memory is near the limit and the runtime is collecting constantly. That is a plan that is too small for the mod list.
- **Only for one player**, it is that player's connection.

[CPU or RAM: which one is holding your server back](https://www.renode.space/blog/cpu-vs-ram-for-game-servers) covers reading the graphs, and [how many players fit on a server](https://www.renode.space/blog/how-many-players-fit-on-a-server) covers why slot counts promise less than they seem to.

#### Saves, backups and memory stops

The server autosaves periodically and saves on a clean `exit`. The vanilla console's `save` command forces a save at any time. Anything that ends the process without a save - a host reboot, a kill, a memory stop - loses whatever happened since the last write.

A Terraria world is one file (two on tModLoader), so a corrupt write damages the whole world rather than a region. Keep backups somewhere other than the server's own folder, and take one before every update and every mod change. [Terraria world backup and transfer](https://www.renode.space/blog/terraria-world-backup-and-transfer) covers the files and the restore.

On RE:NODE a server that reaches its memory limit is stopped and restarted clean rather than left to swap, which is safe for the machine and loses unsaved progress, so leave a margin on a modded server rather than running it at the edge. Terraria plans run from 512 MB at $3 a month up to 4 GB, with one port allocation and backup slots on every tier. Moving up a tier raises the limit on the server you already have, so a world that outgrows its plan stays where it is.

#### FAQ

##### Is 1 GB enough for a Terraria server?

For vanilla, yes, up to a large world with about eight players. TShock with several plugins, or sixteen players and frequent events, is more comfortable at 2 GB. Any tModLoader server beyond a couple of small mods needs more.

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

Plan on 4 GB for Calamity with its usual companion mods and a handful of players. The peak is world generation; if you generate the world on your own PC and upload it, the server only needs enough to run it. Larger packs with their own worldgen can peak around 6 GB.

##### Does a large world use more RAM?

Yes. The whole world is held in memory, and a large world has four times the tiles of a small one. On vanilla the difference is a few hundred megabytes; on modded servers it is larger, because mods add content to every part of the map.

##### Why did my server stop while creating a world?

Almost always memory. World generation peaks well above the memory needed to run the finished world, especially with mods that add structures and biomes. Generate the world locally with the same mods and upload the `.wld` and `.twld`, or create it on a larger plan once.

##### Do more players need more RAM on Terraria?

A little. The world is already fully loaded, so each player adds connection state rather than terrain. More players mostly change CPU during events and bosses, when every NPC and projectile is updated on one thread.

Terraria servers on RE:NODE run from 512 MB to 4 GB with one port allocation and backup slots on every tier, and mods and worlds go in through the file manager or SFTP. The console graphs memory against the plan's limit, so you can see world generation peak before it surprises you.

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

---

### Calamity modded Terraria server

Published 2026-10-07 by RE:NODE Team. https://www.renode.space/blog/terraria-calamity-modded-server

A Calamity server is a tModLoader dedicated server with the Calamity Mod enabled, and every player on it runs the same tModLoader version with the same mods at the same versions. In practice it needs 3-4 GB of memory for Calamity plus the usual companion mods, a fresh world generated with Calamity already loaded, the mod list defined in `enabled.json`, and a few minutes of patience every time it starts. The things that go wrong are predictable: a mod version that does not match a client's, a world created before Calamity was added, a mod list that outgrows the memory, and a mod update that lands the day before game night. This post covers all of it, and applies equally to Thorium, Fargo's and the other large content mods.

The basics of tModLoader on a server - installing it, the `Mods` folder, mod sides - are in [Terraria and tModLoader server setup](https://www.renode.space/blog/terraria-and-tmodloader-server). This post is about what changes when the mods are big.

#### What a big mod does to a server

Calamity is not a handful of new swords. It adds several hundred items, dozens of bosses, new biomes generated into the world, new enemies with their own AI, its own difficulty modes, and a great deal of code that runs every tick. Thorium, Spirit and Fargo's Souls are in the same class. Stacking two or three of them multiplies the effect.

On a server that shows up in four places:

- **Memory.** Every item, NPC, projectile and tile type a mod defines is loaded into memory whether or not anyone uses it. A big mod list costs gigabytes before anyone joins.
- **Start-up time.** The server loads, verifies and sets up every mod on start. Vanilla starts in seconds; a heavy modded server can take a few minutes.
- **World generation.** Modded worldgen adds biomes and structures on top of vanilla's, and generating a large world is the memory high-water mark of the server's whole life.
- **CPU during fights.** Modded bosses fire a lot of projectiles. The world update is single-threaded, so a boss fight with eight players is where clock speed shows.

None of this makes a modded server difficult. It makes it a server you size and maintain deliberately rather than one you start and forget.

#### How much RAM a modded server needs

Memory is decided by the mod list first, the world size second and the player count a distant third.

| Setup | RAM | Notes |
| --- | --- | --- |
| tModLoader, a few quality-of-life mods | 1.5-2 GB | Magic Storage, Boss Checklist, Recipe Browser |
| Calamity plus the usual companions | 3-4 GB | The common case for a group of 4-8 |
| Calamity and Thorium together | 4-5 GB | Large world pushes the top of this |
| Calamity, Thorium, Fargo's Souls and more | 5-6 GB+ | Large worlds peak during generation |

Treat these as starting points. Mods change size between releases, and the only number that matters is what your server uses with your list. Watch the memory graph through one world generation and one busy evening, and size for the peak plus some room.

Two specifics are worth knowing. **World generation is the peak**: a large world with three content mods is assembled in memory before it is written to disk, so a plan that runs the finished world comfortably can still fail to create it. Generating on a medium world, or generating locally and uploading, avoids that. And **memory grows with exploration**: more of the world loaded means more tiles and NPCs held, so a server at 60% on day one is not at 60% a month in.

RE:NODE's Terraria plans run from 512 MB to 4 GB. Calamity with its usual companions fits on the larger tiers; a stack of three or four big content mods on a large world can outgrow 4 GB, and it is better to know that before you start a run than halfway through it. If the container reaches its limit it is stopped and restarted clean rather than swapping, which is safe for the machine but loses unsaved progress. [CPU vs RAM for game servers](https://www.renode.space/blog/cpu-vs-ram-for-game-servers) covers reading which resource you are short of.

#### Installing tModLoader and the mods

tModLoader is a separate application from Terraria, free on Steam for owners of the game, and its server is part of the same download. On a server you either install it with SteamCMD or unpack the release archive from tModLoader's GitHub releases page, then run the server start script it ships with:

```bash
$ cd ~/tmodloader
$ ./start-tModLoaderServer.sh -config serverconfig.txt
```

The repository also ships helper scripts for dedicated servers in a `DedicatedServerUtils` folder that install tModLoader and download workshop mods from a list of IDs; check the tModLoader wiki for the current usage, because it has changed between releases.

Mods live in the `Mods` folder of tModLoader's data directory - on Linux `~/.local/share/Terraria/tModLoader/Mods/` unless the host has moved it - as `.tmod` files, with `enabled.json` deciding which load:

Mods/enabled.json:

```json
[
  "CalamityMod",
  "ThoriumMod",
  "MagicStorage",
  "BossChecklist",
  "RecipeBrowser",
  "Fargowiltas"
]
```

These are internal names, not display names. Calamity is `CalamityMod`, Thorium is `ThoriumMod`, Fargo's Mutant Mod is `Fargowiltas` and its Souls add-on `FargowiltasSouls`. A wrong name does not produce an error; the mod simply is not loaded.

The reliable way to build the list is not to type it at all:

1. In tModLoader on your own PC, subscribe to the mods on the Workshop and enable exactly the set you want.
2. Use the **Mod Packs** menu to save the enabled set, or copy your local `enabled.json`.
3. Upload the `.tmod` files and `enabled.json` to the server's `Mods` folder over SFTP or the file manager - [SFTP and the file manager](https://www.renode.space/blog/sftp-and-the-file-manager) covers the connection.

Workshop downloads on your PC live under `steamapps/workshop/content/1281930/<id>/`, each in a folder named after the workshop item ID, with the `.tmod` inside a version folder. Copy the one matching your tModLoader version.

#### Mod sides and what players have to install

Every tModLoader mod declares a side in its build file, and that decides who needs it:

| Side | Server | Clients | Typical example |
| --- | --- | --- | --- |
| `Both` | Yes | Yes, same version | Calamity, Thorium, Magic Storage |
| `Client` | No | Optional | UI tweaks, many music packs |
| `Server` | Yes | No | Server-only tools |
| `NoSync` | Either | Either, unchecked | Some utilities |

Almost every content mod is `Both`. When a player joins a server with `Both` mods they do not have, tModLoader offers to download them and restart with the server's mod set, so a new player needs only tModLoader and the server address. Where it trips people up is a player who already has a mod at a different version: the join fails, and the message about which mod differs is easy to miss.

Music add-ons deserve a check. Calamity's music is a separate mod, `CalamityModMusic`, and it is large. Whether it needs to be on the server depends on the side the current release declares, which is shown on its workshop page; if it is client-side, leave it off the server and let players choose.

> [!NOTE]
> Mod sync only works smoothly when the server and clients are on the same tModLoader branch. The stable branch updates roughly monthly; the preview branch updates more often and big mods do not always support it. Keep the server on stable and tell players to do the same.

#### Creating the world: generate with the mods loaded

Calamity adds biomes and structures during world generation - the Sulphurous Sea and Abyss on one ocean, the Sunken Sea under the desert, and others. They are only placed when the world is generated with Calamity loaded. Add Calamity to a world created without it and those areas are missing, which breaks progression that depends on them.

So the order is:

1. Install tModLoader and the full mod list on the server.
2. Generate the world with all content mods enabled.
3. Only then let people in.

The world settings go in `serverconfig.txt`, which tModLoader reads exactly as vanilla does:

serverconfig.txt:

```ini
world=/home/container/worlds/Calamitous.wld
autocreate=2
worldname=Calamitous
difficulty=1
maxplayers=8
port=7777
password=change-this
```

`autocreate=2` is a medium world, a sensible size for a modded group: large worlds take longer to generate, use more memory and spread players further apart. `difficulty=1` is Expert, the minimum for Calamity's own Revengeance and Death modes, which are enabled inside the game rather than in this file; how they are toggled has changed between Calamity versions, so check the current Calamity wiki. Every key in this file is explained in [Terraria server config and commands](https://www.renode.space/blog/terraria-server-config-and-commands).

If the server runs out of memory during generation, generate the world on your own PC with the identical mod list instead, then upload both files: the `.wld` and the `.twld` beside it, which holds all modded data. A `.wld` uploaded without its `.twld` loads as a vanilla world with the modded content stripped out.

#### Mod configs on a server

Many big mods have settings, stored as JSON files in the `ModConfigs` folder next to `Mods`, one per config, named `ModName_ConfigName.json`. tModLoader separates two kinds:

- **Server-side configs** affect gameplay and are synced from the server to every client on join. The server's copy is authoritative.
- **Client-side configs** affect only the local player - interface, visuals, audio - and are never synced.

To change a server-side setting, edit the JSON file in `ModConfigs` on the server while it is stopped, or set it in your local game with the same mods and upload the resulting file. Restart the server afterwards. Client-side settings are each player's own business.

This matters most for mods with difficulty or balance switches - Fargo's Souls is a good example, and Calamity has gameplay options of its own. Agree on them as a group before the world starts, because changing balance mid-run tends to lead to arguments.

#### Performance during the game

Modded Terraria's cost is uneven. Walking around is cheap; a boss fight with several players and hundreds of projectiles on screen is where the server works hardest.

- **Projectiles and NPCs.** Late-game Calamity bosses fill the screen. The server updates every projectile and NPC every tick, on one thread. If the server lags only during fights, that is the cause, and only a faster core helps.
- **Players spread out.** Each player keeps their surroundings active. Eight players in eight biomes cost more than eight in one base.
- **Farms and spawners.** Statue farms and invasion farms generate a lot of entities. Fine in moderation, a problem when four of them run at once.
- **Item clutter.** Dropped items on the ground are entities. Magic Storage helps by keeping things off the floor.

The usual Terraria advice holds: a weekly restart keeps memory steady and gives a clean save point. [Restart schedules that help](https://www.renode.space/blog/restart-schedules-that-help) has the timing argument, and [reading a server load graph](https://www.renode.space/blog/reading-a-server-load-graph) shows how to tell CPU lag from memory pressure.

#### Updates, adding mods and removing them

Big mods update often, and each update can change items, recipes or world data. On a server, that means updates are something you decide, not something that happens:

1. **Back up first** - the `.wld`, the `.twld`, the `Mods` folder and `ModConfigs`. A backup from before an update is the only clean way back.
2. **Update tModLoader before the mods**, and only when the big mods support the new version. Calamity in particular sometimes lags a tModLoader release.
3. **Update the server and tell players at the same time.** A client that auto-updated a mod the server has not will be refused, and the reverse.
4. **Watch the first start after an update** in the console for load errors.

Adding a mod to a running world is usually safe, but a mod that generates terrain will only place its biomes in new worlds or unexplored areas, depending on how it is written. Removing a content mod is the risky direction. tModLoader keeps placeholder data for some content from mods that are no longer loaded, so putting the mod back can restore it, but anything the mod tracked in its own world data may not survive, and players will see their items turn into placeholders in the meantime. Do not remove Calamity from a Calamity world and expect to carry on. [What to do when a mod update breaks](https://www.renode.space/blog/what-to-do-when-a-mod-update-breaks) has the full recovery drill.

On RE:NODE, backup slots are included on every Terraria plan and kept off the machine, so the before-update copy is a button rather than a download, and the Schedules tab can take one every night on a cron expression.

#### Troubleshooting

**Server stops during world creation.** Out of memory. Use a medium world, generate it on your PC and upload the `.wld` and `.twld`, or move up a plan.

**"Mod version mismatch" on join.** The client has a different version of a mod than the server. The player should let tModLoader download the server's mods, or update from the Workshop to the same version.

**The Abyss or Sunken Sea is missing.** The world was generated without Calamity loaded. Generate a new world with the full list.

**Server takes five minutes to start.** Normal for a big list. Look for errors in the console rather than the clock.

**A mod is in Mods but not loading.** Its internal name in `enabled.json` is wrong, or its version does not support this tModLoader release. The console lists every mod it loads.

**Lag only in boss fights.** Projectile and NPC count on one thread. Fewer players in the arena, or a faster CPU core, are the only real fixes.

#### FAQ

##### Do my friends need to download Calamity before joining?

They need tModLoader, owned through Terraria on Steam. When they join, tModLoader offers to download the server's mods and restart with them. If they already have a different version of a mod, they must match the server's.

##### Can I add Calamity to the world we already have?

You can, but its generated biomes will be missing, and parts of its progression depend on them. Start a new world with Calamity loaded from the beginning.

##### Can console or mobile players join a Calamity server?

No. tModLoader is PC only, and a modded server only accepts tModLoader clients with matching mods.

##### Is Calamity plus Thorium too much for one server?

Not inherently. Expect 4-5 GB on a medium world and longer start-up times. Watch memory through world generation and the first big boss fight before inviting the whole group.

##### Can I run TShock on a modded server?

No. TShock is a separate server for vanilla Terraria. Admin features on tModLoader come from mods instead. [The TShock guide](https://www.renode.space/blog/terraria-tshock-server-guide) covers what TShock offers if your group decides vanilla is enough.

Terraria plans on RE:NODE go up to 4 GB with NVMe storage, enough for Calamity and its usual companions. Mods and configs upload over SFTP or the file manager, the console shows every mod as it loads, and backup slots on every plan cover the copy you take before each mod update.

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

---

### TShock server: groups and permissions

Published 2026-10-07 by RE:NODE Team. https://www.renode.space/blog/terraria-tshock-server-guide

TShock is a replacement Terraria server that keeps the game identical for players and adds what the vanilla server lacks: user accounts, groups with permissions, protected regions, item and projectile bans, bans that survive name changes, server-side characters, plugins and a REST interface. You install it in place of `TerrariaServer`, claim ownership with a one-time setup code, create your account in the `owner` group, and then shape the group ladder to match how much you trust each kind of player. Its one real cost is that it must be rebuilt for every Terraria release, so it trails each update by days or weeks. This guide goes through installation, accounts, groups and permissions in detail, then regions, bans, server-side characters, plugins and the config file.

If you have not decided between vanilla, tModLoader and TShock yet, [Terraria and tModLoader server setup](https://www.renode.space/blog/terraria-and-tmodloader-server) compares the three. The vanilla `serverconfig.txt` and console commands are covered in [Terraria server config and commands](https://www.renode.space/blog/terraria-server-config-and-commands); this post is about everything TShock adds on top.

#### What TShock is, and what it cannot do

TShock is built on OTAPI, a patched copy of the official Terraria server that exposes hooks, and it runs on .NET. Clients connect to it with the normal, unmodified game. From a player's point of view it is a Terraria server that answers slash commands and occasionally tells them they are not allowed to break a block.

What it adds:

- **Accounts.** Players register a password and log in, so identity is not just a character name anyone can copy.
- **Groups and permissions.** Every account belongs to a group; every command and many actions need a permission.
- **Regions.** Protected rectangles where only allowed users or groups can build.
- **Anti-grief and anti-cheat checks.** Limits on how fast tiles can be broken or placed, damage caps, range checks, and bans on specific items and projectiles.
- **Server-side characters.** Optional storage of inventories on the server.
- **Plugins** written in C#, loaded from `ServerPlugins`.
- **A REST API** for remote administration and web panels.

What it cannot do: run tModLoader mods. TShock and tModLoader are two separate patched servers, and a modded server with Calamity and friends cannot also be a TShock server. If you want content mods, see [running a Calamity modded server](https://www.renode.space/blog/terraria-calamity-modded-server) instead. TShock also cannot be ahead of the game: a client that updated to a new Terraria version cannot join until a matching TShock release exists.

#### Installing and the first start

TShock is distributed as release archives on its GitHub releases page, built per platform and per Terraria version - a file named along the lines of `TShock-5.x-for-Terraria-1.4.4.9-linux-x64-Release.zip`. The version in the name is the Terraria version it accepts. Download the one that matches the game version your players have, unpack it, and run the server binary.

```bash
$ mkdir -p ~/tshock && cd ~/tshock
$ unzip TShock-*-linux-x64-Release.zip
$ ls
TShock.Server  ServerPlugins/  ...
$ ./TShock.Server -port 7777 -maxplayers 16 \
    -world ~/tshock/worlds/Blossom.wld -autocreate 2 -worldname Blossom
```

Recent Linux releases are self-contained, so the .NET runtime ships inside the archive; older ones expected the runtime installed separately. Check the release notes of the version you download.

The vanilla start arguments still work - `-port`, `-maxplayers`, `-world`, `-autocreate` (`1` small, `2` medium, `3` large) and `-worldname`. On the first start TShock creates its own folder beside the binary:

```text
tshock/
  config.json        TShock's own settings
  sscconfig.json     server-side character settings
  motd.txt           the message shown on join
  setup-code.txt     one-time ownership code
  tshock.sqlite      accounts, groups, bans, regions, warps
  logs/              one log file per start
ServerPlugins/       plugin .dll files
```

`tshock.sqlite` is the important one. Every account, group change, ban, region and warp lives in it. Back it up together with the world, because a world restored without its database has regions that no longer match their buildings and bans that have gone.

On a panel-based host, check what the Terraria server actually runs before you replace anything: the console prints TShock's version banner on start if it is already TShock. The start command on a panel is part of the server's configuration, so if your server is vanilla, ask support about running TShock rather than uploading a new binary over the old one.

#### Claiming the server: the setup code

The first time TShock starts with no owner account, it prints a setup code in the console and writes it to `tshock/setup-code.txt`. That code makes whoever uses it a temporary superadmin. Join the server with a normal client and run, in this order:

```text
/setup 12345678
/user add yourname a-long-password owner
/login yourname a-long-password
/setup
```

The first line grants temporary superadmin. The second creates a permanent account in the `owner` group. The third logs you into it. The last line, `/setup` on its own, ends setup mode so the code stops working.

Do all four in one go. A server left in setup mode with the code still valid can be taken over by anyone who reads the console or guesses the code. If you lose access to the owner account later, deleting `setup-code.txt` and the owner accounts from the database is the recovery route, so keep the owner password somewhere safe.

The server console itself always has full rights. Anything you would type in game, you can type into the panel console, which is the easiest way to administer a server you are not playing on.

##### Accounts and logging in

Players create accounts themselves:

| Command | What it does |
| --- | --- |
| `/register <password>` | Creates an account named after the character |
| `/login <password>` | Logs into the account matching the character name |
| `/login <user> <password>` | Logs into a named account |
| `/logout` | Logs out |
| `/password <old> <new>` | Changes the password |
| `/user add <name> <pass> <group>` | Admin: creates an account |
| `/user group <name> <group>` | Admin: moves an account to a group |
| `/user password <name> <pass>` | Admin: resets a password |
| `/user del <name>` | Admin: deletes an account |

By default a player can play without logging in, as a guest. `RequireLogin` in `config.json` forces login before they can do anything meaningful, and on a public server it should be on - otherwise a griefer simply never registers. New registrations go to the group named in `DefaultRegistrationGroupName`, `default` unless you change it; players who are not logged in are in `DefaultGuestGroupName`, normally `guest`.

TShock can also log returning players in automatically by their client UUID, which is convenient and a little weaker than a password. Leave it on for a friends' server; consider turning it off for a public one.

#### Groups and the permission ladder

Every account is in exactly one group. Every group has a list of permissions and, optionally, a parent group whose permissions it inherits. Out of the box TShock builds a ladder roughly like this:

| Group | Inherits from | Intended for |
| --- | --- | --- |
| `guest` | - | Not logged in |
| `default` | `guest` | Registered players |
| `vip` | `default` | Trusted players, reserved slots |
| `newadmin` | `vip` | Junior staff: kick, mute |
| `admin` | `newadmin` | Staff: bans, regions, teleport |
| `trustedadmin` | `admin` | Senior staff: item spawning, world changes |
| `owner` | `trustedadmin` | You |

The exact defaults have moved between major versions, so check yours with `/group list` and `/group listperm <group>` before relying on this table. Changes are made with `/group`:

```text
/group add builder
/group parent builder default
/group addperm builder tshock.world.editspawn
/group prefix builder "[Builder] "
/group color builder 120,200,255
/user group alice builder
```

That creates a `builder` group that inherits everything `default` has, adds the ability to build inside spawn protection, gives it a chat prefix and colour, and moves Alice into it.

Permissions are dotted strings. A few that come up on every server:

| Permission | Allows |
| --- | --- |
| `tshock.world.modify` | Breaking and placing at all |
| `tshock.world.editspawn` | Building inside spawn protection |
| `tshock.admin.kick` | `/kick` |
| `tshock.admin.ban` | `/ban` |
| `tshock.admin.region` | Defining and editing regions |
| `tshock.item.spawn` | `/item` and `/give` |
| `tshock.npc.spawnboss` | `/spawnboss` |
| `tshock.npc.butcher` | `/butcher` |

Two syntax details matter. A leading `!` negates a permission, which is how you remove something a parent group grants: `/group addperm vip !tshock.npc.spawnboss`. And `*` grants everything, which is what `owner` and the console have; never give `*` to a group other people are in.

> [!TIP]
> Build staff groups by adding permissions to a low group rather than removing them from a high one. A junior moderator who inherits from `default` and gets exactly kick, mute and region info is far safer than an admin with a list of negations.

For the general principle behind this - give each person the least they need - see [server rules, moderation and staff](https://www.renode.space/blog/server-rules-moderation-and-staff).

#### Regions, spawn protection and warps

Spawn protection is on by default: `SpawnProtection` and `SpawnProtectionRadius` (10 tiles) in `config.json` stop anyone without `tshock.world.editspawn` building near the world spawn. It is the first thing that confuses new players on a TShock server, who discover they cannot dig next to where they arrived.

Regions are the general version. To protect a base:

```text
/region set 1        then hit the top-left block
/region set 2        then hit the bottom-right block
/region define TownHall
/region allow alice TownHall
/region allowg builder TownHall
```

Regions are protected when created. Other useful subcommands are `/region list`, `/region info <name>`, `/region protect <name> false` to open one up, `/region remove <user> <name>` and `/region delete <name>`. `/region name` followed by hitting a block tells you which region it belongs to, which settles most "why can't I build here" arguments in seconds.

Warps are named teleport points: `/warp add Market` saves your position, `/warp Market` takes a player there, `/warp del Market` removes it. Like everything else, they live in `tshock.sqlite`.

#### Bans, mutes and item bans

TShock's ban system tracks players by account, client UUID and IP address together, so a banned player cannot come back by renaming their character. In TShock 5:

```text
/ban add griefer42 "Destroyed the hellevator" 7d
/ban list
/ban details 14
/ban del 14
```

Each ban gets a ticket number; `/ban details` and `/ban del` take that number. A duration such as `7d` or `12h` makes it temporary; leave it out for a permanent ban. `/kick <player> [reason]`, `/mute <player>` and `/unmute <player>` cover the lighter end.

Item, projectile and tile bans stop specific things being used at all:

```text
/itemban add "Dirt Rod"
/itemban allow "Dirt Rod" builder
/projban add 17
/tileban add 4
```

Item bans take the item name; projectile and tile bans take numeric IDs, which the Terraria wiki lists. Common candidates on public servers are explosives, liquid-spreading items and anything that can flood or blow up other people's builds. `/itemban allow` exempts a group, so trusted builders keep tools you have banned for everyone else.

#### Server-side characters

By default, a Terraria character lives on the player's PC and comes with them to any server. That means a player can walk onto your progression server with a character from a cheated single-player world, holding endgame weapons on day one. TShock's only real answer is server-side characters (SSC).

SSC is configured in `tshock/sscconfig.json`:

tshock/sscconfig.json:

```json
{
  "Settings": {
    "Enabled": true,
    "StartingHealth": 100,
    "StartingMana": 20,
    "StartingInventory": []
  }
}
```

With `Enabled` set to `true`, each account's inventory, health and mana are stored in `tshock.sqlite`. Players start with what you define, and what they carry is what they earned on your server. Logging in becomes mandatory in practice, since the character is tied to the account.

Turn SSC on before the server opens, not halfway through: every existing player starts again from the starting inventory, and that conversation is easier on day one. Players who also play elsewhere will notice that their character on your server is separate, which is the point.

#### config.json: the settings that matter

TShock's own settings are in `tshock/config.json`, inside a `Settings` object since TShock 4.5. The file is long; these are the keys worth knowing.

| Key | Default | What it does |
| --- | --- | --- |
| `ServerPassword` | empty | Join password |
| `ServerPort` | `7777` | Overrides the vanilla port |
| `MaxSlots` | `8` | Player limit |
| `ReservedSlots` | `20` | Extra slots for groups with the reserved permission |
| `SpawnProtection` | `true` | Protects the area around spawn |
| `SpawnProtectionRadius` | `10` | Radius in tiles |
| `RequireLogin` | `false` | Players must log in to play |
| `DefaultRegistrationGroupName` | `default` | Group for new accounts |
| `DefaultGuestGroupName` | `guest` | Group for logged-out players |
| `AutoSave` | `true` | Periodic world saves |
| `AnnounceSave` | `true` | Tells players when the world saves |
| `BackupInterval` | `0` | Minutes between world backups, `0` off |
| `BackupKeepFor` | `60` | Minutes to keep each backup |
| `EnableWhitelist` | `false` | Enforces `whitelist.txt` |
| `RestApiEnabled` | `false` | Turns on the REST API |
| `RestApiPort` | `7878` | REST API port |

Key names and defaults have changed between major versions, so treat this as a map rather than gospel and read the file your version wrote. After editing, `/reload` re-reads the config without a restart for most settings; port and slot changes need one.

`MaxSlots` deserves a note: `MaxSlots` and the vanilla `-maxplayers` both exist, and TShock's own setting is the one that decides who gets in. Set both to the same number to avoid confusion.

##### Plugins and the REST API

Plugins are `.dll` files in `ServerPlugins`. They are compiled against a specific TShock API version, and a plugin built for an older TShock usually fails to load on a newer one - the console says so on start. Before updating TShock, check every plugin you rely on has a release for the new version, and keep the old `ServerPlugins` folder until you know the update worked. Plugins run with the server's full rights, so take them from their authors' release pages, not from re-uploads; [keeping a modded server clean](https://www.renode.space/blog/keeping-a-modded-server-clean) has the reasoning.

The REST API, when enabled, is an HTTP interface on `RestApiPort` that can run commands, list players and manage bans with a token. Web dashboards and Discord bots use it. It is also an admin interface reachable over the network, so if you enable it, use long tokens and do not leave the port open to everyone - [firewall rules that matter](https://www.renode.space/blog/firewall-rules-that-matter) and [RCON, safely](https://www.renode.space/blog/rcon-safely) cover the same problem for other games.

#### Updates, saving and backups

TShock's release cycle follows Terraria's. When Re-Logic ships an update, players' games update automatically and they cannot join an older TShock until a new release appears. For a small patch that is usually days; for a major one it can be longer. Tell your players before it happens rather than after.

Saving works as on vanilla - the world is written periodically with `AutoSave` on, and `/save` forces one. Stop the server with `/off`, which saves and shuts down, rather than killing it; `/off-nosave` exists for the rare case where you want to throw away what is in memory.

Back up three things together: the `.wld` world file, `tshock/tshock.sqlite`, and `tshock/config.json`. On RE:NODE, backup slots are included on every Terraria plan, stored off the machine, and the Schedules tab can send `/save` as a console command and take a backup straight after on a cron expression. [Terraria world backup and transfer](https://www.renode.space/blog/terraria-world-backup-and-transfer) covers the world-file side in detail.

#### FAQ

##### Can players join a TShock server with the normal game?

Yes. TShock is server-side only and clients use the unmodified game. The one condition is version: the client must be on the Terraria version that TShock release was built for.

##### Can I run TShock and tModLoader together?

No. They are separate patched servers. A server is either TShock with vanilla content, or tModLoader with mods. Some TShock-style admin features exist as tModLoader mods, but not TShock itself.

##### I lost access to my owner account. How do I get it back?

Use the server console, which always has full rights: `/user password <name> <newpass>` resets the password. If the account is gone, `/user add <name> <pass> owner` from the console recreates it.

##### Why can new players not break blocks near spawn?

Spawn protection. Either move the spawn point away from where people build, reduce `SpawnProtectionRadius`, or give trusted groups `tshock.world.editspawn`.

##### Does TShock make the server slower?

Slightly, in that it checks more things per action, but a TShock server runs comfortably in the same memory as vanilla - 512 MB to 1 GB for a typical world. Plugins are where cost appears.

Terraria plans on RE:NODE start from 512 MB, with an unfiltered console where TShock's setup code and every slash command work, SFTP for plugins and the database file, and backup slots on every plan for the world and `tshock.sqlite` together.

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

---

### Terraria world backup and server transfer

Published 2026-10-07 by RE:NODE Team. https://www.renode.space/blog/terraria-world-backup-and-transfer

A Terraria world is one file with a `.wld` extension, plus a `.wld.bak` holding the previous save. Moving a world to a dedicated server is uploading that file into the server's world folder with the server stopped, then pointing the `world` line in `serverconfig.txt` at it. Moving it back is downloading the same file. tModLoader adds a second file, `.twld`, which must always travel with its `.wld`; TShock adds a database whose protected regions are tied to the world. Characters are separate `.plr` files on each player's PC and never need moving. The only common way to lose a Terraria world is to rely on the `.bak` file as a backup - it is overwritten on every save, on the same disk. This guide covers where worlds live on every platform, each direction of transfer, the modded and TShock cases, and a backup routine that actually restores.

For `serverconfig.txt` itself and the console commands, see [Terraria server config and commands](https://www.renode.space/blog/terraria-server-config-and-commands); for modded servers in general, [Terraria and tModLoader server setup](https://www.renode.space/blog/terraria-and-tmodloader-server).

#### What a Terraria world is made of

| File | What it is |
| --- | --- |
| `Name.wld` | The world: tiles, chests, NPCs, progress flags, the map seed |
| `Name.wld.bak` | The previous save of the same world, written on each save |
| `Name.twld` | tModLoader only: data belonging to mods |
| `Name.twld.bak` | tModLoader only: the previous mod data save |
| `Name.plr` | A character, on the player's own PC, not part of the world |
| `Name.map` | A player's explored map of a world, also on their PC |

Two consequences follow. A world is self-contained: copy one `.wld` and you have copied everything about it, which makes moving and backing up trivial. And the server never holds characters on a vanilla server, so a world transfer never touches anybody's inventory - each player brings their character from their own machine, which is also why you cannot stop someone arriving with endgame gear.

The file name and the world's display name are different things. The display name is stored inside the file and shown in the game's world list; the file name is what the server's `world` line refers to. A world called "Land of Slime" may be saved as `Land_of_Slime.wld`. When the server cannot find a world, it is nearly always the file name that is wrong.

#### Where worlds live

| Platform | Vanilla worlds | tModLoader worlds |
| --- | --- | --- |
| Windows | `Documents\My Games\Terraria\Worlds\` | `Documents\My Games\Terraria\tModLoader\Worlds\` |
| Linux | `~/.local/share/Terraria/Worlds/` | `~/.local/share/Terraria/tModLoader/Worlds/` |
| macOS | `~/Library/Application Support/Terraria/Worlds/` | `.../Terraria/tModLoader/Worlds/` |
| Server | Wherever `worldpath` points | Same, for the tModLoader server |

On Steam, a world can also be stored in Steam Cloud rather than locally. A cloud world does not appear in the `Worlds` folder - it sits in Steam's own `userdata` folder for Terraria's app id `105600` - and copying from there by hand is unreliable. The clean way out is in the game: on the world selection screen, each world has a cloud toggle. Switch the world to local storage, and it appears in your `Worlds` folder as an ordinary `.wld`.

If you are not sure which world is which, sort the folder by modification date and play the world for a minute - the file that changes is the one you are in.

#### Moving a world from your PC to the server

1. **Close Terraria** on your PC, or at least return to the main menu, so the world is fully saved.
2. **Find the file** in your `Worlds` folder. Bring the `.wld`; bringing the `.wld.bak` too costs nothing and gives you a second chance.
3. **Stop the server** with `exit` in the console, which saves and shuts down. Never upload while it runs - the server's next save overwrites your file with its own world.
4. **Upload** the file into the server's world folder over SFTP or the file manager. [SFTP and the file manager](https://www.renode.space/blog/sftp-and-the-file-manager) has the details.
5. **Point the config at it**. In `serverconfig.txt`, set `world` to the full path of the file, exactly, including capitals:

serverconfig.txt:

```properties
world=/home/container/worlds/Land_of_Slime.wld
worldpath=/home/container/worlds/
autocreate=0
```

6. **Start the server** and read the log. You should see the world loading by name; if you see world generation, the path was wrong.

`autocreate` is the setting to watch. If it is set to a size and the `world` path does not match an existing file, the server generates a brand new world with that file name instead of failing. That is convenient for a first start and a trap during a transfer, because the server looks perfectly healthy while running the wrong world. Set it to `0` while moving worlds around, so a wrong path is an error rather than a surprise. On a panel, the world name and size are often Startup tab variables that feed these lines, so check there as well as in the file.

```diagram
title: Where a Terraria world goes
pc = Player's PC | Worlds/Name.wld
cloud = Steam Cloud | toggle to local
server = Server | serverconfig world=
backup = Off-server backup | scheduled
test = Spare copy | restore test
cloud -> pc : world select toggle
pc -> server : upload with server stopped
server -> backup : nightly
backup -> test : prove it restores
server -> pc : download to play offline
```

#### Moving a world from the server to your PC

Run `save` in the server console and wait for it to finish, or stop the server with `exit`. Download the `.wld` and drop it into your local `Worlds` folder. It appears in your world list immediately and can be played single-player or hosted from the game. This is the copy to take before a server is cancelled, before moving to another host, and before anything risky. A world you can open at home is a world no hosting problem can take from you.

#### Difficulty and journey mode compatibility

A world's difficulty is fixed when it is created and travels with the file. Classic, Expert and Master worlds accept classic, mediumcore and hardcore characters. Journey worlds only accept journey characters, and journey characters can only join journey worlds. If somebody cannot join a world you just moved, check the character type before you check the network.

The server's `difficulty` setting only affects worlds it creates. Changing it does nothing to a world that already exists, uploaded or not. [Terraria server config and commands](https://www.renode.space/blog/terraria-server-config-and-commands) covers journey mode permissions, which are a server setting rather than part of the world.

#### tModLoader worlds

A tModLoader world is a pair: `Name.wld` and `Name.twld`. The `.twld` holds every modded tile, item, NPC and piece of mod data. Upload a `.wld` without its `.twld` and the world loads with every modded thing gone. Always move them together, and back them up together.

The server also needs the same mods the world was played with. tModLoader keeps the enabled list in `enabled.json` in its `Mods` folder; copying that file and the mod files to the server is the reliable way to match a local setup. If a world is loaded without a mod it used, tModLoader generally preserves that mod's content as unloaded placeholders rather than deleting it, so re-adding the mod later restores it - but do not rely on that for anything you would miss. Big content mods are their own subject; [Terraria Calamity and modded servers](https://www.renode.space/blog/terraria-calamity-modded-server) covers memory and syncing mods.

#### TShock worlds

TShock loads ordinary `.wld` files, so transferring the world itself is identical. What TShock adds is a database in its `tshock` folder - `tshock.sqlite` by default - holding accounts, groups, bans, protected regions and, if enabled, server-side characters.

Two things to know when moving a TShock world:

- **Regions belong to a world ID**, a number stored inside the `.wld`. Move the same world to a new TShock server with the old database, and its regions come with it. Move a different world into a server, and the old regions do not apply to it - they are still in the database, tied to the old world's ID.
- **Server-side characters live in the database, not in `.plr` files.** On an SSC server, the database is as important as the world. Back up the `tshock` folder alongside the worlds, always.

TShock also has its own automatic world backups, configured in its config file with an interval and a retention period and written into a backups folder under `tshock`. They are useful and they live on the same disk as the world. [The TShock server guide](https://www.renode.space/blog/terraria-tshock-server-guide) covers the rest of the setup.

#### Backups that work

The `.wld.bak` file is the previous save, overwritten every time the world saves. It protects against a save that was interrupted halfway, which is what it was designed for. It does not protect against a world that was griefed, a boss fight that went wrong an hour ago, a deleted server or a disk problem. Neither do rolling copies kept by `worldrollbackstokeep` on current builds, because they sit in the same folder.

A routine that covers the real risks:

- **A nightly copy of the world folder**, kept somewhere other than the server, while people are playing.
- **A manual copy before anything irreversible.** Breaking the first altar after Wall of Flesh, summoning a boss that can wreck a base, enabling a new mod.
- **Save before you copy.** Run `save` in the console first; a copy taken mid-save may be incomplete, and a copy taken without one is of the last autosave, not of now.
- **One practice restore.** Load a backup on a spare server or at home, walk around, check the latest builds are there. [Backups that actually restore](https://www.renode.space/blog/backups-that-actually-restore) is the long argument; [testing a restore before you need it](https://www.renode.space/blog/testing-a-restore-before-you-need-it) the ten-minute version.

On RE:NODE, each Terraria plan includes backup slots, taken on demand or on a schedule and stored off the machine they protect. A Schedules entry can run `save` as a console command, then a backup, as ordered tasks with a delay between them, so the backup captures the world as it is rather than as it was at the last autosave. Restoring is one button, backups can be downloaded to keep a copy at home, and a backup slot can be locked so rotation never removes the copy you took before the altar.

#### Restoring and rolling back

To roll a world back from a backup:

1. Stop the server with `exit`.
2. Move the current `.wld` (and `.twld`) aside rather than deleting it - you may want something from it.
3. Put the backup copy in its place with the same file name.
4. Start the server, check the log, join and confirm.

To recover from a world that will not load, try the `.bak` first: stop the server, move the broken `Name.wld` aside, copy `Name.wld.bak` to `Name.wld`, and start. If that also fails, go to your most recent real backup. Tools such as TEdit can open and sometimes repair damaged world files, but treat that as a last resort and work on a copy.

Announce a rollback before doing it. Players lose everything built since the backup, and their characters keep whatever they gathered, so items may exist twice. That is usually the right trade after a griefing incident and the wrong one for a lost hour of mining.

#### Troubleshooting

**The server generated a new world instead of loading mine.** The `world` path does not match the file exactly and `autocreate` is on. Fix the path, set `autocreate=0`, delete the accidental world if you like, and restart.

**My world is not in the Worlds folder.** It is a Steam Cloud world. Toggle it to local on the world select screen.

**The world loaded but all modded items are gone.** The `.twld` was not uploaded, or the server is missing mods the world used.

**A player cannot join the moved world.** Journey characters only join journey worlds, and the reverse. Also check the client and server are on the same version.

**My upload disappeared after a restart.** The server was running during the upload and saved its own world over yours. Stop first, then upload.

**Regions stopped protecting anything after a move.** TShock regions are tied to the world ID of the world they were made in. The world you loaded is a different one.

#### FAQ

##### Where are Terraria world files saved?

On Windows in `Documents\My Games\Terraria\Worlds`, on Linux in `~/.local/share/Terraria/Worlds`, on macOS in `~/Library/Application Support/Terraria/Worlds`. tModLoader uses a `tModLoader\Worlds` folder beneath the same root. Steam Cloud worlds are elsewhere until you toggle them to local.

##### How do I upload a Terraria world to a dedicated server?

Stop the server, upload the `.wld` file into its world folder, set `world` in `serverconfig.txt` to that file's exact path, and start. For tModLoader, upload the `.twld` alongside it.

##### Do I need to move characters to the server?

No. On a vanilla server characters are `.plr` files on each player's PC and come with them. TShock servers with server-side characters store them in TShock's database instead.

##### Is the .wld.bak file a backup?

Only of the previous save. It is overwritten on every save and kept on the same disk, so it protects against an interrupted save, not against griefing, mistakes or losing the server.

##### Can I download my world from the server to play offline?

Yes. Save or stop the server, download the `.wld` (and `.twld` for tModLoader), and put it in your local `Worlds` folder. It appears in your world list.

##### Can I change a world's difficulty after moving it?

No. Difficulty and journey mode are set when the world is created and are part of the file. The server's difficulty setting only affects new worlds.

Terraria servers on RE:NODE start from $3 a month with the port allocated, `serverconfig.txt` and the world folder reachable in the file manager or over SFTP, and backup slots on every plan that restore with one button. The Schedules tab can run a save and a backup in order every night.

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

---

### Terraria server config and commands

Published 2026-09-21 by RE:NODE Team. https://www.renode.space/blog/terraria-server-config-and-commands

A Terraria server is one executable and one text file. `TerrariaServer` reads `serverconfig.txt`, opens a single TCP port, loads a `.wld` file and that is the entire architecture - no query port, no server browser, no RCON, no plugin system. It is refreshingly small, and it is also why the vanilla server gives you twenty-four console commands and nothing else: no permissions, no whitelist, no teleport, no protection. This guide covers every setting in the config file, every console command the server actually has, how world creation works including the secret seeds, the journey mode permission block, and where TShock takes over. Figures here are from the 1.4.5 dedicated server; a key that does not exist in your build will simply be ignored.

#### How a Terraria server is configured

The dedicated server is a free download from terraria.org, separate from the game, containing Windows, Linux and Mac builds in one archive. It must be the same version as the clients, down to the fourth digit - a 1.4.5.8 client cannot join a 1.4.5.7 server.

Started with no arguments, the server runs an interactive wizard: choose a world or make one, pick the size, the difficulty, the world evil, a name, a port, whether to forward it with UPnP, and a password. That is pleasant on a desktop and useless on a server, because a process waiting on standard input looks exactly like a process that has hung. Point it at a config file instead:

```bash
$ ./TerrariaServer.bin.x86_64 -config serverconfig.txt
```

Everything in the file has a command line equivalent, and the command line wins where both are set. The file is plain `key=value`, one per line, `#` for comments, no spaces around the equals sign and no quotes around values. It is read once at start, so every change needs a restart.

On a panel you are not typing that command. On RE:NODE the world is generated on the first boot and the size and difficulty are fields on the Startup tab, which set the same values the wizard would have asked for.

#### Requirements, player counts and performance

Terraria is the lightest game in this catalogue and the numbers are genuinely small.

| Setup | RAM | CPU | Notes |
| --- | --- | --- | --- |
| 1-4 players, small or medium world | 512 MB - 1 GB | 0.5 core | Plenty |
| 5-8 players, large world | 1 GB | 0.75 core | The common case |
| 8-16 players, events and invasions | 2 GB | 1-1.5 cores | Spikes, not sustained load |
| TShock with a stack of plugins | 2 GB | 1.5 cores | Plugins cost more than players |
| tModLoader with a large mod pack | 4-6 GB | 2 cores | A different animal entirely |

`maxplayers` accepts anything from 1 to 255. The number you can actually run is not a memory question, it is an NPC question: the server updates every active NPC and projectile on one thread, and a Frost Moon with sixteen players present is a different workload from sixteen people mining. Load is spiky rather than steady, which is why a Terraria server can idle for an hour and then stutter for ninety seconds during an invasion.

Two settings exist specifically for this. `npcstream` trades bandwidth against enemy skipping - lower numbers send more data and produce less teleporting, `0` turns the throttle off. `slowliquids=1` caps how much liquid moves at once, which helps during large flooding but makes water take longer to settle.

The heavy variant is tModLoader, where every mod loads into the same process and world generation is the peak. That is covered separately in [Terraria and tModLoader, hosted properly](https://www.renode.space/blog/terraria-and-tmodloader-server); size for generation, not for the steady state.

#### serverconfig.txt, setting by setting

| Setting | Default | What it does |
| --- | --- | --- |
| `world` | - | Full path to the `.wld` file to load |
| `worldpath` | - | Directory where worlds are stored |
| `autocreate` | - | Create a world if none found: `1` small, `2` medium, `3` large |
| `worldname` | `Terraria` | Name used when autocreating |
| `seed` | - | World seed for autocreate |
| `difficulty` | `0` | `0` classic, `1` expert, `2` master, `3` journey |
| `maxplayers` | `8` | 1 to 255 |
| `port` | `7777` | TCP listening port |
| `password` | - | Join password. Blank means open |
| `motd` | - | Message shown on join |
| `worldrollbackstokeep` | `2` | Rolling world backups kept |
| `banlist` | `banlist.txt` | Path to the ban list |
| `secure` | - | `1` adds extra cheat protection |
| `language` | `en-US` | Server language code |
| `upnp` | `1` | Automatic port forwarding on a home router |
| `npcstream` | `60` | Lower sends more data and skips fewer enemies |
| `priority` | `1` | Process priority, `0` realtime to `5` idle |
| `slowliquids` | - | `1` limits simultaneous liquid movement |

A worked example for a private server on a large expert world:

serverconfig.txt:

```properties
world=/home/terraria/.local/share/Terraria/Worlds/Hardmode.wld
worldpath=/home/terraria/.local/share/Terraria/Worlds/
autocreate=3
worldname=Hardmode
difficulty=1
maxplayers=10
port=7777
password=copper-shortsword
motd=Be nice. No grief. Boss fights are announced in Discord.
worldrollbackstokeep=3
secure=1
npcstream=60
priority=1
```

Three notes that save an evening. `world` wants the full path to the file including the extension; `worldpath` wants a directory and is used for autocreate and for the world list. `autocreate` only fires when the file in `world` does not exist, so leaving it in is safe once the world is made - it is not the same trap as Factorio's `--create`. And `upnp` is for a router at home; on hosted infrastructure it does nothing useful and can be left at the default or set to `0`.

`secure=1` is worth turning on. It adds server-side checks against a handful of common client-side cheats. It is not an anti-cheat and it will not stop a determined inventory editor, but it costs nothing.

#### Creating the world: size, difficulty, evil and secret seeds

World size is the `autocreate` value: `1` small, `2` medium, `3` large. Large worlds take longer to generate, hold more content and are what most groups want. Difficulty is set once at creation and cannot be changed afterwards from the config - `0` classic, `1` expert, `2` master, `3` journey.

World evil - corruption or crimson - is chosen at creation. There is no config key for it, but the command line has `-worldevil` and the interactive wizard asks. On a panel, that choice is normally a field on the Startup tab alongside size and difficulty.

Then there are the secret seeds, which get their own config keys rather than being typed into `seed`. Each is a `0` or `1` switch and enabling one overrides the seed text:

```properties
#seed_celebration=1
#seed_theconstant=1
#seed_notthebees=1
#seed_notraps=1
#seed_fortheworthy=1
#seed_remix=1
#seed_drunk=1
#seed_zenith=1
```

These are the drunk world, the for-the-worthy world, the no-traps world and the rest. They change world generation profoundly and they are permanent, so set them before the first boot or not at all. If several are enabled the game combines them, which is how people end up with a world they cannot describe.

##### Journey mode permissions on a server

Journey mode on a multiplayer server is not a free-for-all. Each of its powers has its own permission setting, with three values: `0` locked for everyone, `1` only the host can change it, `2` anyone can change it.

```properties
journeypermission_time_setfrozen=1
journeypermission_time_setdawn=2
journeypermission_time_setnoon=2
journeypermission_time_setdusk=2
journeypermission_time_setmidnight=2
journeypermission_godmode=0
journeypermission_wind_setstrength=1
journeypermission_rain_setstrength=1
journeypermission_time_setspeed=1
journeypermission_rain_setfrozen=1
journeypermission_wind_setfrozen=1
journeypermission_increaseplacementrange=2
journeypermission_setdifficulty=0
journeypermission_biomespread_setfrozen=0
journeypermission_setspawnrate=1
```

Every one of these defaults to `2` in the shipped example, which means on a stock journey server anybody can freeze time, turn on god mode, change the difficulty and stop biome spread. For a public server that is almost certainly not what you want. `journeypermission_setdifficulty` and `journeypermission_godmode` are the two to lock first.

#### Ports, passwords and connecting

| Port | Protocol | Purpose |
| --- | --- | --- |
| `7777` | TCP | Game traffic. The only port the server uses |

One port, and it is TCP, which makes Terraria the exception in a catalogue of UDP games. A UDP rule will not help you and a TCP rule is all you need. [Game server ports explained](https://www.renode.space/blog/game-server-ports-explained) covers why most games do the opposite.

There is no public server list and no query protocol, so nothing advertises your server anywhere. Players join through Multiplayer, then Join via IP, then the address, the port and the password in three separate prompts. A hostname works in that first box, so pointing an A record at the server and giving people a name instead of four numbers is worth the five minutes - [connecting a domain to a game server](https://www.renode.space/blog/connecting-a-domain-to-a-game-server) has the record to create.

The Steam route is different. Starting the server with `-steam` and `-lobby friends` lets your Steam friends join from the friends list without an address at all; `-lobby private` restricts it to invitations. That is convenient for a small group and irrelevant for a hosted server that people join by address.

Passwords are sent on connect and set in the config or at runtime. Keep them to letters, digits and hyphens - the config parser has no quoting, so a password with spaces or an equals sign in it will not be what you think it is.

#### Console commands

The vanilla server reads commands from standard input. This is the complete list.

| Command | What it does |
| --- | --- |
| `help` | Lists the commands |
| `playing` | Shows connected players |
| `clear` | Clears the console window |
| `save` | Saves the world |
| `exit` | Saves and shuts down |
| `exit-nosave` | Shuts down without saving |
| `kick <player>` | Kicks a player |
| `ban <player>` | Bans a player and writes the ban list |
| `password` | Prints the current password |
| `password <pass>` | Changes it |
| `motd` | Prints the message of the day |
| `motd <words>` | Changes it |
| `say <words>` | Sends a server message |
| `time` | Prints the in-game time |
| `dawn` | Sets time to dawn |
| `noon` | Sets time to noon |
| `dusk` | Sets time to dusk |
| `midnight` | Sets time to midnight |
| `settle` | Settles all water |
| `seed` | Prints the world seed |
| `port` | Prints the listening port |
| `maxplayers` | Prints the player limit |
| `version` | Prints the version |
| `fps` | Toggles the frame counter |

That is genuinely all of it. There is no operator concept, no whitelist, no teleport, no item command, no region protection and no way to undo griefing. `settle` is more useful than it looks - a flooded base after someone empties a bucket collection is a solved problem.

Note what is missing from the bottom of that list: nothing here restricts who can do what. A vanilla Terraria server trusts everybody who knows the password. If that is not acceptable, you need TShock.

#### TShock: accounts, groups and the commands vanilla lacks

TShock replaces `TerrariaServer` with a build that keeps the same game and adds a server framework: user accounts, groups and permissions, regions, a whitelist, item bans, logging, a plugin API and a REST interface. It is the standard answer for any Terraria server that is open to strangers.

First run prints a setup code in the console and writes it to `tshock/setup-code.txt`. Join the server with a normal client and claim it:

```text
/setup 12345678
/user add myname a-long-password owner
/login myname a-long-password
/setup
```

The first command grants temporary superadmin, the second creates a permanent account in the owner group, the third logs you into it, and the fourth closes setup mode so the code stops working. Do all four in one sitting; a server left in setup mode is a server anyone can take over.

Configuration is `tshock/config.json`. From TShock 4.4 onwards the keys live inside a `Settings` object, and names have moved between major versions, so read the file you have rather than a guide written for an older one. The ones people change first:

| Key | What it does |
| --- | --- |
| `ServerPort` | Port, overriding the Terraria config |
| `MaxSlots` | Player limit |
| `ServerPassword` | Join password |
| `EnableWhitelist` | Enforces `tshock/whitelist.txt` |
| `DisableBuild` | Read-only world, for a showcase or a museum |
| `PvPMode` | `normal`, `always`, `disabled` or `pvpwithnoteam` |
| `AutoSave` | Periodic world saves |
| `BackupInterval` | Minutes between backups, `0` is off |
| `BackupKeepFor` | Minutes to keep them |
| `RestApiEnabled` | Turns on the HTTP admin interface |
| `RestApiPort` | Which port it listens on, `7878` by default |
| `StorageType` | `sqlite` by default, or a database |

Groups are the point of TShock. Out of the box there is a ladder from guest through default, vip and the admin tiers up to owner, each with a permission list, and `/group addperm` and `/user group` move people around it. Everyday admin then looks like `/kick`, `/ban add`, `/mute`, `/tp`, `/spawn`, `/butcher`, `/time day`, `/region define`, `/save` and `/off`. Server-side characters can be turned on so that inventories live on the server instead of on each player's machine, which is the only real defence against people arriving with items from a cheated single-player world.

> [!WARNING]
> The REST API is an HTTP admin interface with a token. If you enable it, do not leave its port open to the internet - anything that can reach it can run admin commands. The reasoning is the same as for any remote admin channel, and [firewall rules that matter](https://www.renode.space/blog/firewall-rules-that-matter) covers how to think about which ports are actually exposed.

The cost of TShock is the update lag. It has to be rebuilt for each Terraria release, so after a patch you wait days or weeks while your players have already auto-updated. Plan for that before a big content update rather than during one.

#### Worlds, backups and rollbacks

A Terraria world is a single `.wld` file, typically a few megabytes on a small world and tens of megabytes on a large hardmode one. That makes backups trivial and losing a world equally trivial. The server keeps rolling copies according to `worldrollbackstokeep`, and writes a `.bak` beside the world, both on the same disk as the original.

- **Stop the server properly.** `exit` saves and shuts down. `exit-nosave` does not, and neither does killing the process. Anything built since the last save is gone.
- **Save before you copy.** Copying a `.wld` while the server is running gives you a file mid-write. Run `save`, wait for the confirmation, then copy.
- **Keep copies off the machine.** Rolling backups protect you from a bad decision, not from a lost server. On RE:NODE the backup slots on every Terraria plan are stored off the machine they protect and restore with a button, and the Schedules tab can take a nightly one on a cron expression. [Backups that actually restore](https://www.renode.space/blog/backups-that-actually-restore) explains why untested backups are not backups.
- **Back up before hardmode.** Breaking an altar changes the world permanently and generates new biome stripes. It is the single most requested rollback in Terraria.

On a vanilla server, characters are not the server's problem: each player's inventory lives on their own machine, which is why a character can carry gear between worlds and why you cannot stop someone arriving fully equipped. TShock's server-side characters change that, and it is the main reason public servers run it.

#### Troubleshooting

**The server starts and then does nothing.** It is in the interactive wizard waiting for a keystroke. Add `-config serverconfig.txt`, and check that the path in `world` exists.

**"Lost connection" the moment somebody joins.** Version mismatch. The client auto-updated and the server did not. Check the exact build numbers, including the fourth digit.

**Nobody outside the network can connect.** TCP `7777` is not open, or the address is wrong. Terraria has no query port, so there is no second thing to test - if the port is open and the process is listening, it works.

**The password is rejected even though it is right.** A space, a quote or an equals sign in the config value. Simplify the password and restart.

**The world reverted a few hours.** The process was stopped without a save. Use `exit`, and if the server is being restarted on a schedule, make sure the schedule sends a clean stop rather than a kill.

**Enemies teleport around during invasions.** That is `npcstream` doing its job at the default of `60`. Lower it to `30` if you have bandwidth to spare, or accept it; the alternative is more data per player.

**TShock commands do nothing.** You are not logged in. Accounts are separate from characters, so `/login` after every join unless the group has been granted automatic login.

#### FAQ

##### How many players can a Terraria server hold?

`maxplayers` allows up to 255 and the honest answer is far fewer. Eight to sixteen is a normal group; past that, invasions and boss fights are what breaks, not the player count itself, because the server updates every NPC and projectile on one thread.

##### Can I change the world difficulty after creating it?

No. Classic, expert, master and journey are fixed at world generation. Changing `difficulty` in the config afterwards affects the next world you create, not the one already in the file.

##### Does a Terraria server need UDP ports?

No. Terraria is TCP on a single port, `7777` by default. That is unusual for a game and it is the reason half the firewall advice you will find for other games does not apply.

##### Do I need TShock?

Only if you need permissions, protection or plugins. For a password-protected server among friends, vanilla is simpler, updates the day the game does, and has nothing extra to break. For anything public, the vanilla server's lack of any permission system makes TShock close to mandatory.

##### Where are the world files?

Wherever `worldpath` points. The defaults are the Terraria folder under Documents on Windows and under the user's local share directory on Linux. On a panel they are in the server's own file tree, where the file manager and SFTP can reach them.

##### Can I move a single-player world onto the server?

Yes, and it is a straight file copy. Stop the server, upload the `.wld` file into the world folder, point `world` at it with the exact file name, and start. Your character comes with you separately, because characters are stored on each player's machine.

Terraria servers on RE:NODE start from $3 a month with the world generated on the first boot and the size and difficulty picked from the Startup tab. The port is allocated for you, the file manager and SFTP reach the world files directly, and backup slots are included on every plan so the copy you take before breaking an altar is one click.

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

---

### Terraria and tModLoader server setup

Published 2026-08-14, updated 2026-09-21 by RE:NODE Team. https://www.renode.space/blog/terraria-and-tmodloader-server

A vanilla Terraria server is one of the lightest things you can run: a large world with eight players sits comfortably inside a gigabyte, uses one TCP port, and has no server browser to register with. tModLoader is a different animal, because every mod is loaded into the same process and some of them are not shy about it. A Calamity-sized list wants 4 GB, and it wants most of that during world generation rather than during play - which is why the first world people make on an undersized plan is the one that fails. This guide covers both: installing each, every `serverconfig.txt` setting worth changing, the console commands, how mods are matched between server and client, and how not to lose a world that lives in a single file.

#### Vanilla, tModLoader or TShock: which server you are running

Three different programs answer to "Terraria server", and they are not interchangeable.

- **The vanilla dedicated server** ships with the game. It is `TerrariaServer.exe` on Windows and `TerrariaServer.bin.x86_64` on Linux, and there is no separate free Steam app for it - you copy it out of your own game install, or download the Dedicated Server package from the official terraria.org release page. It runs unmodified worlds and unmodified clients.
- **tModLoader** is a free, separate application (Steam app id `1281930`, also published on GitHub releases) that wraps the game and loads `.tmod` files. Its server is `start-tModLoaderServer.sh` or the matching `.bat`. Clients must run tModLoader too, at the same version.
- **TShock** replaces the vanilla server with one that adds groups and permissions, region protection, server-side characters, a database and a large command set. Players still run unmodified Terraria, which is its main appeal. It does not load tModLoader mods, so you pick one or the other.

tModLoader tracks a specific Terraria version and a mod built for one tModLoader release will not load on another. That version lock is the root of most tModLoader problems, and it is why a server should pin its version rather than take every update the day it lands.

#### Requirements and resource usage

Size for world generation, not for the steady state.

| Setup | RAM | CPU | Disk |
| --- | --- | --- | --- |
| Vanilla, small or medium world, 2-4 players | 512 MB - 1 GB | 0.5 core | 5 GB |
| Vanilla, large world, 8-16 players | 1-2 GB | 1 core | 10 GB |
| tModLoader, a handful of quality-of-life mods | 2-3 GB | 1 core | 15 GB |
| tModLoader, Calamity plus the usual companions | 4 GB | 1-1.5 cores | 20 GB |
| tModLoader, large content pack with generated structures | 6 GB peak | 1.5-2 cores | 30 GB |

- **The peak is world generation.** A big modded world is built in memory before it is written, and that moment is the high-water mark for the whole life of the server. A plan that runs the finished world perfectly can still fail to create it.
- **CPU**: the world update is one thread. Clock speed matters, core count barely does. Vanilla will not trouble half a core; a heavy mod list with hundreds of custom NPCs will use a full one.
- **Disk**: the vanilla server itself is tiny. A large world file is tens of megabytes; tModLoader adds a second file of mod data beside it that can be larger than the world. Neither is a reason to buy disk, but a rotating backup set of both is.
- **Network**: modest, and mostly spent on world sections. Terraria streams the tiles around each player the first time they visit an area, so eight players spread across a large world cost far more than eight players in one base.

#### Installing and starting a vanilla server

On Linux, from the extracted Dedicated Server package:

```bash
$ cd /home/terraria/server/Linux
$ chmod +x TerrariaServer.bin.x86_64
$ ./TerrariaServer.bin.x86_64 -config serverconfig.txt
```

Without `-config`, the server asks its questions interactively: which world, or which size and difficulty to generate, then the port, the maximum players and the password. That interactive path is fine once. For anything you will restart, use the config file, because a server that stops with an unanswered prompt does not come back.

Steam lobbies are also supported, with `-steam` and `-lobby friends` or `-lobby private`, which lets people join through the Steam friends list rather than by address. On a rented server you almost always want the plain address route instead.

#### serverconfig.txt: the settings that matter

`serverconfig.txt` is one `key=value` per line, with `#` starting a comment. The file that ships with the server is already documented; these are the lines that change behaviour.

serverconfig.txt:

```properties
world=/home/terraria/.local/share/Terraria/Worlds/Midgard.wld
worldpath=/home/terraria/.local/share/Terraria/Worlds/
autocreate=3
worldname=Midgard
difficulty=1
seed=
maxplayers=10
port=7777
password=herring-barrel
motd=Welcome. Rules are in the Discord.
banlist=banlist.txt
secure=1
language=en/US
upnp=0
npcstream=60
priority=1
```

| Key | Default | What it does |
| --- | --- | --- |
| `world` | - | Full path to the `.wld` to load. Takes priority over `autocreate` |
| `worldpath` | platform default | Where worlds are stored and created |
| `autocreate` | - | `1` small, `2` medium, `3` large. Only used if `world` is missing |
| `worldname` | `World` | Name of a world being created |
| `difficulty` | `0` | `0` classic, `1` expert, `2` master, `3` journey |
| `seed` | random | World seed, including the special seeds |
| `maxplayers` | `8` | Hard maximum is 255. Playable is nothing like that |
| `port` | `7777` | TCP, and the only port the server needs |
| `password` | empty | Join password |
| `motd` | - | Printed to each player on join |
| `banlist` | `banlist.txt` | File of banned players |
| `secure` | `0` | Extra cheat protection. Turn it on |
| `upnp` | `1` | Port mapping on a home router. Set `0` on a hosted server |
| `npcstream` | `60` | Lower means less enemy skipping and more bandwidth |
| `priority` | `1` | Process priority, `0` realtime to `5` idle |

Two of these catch people. `world` and `autocreate` are mutually exclusive in effect: if `world` points at a file that exists, that world loads and `autocreate` is ignored; if it points at a file that does not exist, the server creates one with the `autocreate` size and the `worldname`, which is how a group silently ends up playing on a brand new map after a path typo. And `difficulty` in this file is world difficulty - journey mode worlds can only be joined by journey characters, so a `difficulty=3` server excludes everyone's existing character.

Journey worlds also read a set of `journeypermission_` keys that decide which of the power menu's controls each player may use. They only apply on a journey world, and they are the difference between a shared sandbox and one person freezing time for everybody.

#### Ports and connecting

| Port | Protocol | Purpose |
| --- | --- | --- |
| `7777` | TCP | Everything |

Terraria is one of the few multiplayer games that runs on TCP rather than UDP, which matters the moment you write a firewall rule or ask a host what to open. A UDP rule for 7777 does nothing here. [TCP vs UDP for game servers](https://www.renode.space/blog/tcp-vs-udp-for-game-servers) explains why almost every other game went the other way and what the trade is.

There is also no server browser and no query port. Players open Multiplayer, then Join via IP, and type the address and port. That is the whole discovery mechanism, so the address is something you hand out rather than something people find. If you would rather give out a name than a number, [connecting a domain to a game server](https://www.renode.space/blog/connecting-a-domain-to-a-game-server) covers the A record, and Terraria is one of the easiest cases because the port is fixed and visible.

Crossplay does not exist. Mobile and console Terraria are a separate multiplayer ecosystem and cannot join a PC dedicated server, whatever the version numbers suggest.

#### Console commands

The server console accepts a short list of commands, typed directly into the running process:

| Command | What it does |
| --- | --- |
| `help` | Lists the commands |
| `playing` | Connected players |
| `say <text>` | Speak as the server |
| `motd` | Print the current message of the day |
| `password <text>` | Change the join password live |
| `kick <player>` | Disconnect a player |
| `ban <player>` | Disconnect and add to the ban list |
| `save` | Write the world immediately |
| `exit` | Save and shut down |
| `exit-nosave` | Shut down without saving |
| `settle` | Force all liquids to settle |
| `time`, `dawn`, `noon`, `dusk`, `midnight` | Read and set the clock |
| `seed` | Print the world seed |

`settle` is the one worth remembering. A large flooded area with water still moving is one of the few things that will genuinely drag a Terraria server, and settling it is instant. `exit-nosave` is the one worth fearing: it does exactly what it says, and there is no confirmation.

The server autosaves roughly every ten minutes and on a clean `exit`. Anything that kills the process instead - an out-of-memory stop, a host reboot, the panel's Kill button - loses whatever happened since the last write.

#### tModLoader on a dedicated server

Install tModLoader from its GitHub release or from Steam, then start the server script rather than the game binary:

```bash
$ cd /home/terraria/tmodloader
$ ./start-tModLoaderServer.sh -config serverconfig.txt
```

Mods are `.tmod` files. On a server they go in the `Mods` folder inside the tModLoader save directory, alongside an `enabled.json` that lists the internal names of the ones to load:

Mods/enabled.json:

```json
[
  "CalamityMod",
  "CalamityModMusic",
  "MagicStorage",
  "BossChecklist",
  "RecipeBrowser"
]
```

The internal name is not the display name. It is the mod's folder name inside the `.tmod`, and getting it wrong means the mod is quietly not loaded rather than an error. The reliable way to get it right is to enable the mods once in a local tModLoader client, then copy that client's `enabled.json` and `Mods` folder up to the server over SFTP - [SFTP and the file manager](https://www.renode.space/blog/sftp-and-the-file-manager) has the connection details.

Every mod declares which side it belongs on, and this is the part that decides who has to install what:

- **Both** - the default. Server and every client need it, at the same version. Content mods, boss mods, anything that changes the game.
- **Client** - interface and quality-of-life mods. The server neither has nor cares about them.
- **Server** - runs on the server alone; clients need nothing.
- **NoSync** - loadable on either side and not checked at all.

tModLoader offers joining clients a download of the server's synced mods, which removes most of the "install this list first" friction. It does not remove the version problem: a client that already has a different version of a mod has to update or downgrade to match, and the message it shows does not always make that obvious.

> [!WARNING]
> Adding or removing a content mod on an existing world is a one-way trip. Removing a mod deletes every item, NPC and tile it owned, from chests and from the map, the next time the world saves. Copy the world files before you touch the mod list, every time.

#### Worlds, saves and the backup habit

A vanilla world is one file: `Midgard.wld`, with `Midgard.wld.bak` beside it holding the previous save. tModLoader adds `Midgard.twld` for mod data, and `Midgard.twld.bak`. Both files belong together - a `.wld` restored without its matching `.twld` loads as a world where every modded item and tile has vanished.

| Platform | Vanilla worlds | tModLoader worlds |
| --- | --- | --- |
| Windows | `Documents\My Games\Terraria\Worlds\` | `...\Terraria\tModLoader\Worlds\` |
| Linux | `~/.local/share/Terraria/Worlds/` | `~/.local/share/Terraria/tModLoader/Worlds/` |

The whole world being a single file makes backups trivial and makes losing one trivial too. The `.bak` file is not a backup: it is the previous save, on the same disk, overwritten every ten minutes. A real backup is a copy somewhere else, on a schedule, that you have restored at least once - [backups that actually restore](https://www.renode.space/blog/backups-that-actually-restore) makes the case better than another paragraph here would, and [testing a restore before you need it](https://www.renode.space/blog/testing-a-restore-before-you-need-it) is the ten minutes that proves it.

Characters are not on the server. A `.plr` file lives on each player's machine, which is why your inventory survives a move between servers and why a vanilla server cannot stop somebody arriving with a full set of endgame gear. TShock's server-side characters are the only way to change that, and they are the main reason large public servers run TShock.

On RE:NODE the Terraria plans include two backup slots, the panel takes them on demand or on a schedule, and restoring one is a button rather than a ticket. The Schedules tab can also run a `save` command before the backup task, which is worth doing - a backup taken mid-interval is a backup of the last save, not of now.

#### Performance and what actually causes lag

Terraria rarely runs out of CPU. When it does, it is nearly always one of four things:

1. **Unsettled liquids.** A large pumping or flooding project keeps thousands of tiles updating. `settle` fixes it in seconds.
2. **Item entities on the ground.** Thousands of dropped items from a farm are each an entity being synchronised. They despawn eventually; a restart clears them instantly.
3. **Wiring and statue farms.** Timers firing hundreds of times a second across a large contraption cost real time on the world thread.
4. **A specific mod.** In tModLoader, the answer to "the server got slow after Tuesday" is the mod you added on Tuesday. Remove one at a time.

What is not usually the problem is player count. Terraria's engine copes with far more players than the game is fun with; the practical ceiling is social and about the world being shared, not technical. [How many players fit on a server](https://www.renode.space/blog/how-many-players-fit-on-a-server) covers the general version of that question. If you do raise `maxplayers` past the default eight, raise memory with it rather than hoping.

#### Troubleshooting

**The server created a new world instead of loading ours.** The `world` path is wrong, or the file name does not match exactly including capitals. The original `.wld` is still where it was; fix the path and restart.

**Players cannot connect but the server is running.** Port `7777` is open for UDP and not TCP, or `upnp=1` on a hosted server has confused things. Set `upnp=0`.

**"You do not have the same mods as the server."** Version mismatch, not a missing mod. Compare the tModLoader version first, then each mod's version. A mod updated for one player and not the others produces exactly this.

**World generation hangs or the server is killed while creating a world.** Memory. Generation peaks well above the running figure, especially with mods that add structures. Generate the world on a plan with headroom, or generate it locally and upload it.

**Modded items vanished from every chest.** A mod was removed, or the `.twld` was lost while the `.wld` survived. Restore both files together from before the change.

**The server freezes for a second every few minutes.** That is the autosave. On a large modded world it is noticeable and there is no setting to remove it - faster storage makes it shorter.

**Memory climbs all week.** Normal to a point, and a scheduled weekly restart keeps it flat. If it climbs fast enough to hit the limit in a day, it is a mod.

#### FAQ

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

A gigabyte is plenty for vanilla with a large world and a full group. tModLoader is the question that matters: two to three gigabytes for a light mod list, four for a Calamity-sized one, and six if the pack generates its own structures, because world creation peaks far above the running figure.

##### Do players need to install mods before joining a tModLoader server?

Usually not. tModLoader offers a joining client the server's synced mods as a download. They do need tModLoader itself at the same version, and a client that already holds a different version of one of those mods has to change it rather than download over it.

##### Can console or mobile players join a PC Terraria server?

No. The console and mobile versions form their own multiplayer ecosystem and cannot connect to a PC dedicated server. There is no crossplay mode to enable.

##### Is TShock better than the vanilla server?

For a public server, yes - it adds permissions, region protection and server-side characters, which is the only real answer to people arriving with duplicated gear. For a private group on mods, no, because TShock does not run tModLoader mods.

##### Why does the world reset every time I restart?

It does not; you are loading a different world. Either `world` points at a path that does not exist and `autocreate` builds a new one each time, or `worldpath` differs from where the world you care about actually lives.

##### How many players can a Terraria server hold?

`maxplayers` accepts up to 255, and nothing about the game is designed for that. Sixteen is a busy server, eight is the default for a reason, and past about twenty-five the shared world stops making sense long before the process struggles.

Terraria servers on RE:NODE start at $3 a month with one port allocation, which is all Terraria needs, and run up to 4 GB for a heavy tModLoader list. Backup slots are on every plan, the in-browser file manager unpacks an uploaded mod archive in place, and the Schedules tab can run a `save` before each backup so the copy is current.

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

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