# Team Fortress 2 Server Hosting - everything RE:NODE has published

> A Team Fortress 2 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/team-fortress-2, 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/team-fortress-2.

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

## What it is

Team Fortress 2 servers on every mode -- Capture the Flag, Payload, Control Point, King of the Hill. RCON password generated for you, SourceTV ready.

- Genres: Action, Free To Play
- Developer: Valve
- Released: 10 Oct, 2007
- Steam: https://store.steampowered.com/app/440/

### What comes with every Team Fortress 2 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 Team Fortress 2 server on the internet.
- The real console: Live output, command input and the server's own logs - not a filtered summary. Web-server noise is folded behind a counter you can switch off.
- Files and SFTP: A full file manager with an editor, plus SFTP credentials. Upload mods, edit configs, pull a world down to your machine.
- 2-2 backup slots: Taken on demand or on a schedule, restored with a button. Deleting a server takes its backups with it, on purpose.
- 3 ports allocated: Add and remove ports yourself from the Network tab, including the query and RCON ports where the game wants them.
- People on the same server: Invite friends or staff with granular permissions - console only, files only, no billing - through subusers, roles and teams.

### Which Team Fortress 2 plan do you need?

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

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

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

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

### General questions

### Getting started

**How quickly is my server ready?**

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

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

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

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

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

**Can I try before buying?**

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

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

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

### Running the server

**Do I get full file access?**

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

**Can I install mods and plugins?**

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

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

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

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

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

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

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

### Backups and safety

**Are backups included?**

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

**Where are backups stored?**

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

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

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

### Billing

**How do I pay?**

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

**Can I pay in Georgian lari?**

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

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

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

**Can I upgrade or downgrade later?**

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

**Do you offer refunds?**

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

### Support and the honest bits

**How do I get help?**

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

**Where are the servers?**

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

**Is there an uptime guarantee?**

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

**Who actually runs this?**

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

## Plans and prices

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

| Plan | Price / month | Memory | CPU | NVMe disk | Databases | Backups | Ports |
|---|---|---|---|---|---|---|---|
| Starter | $6 | 2 GB | 1 vCPU | 30 GB | 1 | 2 | 3 |
| Standard | $9 | 3 GB | 1.5 vCPU | 35 GB | 1 | 2 | 3 |
| Advanced | $12 | 4 GB | 2 vCPU | 40 GB | 1 | 2 | 3 |
| Pro | $16 | 5 GB | 2.5 vCPU | 50 GB | 1 | 2 | 3 |
| Premium | $20 | 6 GB | 3 vCPU | 60 GB | 1 | 2 | 3 |


## Panel how-to

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

### Ordering a server

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

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

Open the shop and find what you want to run:

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

Compare the plans and pick one:

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

Choose how long, then pay:

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

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

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

After you pay:

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

### The console

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

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

### Files and SFTP

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

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

### Backups

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

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

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

### Subusers, roles and teams

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

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

### Scheduled tasks

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

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

### Games that need a key from you

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

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

## Tutorials

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

- [TF2 Mann vs Machine and community modes](https://www.renode.space/blog/team-fortress-2-mvm-and-community-modes) (2026-10-07): Run Mann vs Machine on a TF2 server: slots, missions and pop files, custom waves, plus Valve's other modes and community favourites like VSH, dodgeball and MGE.
- [Team Fortress 2 SourceMod plugins](https://www.renode.space/blog/team-fortress-2-sourcemod-plugins) (2026-09-21): Installing Metamod:Source and SourceMod on a TF2 server, admins and flags, the plugins worth running, map votes, sv_pure and fast downloads.
- [Team Fortress 2 server setup and config](https://www.renode.space/blog/team-fortress-2-server) (2026-07-10): Installing a TF2 dedicated server: SteamCMD and the GSLT, server.cfg, map cycles and custom maps, SourceTV, SourceMod admins, and keeping it populated.

---

### TF2 Mann vs Machine and community modes

Published 2026-10-07 by RE:NODE Team. https://www.renode.space/blog/team-fortress-2-mvm-and-community-modes

Mann vs Machine runs on a normal Team Fortress 2 dedicated server: start it on an `mvm_` map with `-maxplayers 32`, and six human defenders play against waves of robot bots driven by a mission file. Missions are `.pop` files in `tf/scripts/population/`, chosen with `tf_mvm_popfile`, and community servers can write their own. What a community server cannot do is Mann Up: tickets, tours of duty and the loot drops are tied to Valve's official matchmaking. Every other TF2 mode works the same way - the map prefix picks the mode, a few `tf_` cvars change it, and the popular community modes (Versus Saxton Hale, dodgeball, MGE, prop hunt, jump) are SourceMod plugins or specially built maps on top. This guide covers MvM end to end, then the rest of the mode catalogue and what each one needs from a server.

#### How TF2 picks a game mode

TF2 does not have a game mode setting. The map decides. When a map loads, the game reads the entities inside it - capture points, flags, payload carts, an MvM bomb - and runs the matching rules. The map prefix is a naming convention that tells humans what to expect.

| Prefix | Mode | Notes |
| --- | --- | --- |
| `ctf_` | Capture the Flag | Also Mannpower with `tf_powerup_mode 1` |
| `cp_` | Control Points | 5CP, attack/defend and medieval maps |
| `pl_` | Payload | One cart, attack/defend |
| `plr_` | Payload Race | Two carts racing |
| `koth_` | King of the Hill | One point, timers per team |
| `arena_` | Arena | One life per round |
| `sd_` | Special Delivery | Neutral flag to a rocket |
| `pass_` | PASS Time | Ball game |
| `rd_` / `pd_` | Robot / Player Destruction | Collect and score |
| `tc_` | Territorial Control | Rotating point pairs |
| `mvm_` | Mann vs Machine | Co-op against robot waves |

That means a server's mode is its map list. A payload server is a server whose `mapcycle.txt` holds only `pl_` maps; a mixed server alternates. The setup basics - SteamCMD, the token, `server.cfg` and the map cycle - are in [the Team Fortress 2 server guide](https://www.renode.space/blog/team-fortress-2-server); this post assumes that part works.

#### Mann vs Machine: what the server needs

MvM is the one mode with genuinely different server requirements, because the robots are real bot players.

- **Slots.** The robots occupy player slots. Six human defenders plus the robot waves need far more than six slots, which is why MvM servers are started with `-maxplayers 32`. Starting with fewer slots caps how many robots can be alive at once and breaks missions designed for more.
- **Six humans maximum.** The defending team is capped at six. Extra humans join as spectators.
- **An `mvm_` map and a mission.** Each map ships with one or more `.pop` mission files. Without a valid mission the map loads and nothing spawns.
- **Navigation meshes.** Robots path using the map's `.nav` file in `tf/maps/`. Valve's MvM maps ship with them; custom MvM maps must include one, or the robots stand still.
- **CPU.** Twenty-odd bots pathing, shooting and using abilities cost far more than six humans. MvM is the heaviest stock TF2 mode per human player.

```bash
$ ./srcds_run -game tf -console -port 27015 -maxplayers 32 \
    +sv_setsteamaccount <token> +map mvm_coaltown
```

| Setup | RAM | CPU | Notes |
| --- | --- | --- | --- |
| Valve missions, 6 players | 2-3 GB | 1.5-2 cores | Late waves with many robots are the peak |
| Custom missions, 6 players | 3-4 GB | 2+ cores | Custom robots and bigger waves |
| MvM plus SourceMod plugins | add 0.5 GB | add some | Depends on plugins |

On RE:NODE, Team Fortress 2 plans start at 2 GB with three port allocations, so the game and SourceTV each have their own number. A Valve-mission MvM server fits the lower tiers; a server built around custom missions belongs a tier or two higher, and the CPU graph against the plan's limit during the final wave is the honest test. [CPU vs RAM for game servers](https://www.renode.space/blog/cpu-vs-ram-for-game-servers) explains how to read that.

#### Missions and pop files

A mission is a population file: a KeyValues text file that defines the starting money, the waves, which robots appear in each wave, how many, where they spawn and what they carry. Valve's files are in `tf/scripts/population/` inside the game's VPKs, and community ones are loose files in the same folder.

```text
tf/scripts/population/
  mvm_coaltown.pop               normal difficulty
  mvm_coaltown_advanced.pop      advanced
  mvm_coaltown_expert.pop        expert
  robot_standard.pop             shared robot templates
  robot_giant.pop
```

Changing mission is a console command on a running `mvm_` map:

```text
changelevel mvm_coaltown
tf_mvm_popfile mvm_coaltown_advanced
```

`tf_mvm_popfile` takes the file name without `.pop` and restarts the mission. Players can also vote for a different mission from the vote menu if votes are allowed. Valve's official maps are `mvm_coaltown`, `mvm_decoy`, `mvm_mannworks`, `mvm_bigrock`, `mvm_rottenburg`, `mvm_mannhattan` and the Halloween `mvm_ghost_town`; the exact list of missions per map depends on the game version.

##### Writing or installing custom missions

Custom missions are the reason most community MvM servers exist. A custom `.pop` file reuses the shared robot templates and adds its own: different weapons, attributes, health, abilities and wave structures. Installing one is a file copy - the `.pop` into `tf/scripts/population/`, plus any custom map, its `.nav` file and any custom content the mission needs.

The shape of a mission file is easier to understand from a small one. This is a single wave of twenty scouts, at most eight alive at once, spawning four at a time:

tf/scripts/population/mvm_coaltown_test.pop:

```text
#base robot_standard.pop

WaveSchedule
{
	StartingCurrency	800
	RespawnWaveTime	6
	CanBotsAttackWhileInSpawnRoom	no

	Wave
	{
		WaveSpawn
		{
			Where	spawnbot
			TotalCount	20
			MaxActive	8
			SpawnCount	4
			WaitBeforeStarting	0
			WaitBetweenSpawns	5
			TotalCurrency	200
			TFBot
			{
				Class	Scout
				Skill	Normal
			}
		}
	}
}
```

`StartingCurrency` is the money players have before wave one, `TotalCurrency` is what that wave drops in total, and `MaxActive` is the number that decides how hard the server works - it is the cap on live robots from that spawn. `Where` names a spawn point in the map, and the names differ between maps, so copy them from the map's own Valve mission. Real missions also fire the map's relays at wave start and end for doors and announcements; open Valve's `.pop` for the same map to see which ones it uses. Load the file with `tf_mvm_popfile mvm_coaltown_test` and play the wave alone before showing it to anyone.

A few things to know before you go down this route:

- **Players need the content.** A custom map must be downloadable, which on TF2 means FastDL. Mission files themselves stay on the server.
- **Templates are powerful and fragile.** A robot with a misspelled attribute is not an error; it is a robot with that attribute silently missing. Test each wave alone with a friend before opening it.
- **Some custom missions depend on plugins.** Large community MvM projects extend robots with SourceMod plugins for behaviour the pop format cannot express. Check what a mission pack requires before installing it.
- **Difficulty creep.** It is easy to write a mission that is impossible with six players. Balance against your real player count.

> [!NOTE]
> Community MvM servers never award Mann Up loot, Tour of Duty progress or Australium. That is tied to Valve's official servers and tickets. Players come to community MvM for custom missions, different upgrades and good company - say so in the server name so nobody joins expecting drops.

#### Valve's other modes and the cvars that change them

Most stock modes need nothing beyond the right maps. A few have switches worth knowing:

| Cvar | Mode | What it does |
| --- | --- | --- |
| `tf_powerup_mode 1` | Mannpower | Grappling hooks and powerup runes on `ctf_` maps built for it |
| `tf_medieval 1` | Medieval | Melee and a few ranged weapons only |
| `tf_medieval_autorp 1` | Medieval | Rewrites chat into mock-medieval phrasing |
| `tf_arena_use_queue 1` | Arena | Queues players who cannot fit in a round |
| `tf_arena_first_blood 1` | Arena | Crit bonus for the first kill |
| `tf_weapon_criticals 0` | All | Disables random crits |
| `tf_use_fixed_weaponspreads 1` | All | Fixed shotgun spread pattern |
| `mp_timelimit` | All | Minutes per map |
| `mp_winlimit` | All | Rounds won before the map ends |

The last four are the ones community servers argue about. `tf_weapon_criticals 0` and `tf_use_fixed_weaponspreads 1` are the "no random crits, no random spread" pair that many community servers advertise in their names, and they are the closest thing TF2 has to a competitive ruleset outside a league config.

Valve has also adopted some community modes into the game in recent updates - Versus Saxton Hale and Zombie Infection among them - with their own map prefixes. The official versions work on a plain server with the official maps; the plugin-driven community versions still exist and differ in detail.

#### Community modes: plugins and maps

Everything else is SourceMod on top of a normal TF2 server. [TF2 SourceMod plugins](https://www.renode.space/blog/team-fortress-2-sourcemod-plugins) covers installing Metamod:Source and SourceMod and setting up admins; the modes below assume that is done.

| Mode | What it is | Built from |
| --- | --- | --- |
| Versus Saxton Hale / Freak Fortress 2 | Everyone against one boss player | Plugin, plus boss packs for FF2 |
| Dodgeball | Homing rockets bounced by airblast | Plugin and `tfdb_` maps |
| MGE | 1v1 arenas for duel practice | Plugin and `mge_` maps |
| Prop Hunt | Hide as props, hunters search | Plugin and prop hunt maps |
| Jump | Rocket and sticky jump courses | `jump_` maps, plugins for regen and saves |
| Surf | Momentum surfing | `surf_` maps, usually with a timer plugin |
| Jailbreak | Guards and prisoners with a warden | Plugin and `jb_` maps |
| x10 | Weapon stats multiplied by ten | Plugin and attribute tools |
| Slender Fortress | Co-op horror | Plugin, models and maps |

##### The three modes people ask for first

**Versus Saxton Hale and Freak Fortress 2.** One player becomes a boss with a huge health pool scaled to the number of opponents; everyone else tries to kill them before the round timer or the boss kills everyone. VSH has one boss and a fixed ruleset; Freak Fortress 2 is the extended version with boss packs - each boss a config, a model, sounds and abilities. FF2 servers are content-heavy, so FastDL is not optional, and a pack of thirty bosses is thirty sets of downloads. Start with a handful.

**Dodgeball.** Homing rockets spawn and target a player, who has to airblast them back as Pyro. Rockets speed up with each deflection until somebody misses. The plugin forces everyone to Pyro and spawns rockets on `tfdb_` maps; the config sets rocket speed, turn rate and how much each deflection adds. It is one of the cheapest modes to host - few players alive, one or two projectiles - and one of the stickiest for regulars.

**MGE.** A map of small arenas where players queue for 1v1 duels, scored by an Elo-style rating that the plugin stores in a database. It is how competitive players practise their class away from a full team, and it needs very little: the plugin, `mge_` maps and a database for ratings. Each game plan on RE:NODE comes with a database slot whose credentials are generated in the panel - check the plugin supports its engine, or use the local SQLite option that most SourceMod plugins offer.

Three practical rules apply to all of them:

1. **One mode per server.** Each of these plugins assumes it owns the rules. Running dodgeball and VSH on one server with a map vote between them is how you get bosses with homing rockets.
2. **Check the plugin's dependencies.** Many community modes depend on extensions such as TF2Items, TF2Attributes or TF2 Econ Data. Since TF2 moved to 64-bit server binaries, every extension needs a 64-bit build; a mode that was fine in 2023 may not load until its dependencies were rebuilt. Check each project's page for a current build before installing.
3. **Expect custom content.** Boss models, sounds and maps all need to reach players. Set up FastDL before launch, not after the first player complains of missing textures.

```diagram
title: What decides the mode on a TF2 server
mapcycle = mapcycle.txt | which maps rotate
map = Map entities | pl_, koth_, mvm_
pop = Pop file | MvM missions only
sm = SourceMod | community modes
cvars = tf_ cvars | medieval, mannpower
rules = Round rules | what players get
mapcycle -> map
map -> rules : stock modes
pop -> rules : waves and robots
sm -> rules : overrides
cvars -> rules
```

#### Keeping a mode server populated

A community mode server lives or dies by having people on it at the time other people look. MvM is the easiest: six players is a full game, so a group of friends can fill it alone and strangers join the leftover slots. Dodgeball and MGE fill quickly from small numbers. VSH, prop hunt and jailbreak need twelve or more to be fun, which is a real commitment.

Things that help:

- **A clear server name.** Mode, rules and region: "MvM custom missions | DE", "Dodgeball | no randoms". Players filter the browser by words.
- **Tight map lists.** Five good maps beat thirty mediocre ones. A map vote that keeps offering broken custom maps empties the server.
- **Fast downloads.** Custom modes without FastDL lose half their joiners at the download screen.
- **Seed hours.** Pick a regular evening, invite your group, and let the browser do the rest. [Growing a game server community](https://www.renode.space/blog/growing-a-game-server-community) has more on this.

#### Performance and stability

Stock modes are light; MvM and plugin-heavy modes are not. The common causes of a struggling mode server are the same each time: too many bots in MvM, plugins that run timers every frame, extensions built for the wrong architecture, and memory that creeps over days. A scheduled restart at an empty hour solves the last one. On RE:NODE the Schedules tab runs that restart from a cron expression, and the console graph shows CPU and memory against the plan's limits so you can see a wave spike rather than guess at it. [Restart schedules that help](https://www.renode.space/blog/restart-schedules-that-help) covers how often is often enough.

When a TF2 update lands, mode servers break first. Metamod, SourceMod and every extension may need a new build; gamedata files go stale; plugins that read weapon attributes may misbehave. Take a backup before updating, and keep a vanilla fallback map cycle so the server can at least run stock maps while plugins catch up.

#### Troubleshooting

**MvM map loads but no robots spawn.** No valid mission, or not enough slots. Check `-maxplayers 32`, then set a mission with `tf_mvm_popfile`.

**Robots stand still or walk into walls.** The map's `.nav` file is missing or out of date. Custom MvM maps must ship one; do not try to generate one for an MvM map yourself unless you know the mission's spawn and path setup.

**"Bad population file" in the console.** A syntax error in a custom `.pop` file. KeyValues are brace-sensitive; the line number in the error is usually near the problem.

**A community mode plugin does not load after a TF2 update.** The 64-bit change or stale gamedata. Check `sm plugins list` and `sm exts list`, update the extension and its gamedata, and look in `addons/sourcemod/logs/` for the error.

**Players see missing textures and error models.** Custom content is not reaching clients. Set `sv_downloadurl` to a working FastDL host and check that every file is there in the same paths.

**The server is full but only six people are playing MvM.** That is correct - robots are using the other slots. Do not lower `-maxplayers` to "save" slots.

#### FAQ

##### Can I run Mann Up on my own server?

No. Mann Up tours, tickets and loot drops only work on Valve's official MvM servers. Community servers run the same maps and missions, plus custom ones, without those rewards.

##### How many slots does an MvM server need?

Start it with `-maxplayers 32`. Only six humans can defend, but robots are bot players and need slots of their own; fewer slots break missions built around large waves.

##### Where do MvM mission files go?

In `tf/scripts/population/` as `.pop` files. Load one with `tf_mvm_popfile <name>` on an `mvm_` map, without the `.pop` extension.

##### Do community modes like VSH need special maps?

Most do. Dodgeball needs `tfdb_` maps, MGE needs `mge_` arenas, jailbreak needs `jb_` maps. Versus Saxton Hale plays on boss-friendly maps, and Valve's official VSH has its own map set.

##### Why did my community mode stop working after an update?

TF2 updates often break SourceMod gamedata and extensions, and the move to 64-bit server binaries means old 32-bit extensions no longer load at all. Update SourceMod, the extensions and the plugin, in that order.

Team Fortress 2 servers on RE:NODE start at 2 GB with three port allocations, so SourceTV has a number of its own, and two backup slots for a known-good copy before every update. Custom missions, plugins and maps go in through the file manager or SFTP, with no list of what you are allowed to run.

[See TF2 plans](https://www.renode.space/game-servers/team-fortress-2)

---

### Team Fortress 2 SourceMod plugins

Published 2026-09-21 by RE:NODE Team. https://www.renode.space/blog/team-fortress-2-sourcemod-plugins

Everything people like about a Team Fortress 2 community server is a plugin. Admin commands, map votes, reserved slots, custom modes, stats, the thing that stops one person shouting into voice for an hour - none of it is in the game. It is Metamod:Source loading SourceMod, SourceMod loading a folder of compiled plugins, and about twenty minutes of configuration that most guides skip because they assume you already know it.

Two files decide whether it works: `tf/addons/metamod.vdf`, which tells the engine to load Metamod at startup, and `tf/addons/sourcemod/configs/admins_simple.ini`, which decides who you are. Get those right and the rest is choosing plugins. This post covers the install, the admin system in detail, the plugins that ship and the ones worth adding, the TF2 cvars that actually change something, custom content and downloads, and what breaks when Valve updates the game. [A Team Fortress 2 server worth joining](https://www.renode.space/blog/team-fortress-2-server) is the short version of why any of this matters.

#### What SourceMod is, and what runs it

SourceMod is a plugin platform for Source 1 games. Plugins are written in SourcePawn, compiled to `.smx` files, and dropped into a folder; SourceMod loads them, gives them an API for the game, and handles admin identity, translations, menus and database access so that each plugin does not have to. Metamod:Source sits underneath it as the loader that gets SourceMod into the game process in the first place.

TF2 is a Source 1 game, so all of this works properly, which is worth stating because Counter-Strike 2 is Source 2 and none of it works there at all. A SourcePawn plugin you find today will run on TF2 and will not run on CS2.

The server itself is Steam app `232250`, installed anonymously:

```bash
$ steamcmd +force_install_dir /home/tf2/server +login anonymous \
    +app_update 232250 validate +quit
$ cd /home/tf2/server
$ ./srcds_run -game tf -console -usercon -port 27015 \
    +maxplayers 24 +map cp_process_final \
    +sv_setsteamaccount YOUR_GSLT_TOKEN
```

| Setup | RAM | CPU | Disk |
| --- | --- | --- | --- |
| 12 slots, 6v6, a few plugins | 1-2 GB | 1 core | 30 GB |
| 24-32 slot public server, full plugin set | 2-3 GB | 1.5-2 cores | 30-40 GB |
| Versus Saxton Hale, Freak Fortress, custom modes | 3-4 GB | 2+ cores | 40 GB plus content |
| MvM with custom missions | 3-4 GB | 2+ cores | 40 GB plus content |

TF2 is unusual in that disk, not memory, is what a small plan runs out of first. The dedicated server install is upwards of 15 GB before you add a single custom map, and it grows with every update. Memory is modest: the game is old and well optimised, and a full 24-slot server is comfortable inside 2 GB unless a plugin is holding state for every player.

The `-usercon` flag enables RCON, and `sv_setsteamaccount` takes a Game Server Login Token, which is what registers the server with a Steam game server account for the public browser. It costs nothing to create and belongs to a Steam account you own - [Steam game server tokens explained](https://www.renode.space/blog/steam-game-server-tokens-gslt) covers making one and what gets one banned.

#### Installing Metamod:Source and SourceMod

```diagram
title: How a .smx plugin ends up inside TF2
srcds = TF2 server | srcds, Source 1
vdf = addons/metamod.vdf | loaded at startup
mm = Metamod:Source | addons/metamod
sm = SourceMod | a Metamod plugin
plugin = Your plugin | plugins/*.smx
srcds -> vdf : reads addons/
vdf -> mm
mm -> sm
sm -> plugin : loads on map start
```

1. Download Metamod:Source and SourceMod for the same branch. They are versioned together, and mixing a current SourceMod with an old Metamod is the first thing to check when nothing loads.
2. Unpack both so their `addons` folders land in `tf/`. You should end up with `tf/addons/metamod/` and `tf/addons/sourcemod/`.
3. Make sure `tf/addons/metamod.vdf` exists. It is a two-line file naming the Metamod binary, relative to the game root:

tf/addons/metamod.vdf:

```text
"Plugin"
{
	"file"	"../tf/addons/metamod/bin/server"
}
```

4. Restart the server and run `meta list`, then `sm version`.

The path in that VDF is the part people get wrong. It is relative to the directory above `tf`, which is why it starts with `../tf/`. Since TF2's move to 64-bit binaries, the server library lives in a `linuxsteamrt64` subfolder, so on a current install the path has that extra element and you need the Metamod and SourceMod builds that ship 64-bit binaries. If `meta list` produces nothing at all, this is almost always why: the right files, the wrong path, or 32-bit builds on a 64-bit server.

```text
tf/addons/sourcemod/
  configs/
    admins_simple.ini    admins, the simple way
    admins.cfg           admins, the grouped way
    admin_groups.cfg     groups and their flags
    admin_levels.cfg     what each flag letter means
    databases.cfg        database connections
    maplists.cfg         which map list each plugin uses
    core.cfg             SourceMod itself
  plugins/               .smx files that load
  plugins/disabled/      .smx files that do not
  extensions/            native extensions
  gamedata/              offsets and signatures per game
  logs/                  errors_YYYYMMDD.log
  scripting/             .sp sources and the compiler
tf/cfg/sourcemod/        generated per-plugin configs
```

Two of those folders explain most support questions. `plugins/disabled/` is where you move a plugin instead of deleting it, and `logs/errors_*.log` is where the reason it did not load is written in plain English, which the game console rarely manages.

#### Admins: the file, the flags, the immunity

The simple admin file is one line per person: an identity, then immunity and flags.

tf/addons/sourcemod/configs/admins_simple.ini:

```text
// "identity"          "immunity:flags"
"STEAM_0:1:123456"     "99:z"
"STEAM_0:0:987654"     "50:abcdefgj"
"STEAM_0:1:555555"     "20:bcj"
```

The number before the colon is immunity: a higher number cannot be kicked, banned or slain by a lower one. The letters after it are the flags.

| Flag | Grants |
| --- | --- |
| `a` | Reserved slot |
| `b` | Generic admin. Most plugins check this first |
| `c` | Kick |
| `d` | Ban |
| `e` | Unban |
| `f` | Slay and slap |
| `g` | Change map |
| `h` | Change cvars |
| `i` | Exec configs |
| `j` | Admin chat and messages |
| `k` | Start votes |
| `l` | Set the server password |
| `m` | RCON through SourceMod |
| `n` | Enable cheats |
| `o` to `t` | Custom, defined by individual plugins |
| `z` | Root. Everything, including flags that do not exist yet |

Give yourself `z`, give the people who run evenings `bcdefgj`, and give the person who joined last month `bcj`. The two flags to think twice about are `m` and `n`: `m` is RCON, which is the whole server, and `n` enables cheats, which on a public server is the end of the server.

Identities can be a SteamID, an IP address, or a name with a password, and SteamID is the only one that means anything. The format SourceMod wants is the one `status` prints in the console for a connected player, so paste rather than retype. `sm_reloadadmins` re-reads the file with no restart.

For a group with more than a handful of staff, `admin_groups.cfg` plus `admins.cfg` lets you define a "Moderator" group once and put people in it, which beats editing twelve lines of flags when you change your mind. Anything larger than that, or anything spanning several servers, wants the database-backed admin system instead, configured in `configs/databases.cfg`:

tf/addons/sourcemod/configs/databases.cfg:

```text
"Databases"
{
	"default"
	{
		"driver"	"default"
		"host"		"your-db-host"
		"database"	"sourcemod"
		"user"		"generated-user"
		"pass"		"generated-password"
	}

	"storage-local"
	{
		"driver"	"sqlite"
		"database"	"sourcemod-local"
	}
}
```

The panel's database slot gives you a host, a database name, a user and a password, and those four values are all this file wants. If you only need bans to survive a restart on one server, the `storage-local` SQLite entry above needs no database at all and is already there.

| Command | Effect |
| --- | --- |
| `sm_admin` | Opens the admin menu in game |
| `sm_kick <target> [reason]` | Kick |
| `sm_ban <target> <minutes> [reason]` | Ban. `0` is permanent |
| `sm_addban <minutes> <steamid>` | Ban somebody who is not connected |
| `sm_unban <steamid>` | Lift a ban |
| `sm_gag` / `sm_mute` / `sm_silence` | Text, voice, or both |
| `sm_slay` / `sm_slap <target> [damage]` | Kill, or hurt and shove |
| `sm_map <map>` / `sm_votemap <map...>` | Change map, or vote on it |
| `sm_cvar <cvar> [value]` | Read or set a cvar |
| `sm_who` | Who is connected and what access they have |
| `sm_reloadadmins` | Re-read the admin files |
| `sm plugins list` | What is loaded |
| `sm plugins reload <name>` | Reload one plugin |

Targets accept `#userid`, a partial name, `@all`, `@blue`, `@red`, `@me` and `@!me`, which is worth knowing before you slay the wrong person in front of twenty-four people.

#### The plugins that ship with SourceMod

A fresh SourceMod install already includes most of what a public server needs, and people install third-party plugins to replace things they already have. What is in the box:

- Admin commands, the admin menu, bans and communication controls - `basecommands`, `adminmenu`, `basebans`, `basecomm`, `basechat`.
- Map votes and rotation - `mapchooser` runs an end-of-map vote, `rockthevote` lets players call one, `nominations` lets them nominate, `nextmap` answers `say nextmap`, `randomcycle` picks at random instead.
- Quality of life - `reservedslots`, `antiflood`, `basetriggers` for `say timeleft`, `funcommands` and `funvotes` for the silly ones, `clientprefs` so plugins can remember a player's settings.

Every one of those generates a config file in `tf/cfg/sourcemod/` the first time it loads, with every cvar it owns, its default and a comment explaining it. That folder is the actual documentation, and reading `plugin.mapchooser.cfg` beats searching for a forum post from 2013. The vote threshold for rock the vote, how many minutes before the end the map vote starts, whether extending the map is allowed - all of it is there with defaults.

Which maps those plugins offer comes from `configs/maplists.cfg`, which by default points them at the server's `mapcyclefile`. Set `mapcyclefile "mapcycle.txt"` in `server.cfg`, put one map name per line in `tf/cfg/mapcycle.txt`, and votes, nominations and the rotation all agree with each other. A short list of maps people like beats a long list where two thirds get skipped.

#### Plugins worth adding

| Plugin | What it does |
| --- | --- |
| TFTrue | Competitive whitelists, tournament features, logs.tf uploading. Loaded with `plugin_load`, not through SourceMod |
| F2's stats plugins | `supstats2`, `medicstats` and the logs.tf uploader: the standard set behind every match log you have read |
| SOAP TF2DM | Deathmatch spawns and instant respawn for scrim and pug servers |
| TF2Items and TF2Attributes | Change weapon attributes. The base most custom-weapon plugins build on |
| Versus Saxton Hale / Freak Fortress 2 | The boss modes that keep 24-slot servers full |
| Updater | Keeps plugins that support it up to date automatically |

Resist the urge to install thirty. Every plugin is code running in your game server that has to be re-tested after every TF2 update, and a server with six plugins that work is better than a server with thirty where two are quietly throwing errors into a log nobody reads. Install a plugin because a specific thing is wrong, not because it looked interesting.

Plugins are ordinary files, so the file manager or SFTP is all you need - [SFTP and the file manager](https://www.renode.space/blog/sftp-and-the-file-manager) has the connection details. Drop the `.smx` into `addons/sourcemod/plugins/`, change map or run `sm plugins load <name>`, and check `sm plugins list`. Plugins distributed as `.sp` source need compiling, either with `spcomp` in `addons/sourcemod/scripting/` or with the web compiler on the SourceMod site. The general hygiene argument is in [keeping a modded server clean](https://www.renode.space/blog/keeping-a-modded-server-clean), and it applies here: a plugin runs with the server's full privileges and no sandbox.

#### Server cvars TF2 actually cares about

tf/cfg/server.cfg:

```cfg
hostname "Longship TF2 // No crits // EU"
rcon_password "a-long-random-string"
sv_password ""
sv_lan 0
sv_region 3
sv_tags "nocrits,vanilla,eu"
sv_visiblemaxplayers -1

// Rounds
mp_timelimit 30
mp_winlimit 0
mp_maxrounds 0
mp_bonusroundtime 8
mp_autoteambalance 1
mp_teams_unbalance_limit 1
mp_disable_respawn_times 0
mp_idlemaxtime 5
mp_idledealmethod 2

// Gameplay
tf_weapon_criticals 1
tf_damage_disablespread 0
tf_use_fixed_weaponspreads 0
tf_bot_quota 0

// Content
sv_pure 1
sv_pure_kick_clients 1
sv_allowupload 0
sv_allowdownload 1
sv_downloadurl ""
net_maxfilesize 64

// Housekeeping
mapcyclefile "mapcycle.txt"
sv_hibernate_when_empty 1
sv_hibernate_postgame_delay 30

// SourceTV
tv_enable 1
tv_port 27020
tv_delay 90
tv_name "Longship STV"
```

Three of those decide what kind of server you are running. `tf_weapon_criticals 0` turns off random critical hits, which is the single most divisive setting in the game and belongs in your server name either way. `tf_damage_disablespread 1` and `tf_use_fixed_weaponspreads 1` are the competitive damage settings, and turning them on quietly on a public server confuses regulars who cannot say why the rocket launcher feels different. `mp_disable_respawn_times 1` produces the fast, chaotic server a lot of communities are actually after.

`mp_idlemaxtime 5` with `mp_idledealmethod 2` kicks players idle for five minutes, which on a 24-slot server is the difference between full and full of nobody. Set method `1` to move them to spectator instead if you would rather be gentle.

`sv_hibernate_when_empty 1` drops an empty server to almost no CPU, which matters when a plan buys a share of a core rather than a whole one. SourceTV is a second port and a second process: it lets people spectate live and records demos, and it is the reason the TF2 plans here come with three port allocations rather than one - game, SourceTV, and one spare for whatever you add next. RCON runs over TCP on the game port and needs `-usercon`; the panel console is the safer way in, for the reasons in [using RCON safely](https://www.renode.space/blog/rcon-safely).

Bots are `tf_bot_quota` with `tf_bot_quota_mode fill`, `tf_bot_difficulty` from `0` to `3`, and `tf_bot_add`. They need a navigation mesh for the map, which official maps ship and custom maps mostly do not; the server can generate one with `nav_generate`, which takes a while and produces bots that walk into walls on complicated geometry.

#### Custom content, sv_pure and fast downloads

`sv_pure 1` makes clients use the server's version of game content instead of their own, with exceptions listed in `tf/pure_server_whitelist.txt`. It is how you stop people running a flat-white texture pack that makes everyone glow. `sv_pure 2` is stricter and breaks a lot of harmless customisation, including HUDs people rely on, so `1` with a sensible whitelist is where most servers land. `sv_pure_kick_clients 1` removes clients that refuse rather than trying to reconcile.

Custom maps have to reach the player. The engine's own download works with `sv_allowdownload 1` and is slow enough that people disconnect during it. The fix is `sv_downloadurl` pointing at a web server that mirrors the server's folder structure - `maps/`, `sound/`, `materials/`, `models/` - ideally with bzip2-compressed copies of each file. Any static host serves it, including a small [web hosting](https://www.renode.space/web-hosting) plan; it is a folder of files over HTTP. The mechanism is the same one Garry's Mod uses, and [workshop content and FastDL](https://www.renode.space/blog/garrys-mod-workshop-and-fastdl) goes through the folder layout in detail.

`sv_allowupload 0` is deliberate in that config. Client uploads were how custom spray images arrived, and they were also a long-running source of trouble. Turning uploads off costs sprays and removes a whole category of problem.

#### Updates, 64-bit, and keeping the thing running

TF2 updates break SourceMod. Not always, but often enough that it should be a planned event rather than a surprise. The failure is usually gamedata: SourceMod finds functions in the game by signature, an update moves them, and a plugin that depends on one throws an error the moment it is used. The fixes, in order:

1. Update SourceMod's gamedata. AlliedModders ships gamedata updates separately from full releases, and the `updater` plugin can fetch them for you.
2. Update Metamod:Source and SourceMod to the current builds of the branch that matches your server's architecture.
3. Update the individual plugin, or move it to `plugins/disabled/` and live without it until its author returns. Some never do.

The 64-bit transition is the version of this everybody hit at once: TF2 gained 64-bit server binaries and every 32-bit Metamod and SourceMod install stopped working until the builds caught up. If you are installing today, take current builds of both and check they are the ones with 64-bit binaries.

The habit that makes all of this cheap is keeping a copy of the working `addons` folder somewhere that is not the server, so a restore is a file copy rather than a reinstall. [What to do when a mod update breaks](https://www.renode.space/blog/what-to-do-when-a-mod-update-breaks) is the general procedure. On RE:NODE the update runs when the server starts, so taking an update is a decision you make by restarting, backup slots are included on every TF2 plan, and the Schedules tab will run a daily backup and a nightly restart on a cron expression. If the container hits its memory limit it is stopped and restarted clean rather than left to swap, which is a better outcome than an hour of a server that technically responds.

#### Troubleshooting

**`meta list` prints nothing.** `tf/addons/metamod.vdf` is missing, or its path is wrong, or the builds are 32-bit on a 64-bit server. Check the file exists, then check the path inside it matches where the binary actually is.

**Metamod loads but `sm version` does nothing.** SourceMod is unpacked in the wrong place. It belongs in `tf/addons/sourcemod`, not `addons/sourcemod` at the root.

**A plugin loads but its commands say "unknown command".** Admin flags. Run `sm_who` on yourself, check `admins_simple.ini` has your SteamID exactly as `status` shows it, and run `sm_reloadadmins`.

**Everything worked until the update.** Gamedata. Update SourceMod, then the plugins, then start disabling.

**Map votes offer the wrong maps.** `configs/maplists.cfg` is pointing at a different list than you think. By default it follows `mapcyclefile`.

**The server is empty and the CPU graph is flat at the limit.** A plugin is running work on a timer with nobody connected, or hibernation is off. Set `sv_hibernate_when_empty 1` and unload plugins one at a time.

**Players cannot download a custom map.** Either `sv_downloadurl` is wrong, or the file is not at the mirrored path, or `net_maxfilesize` is smaller than the file. Try the URL in a browser: it should download the file directly.

#### FAQ

##### Do I need Metamod as well as SourceMod?

Yes. Metamod:Source is the loader that gets SourceMod into the game process; SourceMod is the plugin platform. Neither does the other's job, and they must be matching builds for the same architecture.

##### Where do I add myself as an admin on a TF2 server?

`tf/addons/sourcemod/configs/admins_simple.ini`, one line with your SteamID and `"99:z"` for full access. Run `sm_reloadadmins` in the console, then type `sm_admin` in game to open the menu.

##### Does SourceMod work on Counter-Strike 2?

No. SourceMod supports Source 1 games such as TF2, Counter-Strike: Source and CS:GO. CS2 runs on Source 2 and uses CounterStrikeSharp instead, which is a different platform with different plugins.

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

Two gigabytes covers a full 24-slot server with a normal plugin set. Custom modes that hold state for every player want three or four. Disk is the tighter constraint: the install alone is upwards of 15 GB.

##### How do I turn off random crits?

`tf_weapon_criticals 0` in `server.cfg`. No plugin needed. Put it in the server name and in `sv_tags` as well, because it is the first thing people filter on.

##### Why do my plugins stop working after a TF2 update?

Because SourceMod locates game functions by signature and an update moves them. Update SourceMod's gamedata first, then Metamod and SourceMod themselves, then the individual plugins.

TF2 plans on RE:NODE start at 2 GB with 30 GB of NVMe disk, which is what the install and a map pack actually need, and three port allocations so the game, SourceTV and one more all have somewhere to live. Plugins are yours to choose and yours to upload, through the file manager or SFTP, with backup slots on every tier for the day an update goes badly.

[See TF2 plans](https://www.renode.space/game-servers/team-fortress-2)

---

### Team Fortress 2 server setup and config

Published 2026-07-10, updated 2026-09-21 by RE:NODE Team. https://www.renode.space/blog/team-fortress-2-server

TF2 is old, well optimised and cheap to host, which means the thing that decides whether your server is good is not the hardware. It is the map rotation, the plugin list and whether somebody is watching it. A 24-slot server fits comfortably in 2 GB and one core; the install is the only thing about it that is large, at roughly 25 GB on disk. This guide covers the install, the configuration that actually changes how the game plays, SourceTV, SourceMod and admins, and the part most guides skip - how a community server stops being empty.

#### What you get from a TF2 server

The dedicated server is a Source server running the `tf` game directory, app id `232250`, installed anonymously with SteamCMD. It needs no game licence, runs on Linux or Windows, and is undemanding by any modern standard.

Some things about it are fixed and worth knowing before you start tuning:

- **The tick rate is 66 and you cannot change it.** `-tickrate` is ignored by TF2. Third-party extensions exist that force other values; they are unsupported, they drift out of date with every game update, and every plugin and config you will download assumes 66. Leave it.
- **A Game Server Login Token is effectively mandatory.** Valve has required one for public server listings since 2016. Without a token the server still runs and can be joined by IP, but it does not appear in the browser, which for a community server is the same as not existing.
- **Community servers are found, not matched.** Casual matchmaking does not route players to you. Your traffic comes from the Community Servers browser, from friends, and from whatever Discord or listing site you put yourself on.
- **Everything social is a SourceMod plugin.** Votes, reserved slots, custom commands, bans that persist, MOTD ads - none of it is in the base game.

#### Requirements and resource usage

| Server | RAM | CPU | Notes |
| --- | --- | --- | --- |
| 12-16 slots, vanilla | 1-2 GB | 1 core | Friends and a map cycle |
| 24 slots, SourceMod, a few plugins | 2-3 GB | 1-1.5 cores | The normal community server |
| 32 slots, busy plugin list | 3-4 GB | 2 cores | Chaotic by design; plan for it |
| 24 slots plus SourceTV and demos | 3 GB | 1.5 cores | Add disk for the recordings |

The surprise in TF2 hosting is disk, not memory. The dedicated server install is around 25 GB, and custom maps are 50-150 MB each, so a rotation of twenty community maps is another couple of gigabytes. That is why TF2 plans here start with 30 GB rather than the 10 GB a game this light on memory would otherwise need.

CPU is a single-thread story, as with every Source game. A full 32-slot server with a dozen plugins will use appreciably more of one core than a 12-slot vanilla one, but neither is heavy. If your server is stuttering, suspect a plugin in a per-frame hook before you suspect the plan; [CPU vs RAM for game servers](https://www.renode.space/blog/cpu-vs-ram-for-game-servers) covers how to tell which resource is actually at its limit.

#### Installing the server: SteamCMD and the GSLT

```bash
$ steamcmd +force_install_dir /home/tf2/server +login anonymous \
    +app_update 232250 validate +quit
$ cd /home/tf2/server
$ ./srcds_run -game tf -console -usercon -port 27015 \
    +maxplayers 24 +map cp_process_f12 +sv_setsteamaccount <token>
```

Create the token at Steam's game server account page using app id `440` - the base game's id, not the server's. One token per server; reusing one across two live servers causes both to be logged out. The token is a credential: it can be banned if your server misbehaves, and anyone who has it can impersonate your server. Keep it out of `server.cfg` if other people can read your files, and prefer a startup variable or a separate config file that only you can see. [Steam game server tokens explained](https://www.renode.space/blog/steam-game-server-tokens-gslt) covers bans, per-game app ids and what happens when a token is revoked.

The rest of the launch line is short:

| Parameter | What it does |
| --- | --- |
| `-game tf` | The game directory |
| `-console` | Run headless |
| `-usercon` | Enable RCON; without it `rcon_password` does nothing |
| `-port 27015` | Game and query port |
| `+maxplayers 24` | Slots. The engine allows up to 32 |
| `+map <name>` | First map; the cycle takes over afterwards |
| `+servercfgfile server.cfg` | Only needed if you renamed it |

[SteamCMD explained](https://www.renode.space/blog/steamcmd-explained) covers `validate`, update scripts and what to do when an update half-finishes.

#### server.cfg, the settings that matter

`tf/cfg/server.cfg` runs on every map change. Most of what people put in it has no measurable effect; this is the part that does.

tf/cfg/server.cfg:

```cfg
hostname "Badlands and friends | EU | no random crits"
rcon_password "long-random-string"
sv_password ""
sv_lan 0
sv_region 3
sv_contact "you@example.com"
sv_tags "nocrits,vanilla,eu"

mp_timelimit 30
mp_winlimit 0
mp_maxrounds 0
mp_autoteambalance 1
mp_teams_unbalance_limit 1
mp_idlemaxtime 5
mp_idledealmethod 1
mp_friendlyfire 0
mp_respawnwavetime 10

tf_weapon_criticals 0
tf_damage_disablespread 1
tf_use_fixed_weaponspreads 1

sv_pure 1
sv_cheats 0
sv_allowupload 0
sv_allowdownload 1
sv_downloadurl "https://files.example.com/tf/"
net_maxfilesize 64

mapcyclefile "mapcycle.txt"
```

Four of those change the game rather than the server:

- `tf_weapon_criticals 0` removes random critical hits. This is the single most requested community server setting, and half your visitors will decide within a minute whether they like your server based on it. Either choice is defensible; pick one and say so in the hostname.
- `tf_damage_disablespread 1` removes random damage variation, and `tf_use_fixed_weaponspreads 1` makes shotgun pellets deterministic. Together with the above these are the standard "competitive-feeling" trio.
- `mp_idlemaxtime` with `mp_idledealmethod 1` moves idle players to spectator after that many minutes; `2` kicks them. On a server that fills, this is what stops half your slots being occupied by people who went to make tea in 2019.
- `sv_pure 1` enforces the shipped whitelist in `tf/cfg/pure_server_whitelist.txt`, which stops clients using modified models and bright-pink-everything skins. `sv_pure 2` is stricter and will reject legitimate HUDs and custom content, so most community servers stay at 1.

The rate cvars deserve a mention because people change them for no reason. `sv_minrate` and `sv_maxrate` bound bandwidth per client; `sv_mincmdrate`/`sv_maxcmdrate` bound how often clients send input; `sv_minupdaterate`/`sv_maxupdaterate` bound how often the server sends snapshots. Competitive configs clamp the command and update rates to 66 at both ends so every player is treated identically. If you are not running matches, leave the whole family alone - badly chosen values cause choke and packet loss that look exactly like a network fault.

Per-map overrides go in `tf/cfg/<mapname>.cfg`, which runs after `server.cfg` when that map loads. That is how you give an arena map a different time limit without a plugin.

#### Ports, SourceTV and connecting

| Port | Protocol | Purpose |
| --- | --- | --- |
| `27015` | UDP | Game traffic and Steam queries |
| `27015` | TCP | RCON, with `-usercon` |
| `27020` | UDP | SourceTV |
| `27005` | UDP | Outbound on the client, nothing to open |

TF2 plans here come with three allocations, which is exactly the shape of that table: the game port, SourceTV, and one spare for a second server or a stats daemon. [Game server ports explained](https://www.renode.space/blog/game-server-ports-explained) covers why the query lives on the game port in Source games and on a separate one elsewhere.

SourceTV is worth enabling even if nobody spectates, because it records demos you can review after an argument:

tf/cfg/server.cfg:

```cfg
tv_enable 1
tv_port 27020
tv_name "Badlands TV"
tv_title "Badlands and friends"
tv_delay 90
tv_maxclients 8
tv_autorecord 1
tv_delaymapchange 1
```

`tv_delay 90` is the broadcast delay in seconds that stops spectators relaying enemy positions to players. `tv_autorecord 1` writes a `.dem` for every map, in the `tf` folder, which grows quietly until you clean it up - put that on a schedule rather than discovering it as a full disk.

Players join through the Community Servers browser, through a Steam favourite, or directly with `connect 203.0.113.10:27015` in the developer console. Direct connect is the diagnostic: if it works and the browser does not list you, the problem is the token or the region, not the server. Treat `rcon_password` as the credential it is - the protocol sends it in plain text - and read [RCON safely](https://www.renode.space/blog/rcon-safely) before exposing it anywhere.

```diagram
title: What happens between clicking connect and spawning
client = Player | TF2 client
browser = Server browser | query on 27015
server = TF2 server | 66 tick
fastdl = FastDL | bz2 over HTTP
pure = sv_pure | whitelist check
client -> browser : reads the listing
client -> server : connect
server -> client : map name, download URL
fastdl -> client : map and content
server -> pure : verifies client files
```

#### Maps, the map cycle and custom content

The cycle lives in `tf/cfg/mapcycle.txt`, one map per line, and the server reads it from the file named by `mapcyclefile`. TF2 ships `mapcycle_default.txt`; copy it rather than editing it, because updates overwrite the original.

A map cycle with fewer, better maps beats a long list nobody votes for. Eight to twelve maps is plenty. Every map you add is one more thing a first-time visitor might have to download, and a 120 MB download is where most of them leave.

Custom maps need two things. The `.bsp` goes in `tf/maps/` on the server, and a bzip2-compressed copy goes on the web host behind `sv_downloadurl` so clients can fetch it at web speed rather than trickling it over the game port. Without FastDL, `sv_allowdownload 1` still works - it is just slow enough that people assume the server is broken.

Voting for the next map is a SourceMod job. The bundled `mapchooser`, `rockthevote` and `nominations` plugins between them give you an end-of-map vote, an RTV command and a nomination list, configured through `addons/sourcemod/configs/maplists.cfg`. Keep the votable list shorter than the full cycle; a vote with thirty options is a vote for whatever was at the top.

#### SourceMod, Metamod and admin

SourceMod and Metamod:Source first; everything social builds on them. Metamod loads into the engine, SourceMod loads into Metamod, and plugins are `.smx` files in `addons/sourcemod/plugins/`.

Admins go in `addons/sourcemod/configs/admins_simple.ini`, one line each:

addons/sourcemod/configs/admins_simple.ini:

```text
"STEAM_0:1:12345678"   "99:z"
"STEAM_0:0:87654321"   "20:bcdef"
```

The number before the colon is immunity, and the letters after it are permission flags - `z` is root, and the rest map to kick, ban, slay, changemap and so on. Groups and overrides live in `admins.cfg` and `admin_overrides.cfg` alongside it. After editing, `sm_reloadadmins` in the console applies it without a restart.

| Command | Effect |
| --- | --- |
| `sm plugins list` | What is loaded, and what failed |
| `sm plugins reload <n>` | Reload one plugin by its list number |
| `sm_admin` | The in-game admin menu |
| `sm_kick <player> <reason>` | Kick |
| `sm_ban <player> <minutes> <reason>` | Ban, 0 for permanent |
| `sm_map <map>` | Change map |
| `sm_rcon <command>` | Run a server command from in-game |
| `sm_reloadadmins` | Re-read the admin files |

Reserved slots for regulars is a small feature that keeps a community together, and it is a bundled plugin: set your slot count one higher than you advertise, enable `reservedslots`, and give the flag to the people who show up every week.

Bans that survive a restart and are visible to other admins need a database and a web panel - SourceBans++ is the usual answer. Every game plan here includes one database slot created from the panel with generated credentials, so check the plugin's requirements against it before you commit to that route.

One operational warning: **a TF2 update usually breaks SourceMod until you update it too.** Metamod and SourceMod bind to engine internals, and after a game patch the server will start with no plugins at all, or refuse to load them. Keep the download page bookmarked, use the stable branch unless a snapshot is required, and do not let an automatic game update run an hour before an event. [What to do when a mod update breaks](https://www.renode.space/blog/what-to-do-when-a-mod-update-breaks) is the general version of this problem. The plugin side in detail is in [TF2 SourceMod plugins](https://www.renode.space/blog/team-fortress-2-sourcemod-plugins).

#### Population is a schedule, not a hope

An empty server stays empty. This is the whole of community server hosting and no configuration file changes it.

- **Pick two evenings and be there.** People join servers with people on them. Two reliable hours a week beats a permanently running empty box.
- **Fill it with bots for the first month if you must**, honestly: `tf_bot_quota 8` with `tf_bot_quota_mode fill` keeps eight bots on until humans replace them. Bots need a navigation mesh, so they only work on maps that ship with a `.nav` file or one you generated with `nav_generate` - which is slow and imperfect on community maps.
- **Put the server in front of people.** A Discord with a status bot, a listing site entry, and accurate `sv_tags` so the browser filters find you. [Discord webhooks for server status](https://www.renode.space/blog/discord-webhooks-for-server-status) covers the bot side.
- **Write rules and give two people admin.** A server with no moderation is one bad evening from having no regulars. [Server rules, moderation and staff](https://www.renode.space/blog/server-rules-moderation-and-staff) covers permissions and appeals; [growing a game server community](https://www.renode.space/blog/growing-a-game-server-community) covers the rest.

A weekly restart during the quiet hours keeps memory and demo files in check. The panel's Schedules tab does it from a cron expression along with a backup, which is the entire maintenance burden of a TF2 server once it is set up.

#### Troubleshooting

**The server is not in the Community Servers browser.** In order: no GSLT, a banned GSLT, the query port unreachable, `sv_lan 1`, or the wrong `sv_region`. Confirm the server itself works with a direct `connect`.

**Players are kicked for "server is enforcing consistency for this file".** `sv_pure` rejecting a client file. Usually a custom HUD or model that the whitelist does not allow; `sv_pure 1` rather than `2` fixes most of it.

**A custom map takes minutes to download.** No FastDL, or the bz2 file is missing from the web host for that specific map. Check the exact file name and case.

**SourceMod stopped loading after an update.** Update Metamod and SourceMod. The console prints the failure at start-up; read the first lines, not the last.

**Everyone chokes and loses packets at the same time.** Rate cvars, or a plugin sending a lot of data. Reset the rate family to defaults before blaming the network.

**The server hits its memory limit and restarts.** Unusual for TF2 and almost always a plugin leaking. On RE:NODE a container at its limit is stopped and restarted clean rather than left to swap, and repeated restarts raise a warning and an automatic ticket rather than silently looping.

#### FAQ

##### Do I need a Game Server Login Token for a TF2 server?

For anything public, yes. Valve has required one for server browser listings since 2016. A server without one runs fine and accepts direct connections, which is enough for a private group but not for a community server.

##### Can I change the tick rate of a TF2 server?

No, not in a supported way. TF2 is locked to 66 ticks a second and ignores `-tickrate`. Extensions exist that force other values and they cause more problems than they solve.

##### How many slots should I run?

24 is the sweet spot for most community servers, and 32 is the practical maximum. Above 24 the game becomes a different experience - spam-heavy and hard to play seriously - which is a design choice rather than a performance one.

##### How much disk does a TF2 server need?

About 25 GB for the install, plus 50-150 MB per custom map and whatever SourceTV demos accumulate. Memory is the easy part; disk is what people underestimate.

##### Will my plugins survive a TF2 update?

The plugins usually will; SourceMod itself often will not until you update it. Plan updates for a time when nobody is playing, and never let one run just before an event you have advertised.

##### Should I disable random crits?

It is the most common change community servers make, and it is worth making a decision rather than leaving the default by accident. Put whichever you chose in the hostname so people know what they are joining.

TF2 plans on RE:NODE start at 2 GB with 30 GB of disk for the install and your map rotation, three port allocations so SourceTV has one of its own, SFTP and a file editor for `server.cfg`, and delivery in about a minute after payment clears - so the server exists before the evening you promised it.

[Deploy a TF2 server](https://www.renode.space/game-servers/team-fortress-2)

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