# Garry's Mod Server Hosting - everything RE:NODE has published

> A Garry's Mod 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/garrys-mod, 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/garrys-mod.

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

## What it is

Garry's Mod servers on any gamemode — sandbox, DarkRP, TTT, prop hunt. Workshop content and Lua addons supported.

- Genres: Casual, Indie, Simulation
- Developer: Facepunch Studios
- Released: 29 Nov, 2006
- Steam: https://store.steampowered.com/app/4000/

### What comes with every Garry's Mod 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 Garry's Mod 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 Garry's Mod plan do you need?

Memory is what decides whether a server holds together, so start there. The Starter tier gives 1 GB and 0.8 vCPU, which suits a private group. The Advanced tier at 3 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 10 GB to 40 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 01:45 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/garrys-mod or in the panel shop at https://panel.renode.space before quoting one.

| Plan | Price / month | Memory | CPU | NVMe disk | Databases | Backups | Ports |
|---|---|---|---|---|---|---|---|
| Starter | $5 | 1 GB | 0.8 vCPU | 10 GB | 1 | 2 | 1 |
| Standard | $7 | 2 GB | 1 vCPU | 15 GB | 1 | 2 | 1 |
| Advanced | $10 | 3 GB | 1.5 vCPU | 20 GB | 1 | 2 | 1 |
| Pro | $13 | 4 GB | 2 vCPU | 30 GB | 1 | 2 | 1 |
| Premium | $17 | 6 GB | 2.5 vCPU | 40 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

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

- [Garry's Mod server hosting: what to look for before you pay](https://www.renode.space/blog/garrys-mod-server-hosting-what-to-look-for) (2026-10-15): How to choose Garry's Mod server hosting: single-thread CPU, RAM by gamemode and addon count, Workshop and FastDL, MySQL for DarkRP, tick rate, DDoS and red flags.
- [Garry's Mod server lag and Lua errors](https://www.renode.space/blog/garrys-mod-server-performance-and-lua-errors) (2026-10-07): Find what makes a Garry's Mod server lag: reading Lua errors, measuring addon cost, profiling hooks, physics and prop limits, tickrate, memory and sv.db.
- [Garry's Mod TTT server: setup, maps, addons](https://www.renode.space/blog/garrys-mod-ttt-server) (2026-10-07): Set up a Trouble in Terrorist Town server: the terrortown gamemode, ttt_ cvars and karma, CS:S content, maps, damage logs, map votes and the addons worth adding.
- [Garry's Mod ULX vs SAM admin permissions](https://www.renode.space/blog/garrys-mod-ulx-and-sam-admin) (2026-10-07): Set up ULX and ULib or SAM on a Garry's Mod server: the first superadmin, groups and inheritance, target restrictions, bans, CAMI, databases and which to choose.
- [Garry's Mod DarkRP server: install and jobs](https://www.renode.space/blog/garrys-mod-darkrp-server) (2026-09-21): How to set up a DarkRP server: installing the gamemode, darkrpmodification, custom jobs, ULX or SAM admin, the database and the settings that matter.
- [Garry's Mod Workshop addons and FastDL](https://www.renode.space/blog/garrys-mod-workshop-and-fastdl) (2026-09-21): How Garry's Mod addons reach players: workshop collections, resource.AddWorkshop, resource.AddFile and setting up a FastDL host that actually works.
- [Garry's Mod server setup: addons and Workshop](https://www.renode.space/blog/gmod-server-setup) (2026-07-17): Installing srcds, server.cfg and the sandbox limits, Workshop collections and FastDL, gamemodes, admin mods, and why a full Garry's Mod server drags.

---

### Garry's Mod server hosting: what to look for before you pay

Published 2026-10-15 by RE:NODE Team. https://www.renode.space/blog/garrys-mod-server-hosting-what-to-look-for

Good Garry's Mod hosting is mostly about one CPU core. The server runs every addon's Lua and every prop's physics on a single main thread, so a fast core with a stated, enforced share of it matters more than any other line on the pricing page. After that come memory sized for your addon collection rather than your slot count, full file access so Lua can be edited and addons removed, a MySQL database on the same network if you run DarkRP or a shared admin mod, a location close to your players, and an honest description of what happens during an attack. "128-tick", "unlimited slots" and a long list of regions are mostly decoration.

This post is about judging an offer. Installing the server, the launch line and `server.cfg` are covered in [Garry's Mod server setup](https://www.renode.space/blog/gmod-server-setup); getting addons onto players' machines in [Workshop addons and FastDL](https://www.renode.space/blog/garrys-mod-workshop-and-fastdl); DarkRP itself in [the DarkRP server guide](https://www.renode.space/blog/garrys-mod-darkrp-server); and finding the addon that makes a server lag in [Garry's Mod server lag and Lua errors](https://www.renode.space/blog/garrys-mod-server-performance-and-lua-errors). Here, those facts are turned into questions to ask before you pay.

#### What a Garry's Mod server asks of a host

A Garry's Mod server is `srcds` running the `garrysmod` game directory (Steam app id `4020`), with a gamemode and a pile of addons on top. The engine is old and light; almost everything that costs resources is content somebody else wrote. That shapes what a host has to provide:

- **One fast core** for the main thread, where Lua hooks, timers, entity think functions and physics all run in sequence.
- **Memory that follows the addon list.** Models, materials and Lua for every mounted addon are held by the server whether one player is connected or forty.
- **Disk** for the base install (a few gigabytes), the Workshop cache, which grows with your collection, and logs and data files that addons write.
- **One reachable port**: `27015` UDP carries both game traffic and the server browser query. RCON over TCP and SourceTV are extras.
- **A database**, for DarkRP on more than one server, for admin mods that share ranks between servers, and for the many logging, inventory and economy addons that expect MySQL.
- **Your control over the files.** Fixing a Garry's Mod server usually means editing a Lua file, removing an addon folder or reading a log. Anything between you and the file system slows every fix down.

Bandwidth during play is small. What players notice is the first join: Workshop content comes from Steam, but anything sent through FastDL comes from wherever you put it. That is a content question rather than a hosting one, and it is covered below.

#### CPU: single-thread speed and an honest share

This is where Garry's Mod hosting succeeds or fails. The server has to finish each tick inside its budget - about 15 ms at 66 ticks, 30 ms at 33 - and everything on the main thread counts against it. If an addon spends 10 ms per tick in a `Think` hook, that is two thirds of a 66-tick budget gone, and no number of extra cores gets it back. Extra cores help with loading, networking and the operating system around the process; they do not make that thread faster.

So the questions are about one core:

1. **How fast is a single core?** A recent desktop-class processor or a high-clocked server chip makes a visible difference to tick time. An older many-core server processor at a low clock can look impressive on paper and still run Lua slowly. If a host names its CPU, look up single-thread performance rather than core count.
2. **How much of it is yours?** "2 vCPU" can mean two guaranteed cores, two threads shared with a crowd of neighbours, or a share that shrinks at busy hours. Ask how the limit is enforced. A modest hard limit you can see on a graph beats a generous figure with no guarantee - [shared CPU and noisy neighbours](https://www.renode.space/blog/shared-cpu-and-noisy-neighbours) explains why the unguaranteed kind fails exactly when your server is full.
3. **Can you see it?** A CPU graph against the plan's limit, plus the in-game `stats` command, tells you whether the server is short of CPU or wasting it.

The graph has one trap. A server pinned at 100% of one core on a 2 vCPU plan shows 50% overall and looks comfortable. [Reading game server CPU usage](https://www.renode.space/blog/reading-game-server-cpu-usage-single-thread) shows how to spot a single saturated thread behind a calm total. In Garry's Mod the quicker check is `stats` in the server console: when the `fps` column falls below your tick rate, the main thread is behind.

On RE:NODE, CPU is a percentage of one core - 150 is 1.5 vCPU - enforced as a hard throttle to the share you bought, with one container per server. A server at its limit is slow, never suspended for it. Garry's Mod plans run from 0.75 vCPU on the smallest tier to 2.5 on the largest.

> [!NOTE]
> More CPU rarely fixes a lagging Garry's Mod server on its own. An addon erroring every tick, or a hook doing a full entity search every frame, costs the same on any machine. Profile first, then buy - the method is in [Garry's Mod server lag and Lua errors](https://www.renode.space/blog/garrys-mod-server-performance-and-lua-errors).

#### RAM by gamemode and addon count

Memory is the headline number on every Garry's Mod plan, and the slot count is a poor guide to how much you need. The size of the collection is a better one. A realistic table:

| Server | RAM | vCPU |
| --- | --- | --- |
| Sandbox, friends, under 30 addons | 1-2 GB | 0.75-1 |
| TTT, Murder or Prop Hunt, 16-24 players | 2-3 GB | 1-1.5 |
| Sandbox with 100+ addons | 3-4 GB | 1.5-2 |
| DarkRP, 32-40 players | 4-6 GB | 2-2.5 |
| Any gamemode, 200+ item collection | 4-6 GB | 2+ |

A few things drive where in each range you land:

- **Addon count and type.** Prop packs, vehicle packs and map content cost memory once, at load. Lua-heavy addons - inventories, HUDs with server-side logic, NPC systems - cost memory and CPU continuously.
- **Gamemode.** Round-based modes like TTT reset the map regularly, which clears entities and keeps memory flat. DarkRP and sandbox servers accumulate entities, props and data until the next restart, so the figure that matters is the one just before the nightly restart, not after startup. [The TTT server guide](https://www.renode.space/blog/garrys-mod-ttt-server) covers what that gamemode needs in detail.
- **Maps.** A large RP map with dense props uses noticeably more than `gm_flatgrass`. Some TTT and RP maps also need Counter-Strike: Source content mounted, which adds to disk and memory.

What this means when comparing offers: buy for the end of the day, and check what happens at the limit. Some hosts let a server swap to disk, which turns a memory shortage into an evening of stutter. Others stop the process. On RE:NODE a server that reaches its memory limit is stopped and restarted clean instead of swapping, so a memory problem shows up as an unexplained restart at a similar time each day rather than as slow lag. Either way, you should know which behaviour you are buying.

##### The 32-bit ceiling

One Garry's Mod quirk makes large plans less useful than they look. The standard branch runs a 32-bit server process, which can address roughly 3-4 GB however much memory the plan has. A server with a huge collection can crash with allocation errors while the panel shows gigabytes free. The `x86-64` beta branch removes that ceiling, at the cost of needing 64-bit builds of every binary module in `garrysmod/lua/bin/`.

So before paying for an 8 GB plan to run a 32-bit server, ask yourself whether the server can use it. A host worth choosing lets you pick the branch, and anyone selling Garry's Mod plans above 4 GB should be able to tell you which branch their install uses.

#### Workshop collections, FastDL and disk

Garry's Mod has two content systems, and a host affects them differently.

The **server side** - what the server loads - is usually a Workshop collection mounted at startup:

```bash
+host_workshop_collection 123456789 -authkey <steam_web_api_key>
```

The server downloads and caches the collection at boot. That needs outbound access to Steam, disk for the cache, and a launch line you can actually edit. A host that only lets you choose from a fixed list of addons, or rewrites your launch parameters, makes this harder than it needs to be. The cache also makes startup slower the bigger the collection gets, which matters when a crash or a restart has players waiting.

The **client side** - what players download - is Steam's job for anything added with `resource.AddWorkshop`, and FastDL's job for loose files set up with `resource.AddFile`. FastDL is an ordinary web server holding compressed copies of your files, with `sv_downloadurl` pointing at it:

server.cfg:

```cfg
sv_downloadurl "https://fastdl.example.net/garrysmod/"
sv_allowdownload 0
```

FastDL does not need to run on the game server, and usually should not. A small web host serves static files far better than `srcds` does, and keeps the download traffic away from the game process. When comparing offers, check whether the game plan comes with a web server or whether you need a separate one - and if you are moving mostly to Workshop content, you may not need FastDL at all. [Workshop addons and FastDL](https://www.renode.space/blog/garrys-mod-workshop-and-fastdl) has the full setup, including the `.bz2` compression and the folder layout that trips people up.

On RE:NODE, game plans do not include a web server, but a small plan from [web hosting](https://www.renode.space/web-hosting) serves FastDL with a domain and a certificate issued and renewed automatically through its proxy slot. Disk on the Garry's Mod plans runs from 10 GB to 40 GB on NVMe, which comfortably holds a large collection and its cache.

#### MySQL for DarkRP, admin mods and logs

A single Garry's Mod server can run happily on SQLite. DarkRP stores money and owned doors in `garrysmod/sv.db` by default, ULX keeps its groups and bans in data files, and many addons write to the same local `sv.db`. For one server that is fine, and a database included in a plan is not a reason to pick it.

You want MySQL when:

- **You run more than one server** and want shared money, ranks or bans between them.
- **An addon expects it.** Plenty of logging, inventory, economy and admin addons offer MySQL storage, and some of the larger ones are built around it. SAM can store its data in MySQL; ULX needs a separate addon for that.
- **You want to query or fix data while the server runs**, from phpMyAdmin or a client, rather than stopping the server to open `sv.db`.

Garry's Mod reaches MySQL through a binary module - usually `mysqloo` - placed in `garrysmod/lua/bin/`. The module must match the server's platform and branch: `gmsv_mysqloo_linux.dll` for the 32-bit Linux server, `gmsv_mysqloo_linux64.dll` for `x86-64`. The `.dll` extension on Linux is correct and confuses everybody. A host that does not let you upload files to `lua/bin`, or runs a different branch from the one you expect, breaks this quietly: DarkRP falls back to SQLite and money appears to reset.

Three questions for any offer:

1. **Is a database included, or priced separately?** That changes the comparison between two plans that look similar.
2. **Where does it run?** Addons make many small queries. A database on the same network answers in under a millisecond; a free remote one on another continent adds tens of milliseconds to every query, which turns into hitches when the main thread waits on it.
3. **Is it backed up, and can you get it out?** A database you cannot dump is a database you cannot move.

Every RE:NODE Garry's Mod plan includes one database slot, created from the panel with a generated host, user and password, and an "Open in phpMyAdmin" button that signs you in with a one-use token. If you want the database on its own resources, MySQL 8.4 LTS is also sold separately under [database hosting](https://www.renode.space/database-hosting#mysql). The admin side - groups, permissions and choosing between them - is in [ULX and SAM admin](https://www.renode.space/blog/garrys-mod-ulx-and-sam-admin).

#### Tick rate and what "high tick" offers mean

Tick rate is set with `-tickrate` on the launch line. Garry's Mod servers usually run at 33 or 66. Raising it roughly doubles the per-tick CPU cost and makes no difference to a server that is already falling behind.

| Gamemode | Sensible tick rate | Why |
| --- | --- | --- |
| Sandbox, DarkRP, roleplay | 33 | Many entities, aim matters less |
| TTT, Murder, Prop Hunt | 33-66 | Moderate entity counts, some gunplay |
| Combat-focused modes | 66 | Hit registration matters |

That makes "128-tick Garry's Mod hosting" an odd thing to advertise. Any host can let you type `-tickrate 128`; the question is whether one core can finish a tick in under 8 ms with your addons loaded, and for a DarkRP server it almost certainly cannot. A plan sold on tick rate is selling a launch parameter. What you want is the freedom to set the rate yourself and a CPU fast enough to hold it. [What tick rate actually means](https://www.renode.space/blog/what-tick-rate-actually-means) has the longer argument.

#### Location, latency and DDoS

Pick the location for where your players are. Source interpolates other players' movement, so moderate latency is hidden well, but past roughly 100 ms gunfights in TTT start to feel unfair and props in sandbox lag behind the player carrying them. Most Garry's Mod communities are regional; put the server in the middle of where the regulars live, and ask a few of them to ping a host's test address in the evening before you pay. [Latency, jitter and packet loss](https://www.renode.space/blog/latency-jitter-and-packet-loss) explains what to look at besides the average.

RE:NODE runs in one location, Germany, on hardware we run. That suits players in Europe and nearby, and it is the wrong choice for a community in North America or Asia.

Attacks are the other half of the network question. Source servers have long been targets for query floods and reflection attacks, and DarkRP communities attract grudges. What filtering upstream of a server does well is drop volumetric floods, reflection traffic and malformed packets. What it does poorly is tell an attack shaped like real clients from real clients. When reading a host's claim, look for what is filtered in plain words, what happens when filtering is not enough (some hosts null-route the address during a large attack, which takes the server offline), and no promise of zero downtime. A host that promises no downtime under any attack is selling you a sentence, not a service. [DDoS attacks on game servers explained](https://www.renode.space/blog/ddos-attacks-on-game-servers-explained) goes through the categories.

On RE:NODE the wording is exactly this: upstream filtering that drops obvious volumetric floods, plus reflection and malformed traffic. Attacks that look like real players are not filtered.

Some protection is yours. Keep `rcon_password` long or unset, and do not open TCP `27015` unless you need RCON - [RCON safely](https://www.renode.space/blog/rcon-safely) explains why. Many "attacks" on small servers turn out to be a backdoored addon or an exploitable net message, which no network filter can catch.

#### Panel features that actually matter

Most hosting panels look alike in screenshots. These are the features you will use every week:

- **An unfiltered console with history.** Lua errors announce themselves there, with the file path of the addon that threw them. A console that hides or truncates output hides your problems.
- **Full file access, including SFTP.** Removing an addon is deleting a folder; fixing one is editing a Lua file. Uploading a map pack through a browser form is miserable; through SFTP it is routine. [SFTP and the file manager](https://www.renode.space/blog/sftp-and-the-file-manager) has the details.
- **An editable launch line.** Collection ID, gamemode, map, tick rate, max players and branch all live there. A panel that generates it from a short form and drops anything it does not recognise is a problem.
- **Scheduled restarts.** Sandbox and DarkRP servers benefit from a nightly restart. A schedule that can send a warning message, wait and then restart is worth more than any "auto-restart on crash" checkbox - [restart schedules that help](https://www.renode.space/blog/restart-schedules-that-help) covers the timing.
- **Backups off the machine**, restorable by you, covering `garrysmod/data`, `sv.db` and your config. A backup stored next to what it protects does not protect against losing the server.
- **Subusers.** Garry's Mod servers are run by staff teams. A developer needs files; a moderator may only need the console. Handing out the account password is how servers get lost.

On RE:NODE, every plan gets the same panel: a live console with history, a file manager with an in-browser editor, SFTP with per-server credentials, a Schedules tab that runs console commands, backups and power actions in order, backup slots stored off the machine, and subusers with console-only or files-only access. Mods and addons are installed by you, through the file manager, SFTP or the Workshop - there is no list of allowed addons, and no one-click addon installer either.

#### Red flags in Garry's Mod hosting offers

Some offers are just expensive. Others tell you how the host operates.

- **"Unlimited slots."** Garry's Mod caps `-maxplayers` at 128, and the real limit is the main thread long before that. "Unlimited" means nobody checked.
- **"Free premium addons" or "full DarkRP pack included."** Paid Garry's Mod addons are sold per buyer, usually through Garry's Mod marketplaces with licence checks. A free bundle of them is almost always leaked, and leaked addons are a well-known route for backdoors that hand someone else RCON-level control of your server. [What to do when your server is hacked](https://www.renode.space/blog/what-to-do-when-your-server-is-hacked) is the page you do not want to need.
- **A vCPU figure with no explanation.** "Up to 4 cores" with nothing about enforcement usually means whatever is left over.
- **Large plans with no word on the branch.** 8 GB on a 32-bit server is 4 GB you cannot use.
- **No way to upload binary modules or edit the launch line.** You lose MySQL, the 64-bit branch and half the useful addons.
- **No database, or one on another continent.** A cost you discover after a week of hitches.
- **No backups, or backups on the same disk.** See [backups that actually restore](https://www.renode.space/blog/backups-that-actually-restore).
- **Zero-downtime DDoS promises and 100% SLAs.** Nobody delivers them, which makes you wonder what else on the page is decoration.

None of these prove a host dishonest. Several are signs of a product built for a different customer. But a community runs on its first host for months, and moving later means a weekend of copying data folders and re-pointing players.

#### A checklist before you pay

In the order worth checking:

1. **Location** close to most of your players, confirmed with a ping from a few of them.
2. **CPU**: a stated share of a fast core, enforced and visible on a graph.
3. **Memory** for your addon collection at the end of the day, with a known behaviour at the limit and a known branch.
4. **Launch line and files** fully editable, SFTP available, `lua/bin` writable.
5. **Database** on the same network if you need one, included or priced into the comparison.
6. **FastDL** planned: Workshop-only, or a small web host beside the game server.
7. **Backups** off the machine, restorable by you.
8. **An honest DDoS description** and a support route you have tested.

For the parts that apply to every game, see [how to choose game server hosting](https://www.renode.space/blog/how-to-choose-game-server-hosting) and [game server CPU requirements](https://www.renode.space/blog/game-server-cpu-requirements).

#### FAQ

##### How much RAM does a Garry's Mod server need?

1-2 GB for a sandbox or TTT server with a modest collection, 3-4 GB once you pass about a hundred addons, and 4-6 GB for a busy DarkRP server. Measure just before the nightly restart, not after startup, and remember the default 32-bit server cannot use much more than about 4 GB.

##### Is a DarkRP server more demanding than TTT?

Usually, yes. TTT resets the map every round, which keeps entity counts and memory in check. DarkRP accumulates props, printers and player data all session, and its addons tend to be Lua-heavy, so it needs both more memory and a faster main thread for the same player count.

##### Do I need MySQL for a Garry's Mod server?

Not for a single server. SQLite in `sv.db` handles DarkRP and most addons well. MySQL becomes worth it when several servers share money, ranks or bans, or when an addon you want is built around it.

##### Will a higher tick rate make my server smoother?

Only if the CPU can hold it. A server that already falls below its tick rate in `stats` gets worse at a higher one. Fix the expensive addons first, then raise the rate if there is headroom.

##### Can I host FastDL on the same server?

You can, but a small separate web server does it better and keeps download traffic off the game process. Many servers now use Workshop content alone and need no FastDL at all.

##### Can I move my Garry's Mod server to another host later?

Yes. Copy `garrysmod/addons`, `garrysmod/data`, `garrysmod/cfg`, `sv.db` and any binary modules, dump and import the MySQL database if you use one, check the branch matches, and point players at the new address. [Moving a server without losing players](https://www.renode.space/blog/moving-a-server-without-losing-players) covers the rest.

Garry's Mod plans on RE:NODE start at $5 a month and run from 1 GB to 6 GB on NVMe, with an unfiltered console, SFTP, a database slot with one-click phpMyAdmin sign-in, scheduled restarts and backup slots on every tier. Moving up a tier raises the limits on the server you already have.

[See Garry's Mod plans](https://www.renode.space/game-servers/garrys-mod)

---

### Garry's Mod server lag and Lua errors

Published 2026-10-07 by RE:NODE Team. https://www.renode.space/blog/garrys-mod-server-performance-and-lua-errors

When a Garry's Mod server lags, the cause is almost always Lua - one addon doing too much work every tick, or erroring every tick - or physics, from too many props touching each other. It is rarely the hardware, and almost never fixed by a bigger plan alone. The working method is short: read the console for repeating Lua errors and fix or remove the addon that throws them, measure server frame time with `stats` while the lag is happening, profile hooks with a profiler addon to find which one is expensive, and bisect the addon list on a test copy when nothing else names a culprit. Then set a sane tickrate, prop limits and a nightly restart so it stays fixed. This guide goes through each step with the commands.

#### Where the time goes on a Garry's Mod server

A Garry's Mod server runs its game simulation on one thread. Each tick - 66 times a second at `-tickrate 66`, 33 at `-tickrate 33` - it runs physics, entity logic and every Lua hook registered by the gamemode and addons, then sends updates to players. If the work for one tick takes longer than the tick interval (15 ms at 66 tick), the server falls behind and players feel it as rubber-banding, delayed shots and props that stutter.

| Source of cost | Typical symptom | Where to look |
| --- | --- | --- |
| A Lua hook doing heavy work per tick | Lag that grows with player count | Profiler, addon bisect |
| A Lua error inside a hook | Console spam, constant mild lag | Console, error log |
| Physics: many props in contact | Lag when someone builds or a pile collapses | Prop count, physics settings |
| Net messages: too much sent at once | Players disconnect with overflow errors | Client console, addon bisect |
| Database queries on the main thread | Spikes on join, death or round end | Addons using SQL, `sv.db` size |
| Memory pressure | Crash after hours or days | Memory graph, 32-bit vs 64-bit |

The order matters. Lua errors are the cheapest to find and the most common, so start there. [Garry's Mod server setup](https://www.renode.space/blog/gmod-server-setup) covers the base install and a first diagnostic pass; this post goes deeper.

#### Reading Lua errors

A Lua error prints to the server console with the file, the line and a stack trace:

```text
[ERROR] addons/coolhud/lua/autorun/server/sv_hud.lua:42: attempt to index a nil value
  1. fn - addons/coolhud/lua/autorun/server/sv_hud.lua:42
   2. unknown - lua/includes/modules/hook.lua:96
```

Read it from the top. The first line says which file and line failed and why; the path names the addon (`coolhud` here, or the Workshop addon's title for Workshop content). The stack shows what called it - `hook.lua` means it ran from a hook, which means it will run again next tick, and the tick after.

Common messages and what they usually mean:

| Message | Usual cause |
| --- | --- |
| `attempt to index a nil value` | Code assumed a player, entity or table existed and it did not |
| `attempt to call a nil value` | A function from another addon or a removed API is missing |
| `attempt to compare number with nil` | A config value or networked variable was never set |
| `Tried to use a NULL entity!` | An entity was removed while code still used it |
| `bad argument #1 to ...` | Wrong type passed, often after a Garry's Mod update changed something |
| `stack overflow` | Infinite recursion, often two addons hooking each other |

The one that matters most for performance is an error inside a hook that runs every tick. The error handler itself costs time, the console fills with spam, and the log grows. A single broken HUD addon erroring in a `Think` hook for every player can cost more than the rest of the addon list combined.

##### Getting errors you can read later

The live console scrolls too fast to read on a busy server. Two settings help:

garrysmod/cfg/server.cfg:

```cfg
con_logfile "console.log"
lua_log_sv 1
```

`con_logfile` writes everything the console prints to a file under `garrysmod/`, and `lua_log_sv 1` asks the server to log its Lua errors as well. Both files grow; delete or rotate them weekly. [Reading the console](https://www.renode.space/blog/reading-the-console) covers which lines matter and which are noise.

Client-side errors - in HUDs, menus and effects - happen on each player's machine and appear in their console, not yours. If players report errors you never see, ask for a screenshot of their console after typing `lua_log_cl 1`; the path in the error still names the addon.

#### Fixing or removing an erroring addon

Once the console names an addon, there are four options, in order of preference:

1. **Update it.** Many errors appear after a Garry's Mod update changed an API, and the author has already fixed it. Workshop addons update themselves on restart; legacy addons in `garrysmod/addons/` do not.
2. **Check for a conflict.** An addon that works alone and fails with another installed usually means both override the same function or hook name. Remove the other one and test.
3. **Fix it yourself.** If you can read Lua, the file and line are right there. A nil check (`if not IsValid(ent) then return end`) fixes a large share of real-world errors.
4. **Remove it.** An abandoned addon throwing errors every tick is not worth keeping. Unsubscribe it from the collection or delete its folder.

Do not silence errors by wrapping them in `pcall` everywhere. That hides the error and keeps the cost.

#### Measuring: stats, status and a profiler

You cannot fix lag you have not measured. Three tools, from cheapest to most detailed.

`stats` in the server console prints CPU usage, incoming and outgoing traffic, uptime, the number of map changes and the server's frame rate. Run it during lag. If the frame rate is below the tickrate, the server cannot keep up - a server problem. If it is at the tickrate and players still complain, look at their connection and at net messages instead.

`status` lists players with their ping and loss. One player with 400 ms and loss is that player's route; everyone at 400 ms is the server. [Latency, jitter and packet loss](https://www.renode.space/blog/latency-jitter-and-packet-loss) explains the difference.

A profiler shows which Lua functions use the time. FProfiler is the long-standing Garry's Mod profiling addon: install it, start a recording while the server is busy, stop it after a minute, and it lists the most expensive hooks and functions with their total and average time. That list is usually decisive - one hook from one addon at the top with ten times the cost of anything else.

Quick checks with `lua_run` from the server console are also useful:

```text
lua_run print(#ents.GetAll())
lua_run print(#player.GetAll())
lua_run print(collectgarbage("count"))
```

The first prints the entity count, which on a sandbox or DarkRP server tells you whether props are piling up. The last prints Lua memory in kilobytes; if it climbs steadily over hours and never falls back, an addon is leaking tables.

> [!WARNING]
> `lua_run` executes Lua on the server with full access. Anyone with console or RCON access can run it, which is one more reason panel and admin access should be given narrowly. Never paste `lua_run` lines from a stranger.

#### Addon cost: what makes an addon expensive

Some patterns are reliably expensive, and recognising them in a profiler result saves time:

- **Per-tick loops over players or entities.** A `Think` or `Tick` hook that calls `player.GetAll()` or `ents.FindInSphere` and does work for each result. Cheap at 10 players, expensive at 60.
- **Timers with tiny intervals.** `timer.Create` with a delay of `0` or `0.01`, repeating forever. Effectively another per-tick hook.
- **Networking in hooks.** Sending net messages to all players every tick, or networking large tables. Costs bandwidth as well as CPU and causes overflow disconnects.
- **File and SQL access in hooks.** Reading or writing files, or running `sql.Query` against the local SQLite database, inside a frequent hook. Both block the game thread.
- **Physics-heavy entities.** Vehicles, ropes, wire contraptions and anything that spawns many physics objects.

When nothing obvious shows up, bisect. Make a copy of the server on a test instance, remove half the addons, and measure under the same load. Keep halving until the lag follows one addon. It is tedious, and it is the only method that always works.

##### A typical case, start to finish

A roleplay server runs fine with twenty players and drags at forty. Nothing in the console. `stats` during peak shows the server frame rate falling to the low twenties against a tickrate of 33, so the server is genuinely behind. A one-minute profiler recording puts one function at the top: a hook from an HUD-adjacent addon that, every tick, loops over every player and for each one loops over every entity to find the nearest door. Forty players times a few thousand entities, 33 times a second.

Nothing about that hook was broken. It worked, it threw no errors, and at twenty players it cost a millisecond per tick. At forty players the cost quadrupled, because both lists had doubled. The fix was to run the same check once a second instead of every tick, which the addon's config allowed and nobody had looked at. Frame rate went back to the tickrate, and the plan did not change.

That is the shape of most Garry's Mod performance problems: not a bug, but work that scales with players times entities, hidden in an addon that looked harmless at launch. The profiler finds it in minutes; guessing takes weeks.

#### Physics, props and limits

Physics runs every tick too, and it gets expensive non-linearly: a hundred props lying still are cheap; a hundred props piled together and touching are not, because every contact is resolved every tick. On sandbox and roleplay servers, the worst lag usually comes from one player's contraption or a deliberate prop pile.

garrysmod/cfg/server.cfg:

```cfg
sbox_maxprops 150
sbox_maxragdolls 5
sbox_maxvehicles 2
sbox_maxeffects 50
sbox_maxballoons 10
sbox_maxthrusters 20
sbox_noclip 1
```

These limits are per player. Keep them as low as your gamemode allows; a sandbox server with `sbox_maxprops 1000` and thirty players can in theory hold thirty thousand props. Add a prop-cleanup-on-disconnect setting in your admin mod or a cleanup addon, and consider an anti-crash addon that freezes props when too many collide at once. TTT and other round-based modes clean up every round and need far less of this. [The TTT server guide](https://www.renode.space/blog/garrys-mod-ttt-server) covers that gamemode specifically.

#### Tickrate, hibernation and memory

`-tickrate` on the launch line sets how many ticks the server runs per second. 66 is smoother; 33 halves the per-tick cost and is still fine for roleplay and sandbox where precise aim matters less. Set it explicitly rather than relying on a default.

| Gamemode | Sensible tickrate | Why |
| --- | --- | --- |
| Sandbox, DarkRP, roleplay | 33 | Many entities, aim matters less |
| TTT, Murder, Prop Hunt | 33-66 | Round-based, moderate entity counts |
| Combat-focused gamemodes | 66 | Aim and hit registration matter |

Raising the tickrate roughly doubles the per-tick CPU cost and makes no difference to a server that is already behind. Fix the cost first, then raise the rate if there is headroom. [What tick rate actually means](https://www.renode.space/blog/what-tick-rate-actually-means) has the longer argument.

An empty Garry's Mod server hibernates by default and uses almost no CPU. `sv_hibernate_think 1` keeps it thinking while empty, which some addons need; if your idle server shows steady CPU use, check whether this is set, or whether an addon is running a timer regardless.

Memory problems look different. The standard Garry's Mod server is a 32-bit process, so it can only address about 4 GB however much the plan has; large collections hit that ceiling and crash with out-of-memory errors while the graph looks fine. The `x86-64` beta branch removes that limit, at the cost of needing 64-bit builds of any binary modules. The local SQLite database, `garrysmod/sv.db`, is another slow leak: some addons write to it constantly, and a file of hundreds of megabytes makes every query slower. Check its size occasionally and clean or move the data that addons store there.

```diagram
title: Finding the cause of Garry's Mod lag
lag = Players report lag | when and how many
console = Console | repeating Lua errors
stats = stats | server fps vs tickrate
prof = Profiler | expensive hooks
bisect = Bisect addons | on a test copy
fix = Fix | update, remove, limit
lag -> console
console -> fix : error names addon
console -> stats : no errors
stats -> prof : fps below tickrate
prof -> fix : hook names addon
prof -> bisect : nothing obvious
bisect -> fix
```

#### Restarts, crashes and staying fixed

Even a well-tuned Garry's Mod server accumulates entities, timers and Lua memory over days. A nightly restart at an empty hour keeps frame times flat and costs nothing. On RE:NODE the Schedules tab runs it from a cron expression, with an optional warning command a few minutes before. [Restart schedules that help](https://www.renode.space/blog/restart-schedules-that-help) covers timing.

Crashes are a separate problem from lag. A Lua error does not crash the server; a crash comes from a binary module, a physics explosion, the 32-bit memory ceiling or the process being stopped at the plan's memory limit. On RE:NODE a server that reaches its memory limit is stopped and restarted clean rather than left to swap, and a watcher counts unexpected restarts - three in an hour puts a warning on the server page and opens a ticket automatically, so a crash loop does not go unnoticed. [Why your game server keeps restarting](https://www.renode.space/blog/why-your-game-server-keeps-restarting) helps tell those cases apart.

#### Troubleshooting

**The console is full of the same Lua error.** One addon in a hook. Read the path in the first line, update or remove that addon, and restart.

**Lag only when the server is full.** Per-player cost. Profile at peak; look for hooks looping over players.

**Lag spikes when someone joins.** Addons doing database or file work on `PlayerInitialSpawn`, or a large `sv.db`. Profile a join.

**Players disconnect with "reliable channel overflowed".** An addon sends too much in one go, usually on spawn. Remove addons until it stops; the client console shows the last message received.

**The server crashes after hours with memory free.** The 32-bit address space. Trim addons or move to the 64-bit branch with matching modules.

**Idle server uses CPU.** `sv_hibernate_think 1`, or an addon timer running without players.

#### FAQ

##### Do Lua errors cause lag?

An error that happens once does not matter. An error inside a hook that runs every tick does, because the error handler runs every time and the console and log fill up. Fix repeating errors first.

##### What tickrate should a Garry's Mod server use?

33 for sandbox and roleplay, 33 to 66 for round-based modes, 66 for combat-focused gamemodes. Put it on the launch line explicitly, and only raise it once the server has CPU headroom at peak.

##### Will a bigger plan fix my lag?

Only if the server is genuinely short of CPU or memory after the addon problems are fixed. One expensive hook or a pile of colliding props will lag on any hardware. Measure first, then size.

##### How do I find which addon is causing lag?

Read the console for repeating errors, then use a profiler such as FProfiler while the server is busy. If neither names a culprit, remove half the addons on a test copy and measure, repeating until the lag follows one addon.

##### Should I run the 64-bit Garry's Mod server?

If your server crashes with memory errors while the plan has memory to spare, yes. Check that every binary module you use has a 64-bit build first.

Garry's Mod servers on RE:NODE start from 1 GB with CPU, memory and disk graphs in the console against your plan's limits, scheduled restarts from the Schedules tab, and crash detection that warns you and opens a ticket after repeated restarts. Moving up a tier changes the limits on the same server.

[See Garry's Mod plans](https://www.renode.space/game-servers/garrys-mod)

---

### Garry's Mod TTT server: setup, maps, addons

Published 2026-10-07 by RE:NODE Team. https://www.renode.space/blog/garrys-mod-ttt-server

Trouble in Terrorist Town ships with Garry's Mod, so a TTT server is a normal Garry's Mod server started with `+gamemode terrortown` on a `ttt_` map. The settings are `ttt_` cvars in `garrysmod/cfg/server.cfg` - round length, traitor percentage, karma - and the defaults are sensible enough to play on the first evening. What turns a working server into one people come back to is three things: Counter-Strike: Source content mounted so maps do not fill with `ERROR` models, a damage log so admins can rule on random deathmatch fairly, and a map vote over a short list of good maps. This guide covers the install, the cvars that matter, karma, maps, the addons TTT servers actually run, and the problems you will hit in the first week.

#### What a TTT server is made of

TTT is a round-based social deduction gamemode: a few players are secretly traitors, a few are detectives with a shop and tools, and everyone else is innocent. Rounds are short, deaths are permanent until the next round, and the whole game depends on players trusting the server's rules more than each other.

The pieces:

| Piece | What it is | Where it lives |
| --- | --- | --- |
| Gamemode | `terrortown`, bundled with Garry's Mod | `garrysmod/gamemodes/terrortown/` |
| Maps | `ttt_` maps, mostly from the Workshop | Workshop collection or `garrysmod/maps/` |
| CS:S content | Textures and models many maps use | Mounted on server and clients |
| Admin mod | ULX/ULib or SAM | Addons |
| Damage logs | Who hurt whom, for RDM rulings | Addon |
| Map vote | End-of-map vote over your list | Addon |
| Optional | Pointshop, custom weapons, TTT2 | Addons |

TTT2 is worth knowing about before you start. It is a community rewrite of TTT, distributed through the Workshop, with many more roles and a large addon ecosystem. It is a different gamemode with its own settings, and most classic TTT addons need TTT2-specific versions. Decide early which one you run; this guide is about classic TTT, with notes where TTT2 differs.

#### Requirements and sizing

TTT is one of the better-behaved Garry's Mod gamemodes. Rounds reset the map, so entities do not accumulate the way they do on DarkRP or sandbox, and the Lua running each tick is modest until addons add to it.

| Server | RAM | CPU | Notes |
| --- | --- | --- | --- |
| 12-16 players, light addons | 1.5-2 GB | 1 core | A friends server |
| 16-24 players, typical addons | 2-3 GB | 1-1.5 cores | The common public setup |
| 24-32 players, Pointshop and many weapons | 3-4 GB | 1.5-2 cores | Addons dominate the cost |

Garry's Mod runs its game logic on one thread, so clock speed matters more than core count, and the Workshop collection size drives both disk and first-boot time. [Garry's Mod server setup](https://www.renode.space/blog/gmod-server-setup) covers the base install, the 64-bit branch and the sandbox limits.

#### Installing and starting TTT

On your own machine, Garry's Mod server installs with SteamCMD as app `4020`. Start it on the TTT gamemode and a TTT map:

```bash
$ ./srcds_run -game garrysmod -console -port 27015 \
    +maxplayers 24 +gamemode terrortown +map ttt_minecraft_b5 \
    +host_workshop_collection <collection_id> -authkey <steam_web_api_key>
```

`+gamemode terrortown` is the whole switch. `+host_workshop_collection` mounts your maps and addons from the Workshop, and it needs a valid Steam Web API key in `-authkey` or the collection is silently skipped. On a panel host you do not type this line: the launch arguments are variables on the Startup tab, and the panel builds the command from them.

##### Mounting Counter-Strike: Source content

Many popular TTT maps use textures and models from Counter-Strike: Source. If a player does not have that content, those surfaces render as purple-and-black checkerboards and props as giant red `ERROR` signs. There is no legal way for your server to give players CS:S content; they need to own CS:S or play with the errors.

The server should mount it too, because some maps rely on CS:S physics models for collisions. The free Counter-Strike: Source dedicated server (SteamCMD app `232330`) provides the files without a game licence. Install it in its own folder and point Garry's Mod at it:

garrysmod/cfg/mount.cfg:

```text
"mountcfg"
{
	"cstrike"	"/home/gmod/css/cstrike"
}
```

Tell players in your server description and MOTD that CS:S content is required for the best experience, and pick maps that use as little of it as possible if your community is mostly players without it. [Garry's Mod Workshop and FastDL](https://www.renode.space/blog/garrys-mod-workshop-and-fastdl) covers how the rest of your content reaches players.

#### The ttt_ settings that matter

TTT reads its settings from `ttt_` convars, set in `garrysmod/cfg/server.cfg`. The defaults below are from the TTT documentation and have been stable for years; type any cvar into the console without a value to see its current value and default on your server.

| Cvar | Default | What it does |
| --- | --- | --- |
| `ttt_firstpreptime` | `60` | Seconds of preparation before the first round on a map |
| `ttt_preptime_seconds` | `30` | Preparation before every later round |
| `ttt_posttime_seconds` | `30` | Time after a round ends before the next one |
| `ttt_roundtime_minutes` | `10` | Round length when haste mode is off |
| `ttt_haste` | `1` | Haste mode: short rounds that gain time per death |
| `ttt_haste_starting_minutes` | `5` | Initial round time in haste mode |
| `ttt_haste_minutes_per_death` | `0.5` | Time added per innocent death |
| `ttt_traitor_pct` | `0.25` | Share of players who become traitors |
| `ttt_detective_pct` | `0.13` | Share of players who become detectives |
| `ttt_detective_min_players` | `8` | No detectives below this player count |
| `ttt_minimum_players` | `2` | Players needed to start a round |
| `ttt_round_limit` | `6` | Rounds per map before it changes |
| `ttt_time_limit_minutes` | `75` | Maximum minutes on one map |

A typical public server tunes a few of these and leaves the rest:

garrysmod/cfg/server.cfg:

```cfg
hostname "Longship TTT | Karma on | Damage logs"
sv_password ""
sv_alltalk 0

ttt_firstpreptime 45
ttt_preptime_seconds 20
ttt_posttime_seconds 15
ttt_round_limit 8
ttt_time_limit_minutes 60
ttt_traitor_pct 0.25
ttt_detective_min_players 8
```

Leave `sv_alltalk` at `0`. TTT manages voice itself: the dead cannot talk to the living, and traitors have a private channel. Turning alltalk on hands dead players a microphone into the living game, which ends the deduction half of the gamemode.

Shorter prep and post times make the server feel busier, but the first prep time is when players are still loading the map, and cutting it too far means people spawn into the middle of a round. Forty-five seconds is a good compromise on a server with a large collection.

#### Karma: the setting that keeps it fair

Karma is TTT's built-in answer to random deathmatch - killing or hurting people on your own side. Every player starts with karma, loses it for damaging teammates, and earns it back over clean rounds. Karma scales the damage a player does: someone at low karma deals noticeably less damage, and below a threshold they are kicked or banned.

| Cvar | Default | What it does |
| --- | --- | --- |
| `ttt_karma` | `1` | Karma system on or off |
| `ttt_karma_strict` | `1` | Damage penalty falls off faster as karma drops |
| `ttt_karma_starting` | `1000` | Karma a new player starts with |
| `ttt_karma_max` | `1000` | Highest possible karma |
| `ttt_karma_low_autokick` | `1` | Kick players who end a round below the threshold |
| `ttt_karma_low_amount` | `450` | The threshold |
| `ttt_karma_low_ban` | `1` | Ban instead of only kicking |
| `ttt_karma_low_ban_minutes` | `60` | Length of that ban |
| `ttt_karma_persist` | `0` | Keep karma across disconnects and map changes |

`ttt_karma_persist 1` is the setting most public servers should change. Without it, a player who has wrecked their karma reconnects and starts fresh, which makes the system easy to dodge. With it on, karma is stored and follows the player back.

Karma is automatic and blunt. It catches obvious RDM and misses subtle griefing, and it occasionally punishes an honest mistake. Treat it as a filter, not a judge, and back it with damage logs and admins.

> [!TIP]
> Put your rules on RDM, ghosting and karma in the server's MOTD, and make sure staff apply the same rules. Most of the drama on a TTT server is not cheating, it is two admins ruling differently on the same kind of kill.

##### Credits and the equipment shops

Traitors and detectives buy equipment with credits from a shop opened with `C`. Traitors start with `ttt_credits_starting` credits (default `2`) and detectives with `ttt_det_credits_starting` (default `1`); more are awarded as innocents die and when detectives confirm bodies. Those two numbers decide how much of a round is about gadgets rather than guns. Raising them makes traitor rounds louder and shorter; lowering them makes traitors rely on deception. Leave them at the defaults until you have watched a few dozen rounds on your own server, then change one at a time.

Workshop weapon packs add items to these shops, and they are where balance goes to die. A single traitor item that kills a room without warning turns every round into the same round. Test each new shop item with staff before it goes public.

##### Rules, staff and RDM rulings

TTT generates more disputes than any other Garry's Mod gamemode, because the core mechanic is people lying and shooting each other on suspicion. A server stays fun when rulings are predictable. A workable setup:

1. Write a short rule list: what counts as RDM, what counts as reasonable suspicion, whether ghosting (dead players passing information) is banned, how many warnings before a ban.
2. Give staff the damage log and the ULX TTT commands, nothing more than that until they have proved themselves.
3. Rule from the log, not from chat. A complaint that says "he killed me for no reason" is answered by the log showing what the killer saw - a traitor weapon in hand, a body nearby, a shot fired first.
4. Prefer slaying a player at the start of the next round over kicking them for a first offence. It punishes the action without emptying the server.

Panel access is a different matter from in-game power. On RE:NODE a subuser can be limited to the console, without files or billing, which is the right level for a trusted moderator who restarts the server when a map hangs. [Server rules, moderation and staff](https://www.renode.space/blog/server-rules-moderation-and-staff) covers building a team that stays consistent.

#### Maps and the map vote

TTT maps carry the `ttt_` prefix and almost all of them come from the Workshop. Classic, widely played examples include `ttt_minecraft_b5` and `ttt_67thway_v14`, and every community has its own favourites. A good TTT map has hiding places, a traitor room or traps, decent weapon spawns and a size that suits your player count - a map built for 32 is empty with 10.

Weapon placement comes from the map itself, plus optional weapon spawn scripts: TTT can read a `maps/<mapname>_ttt.txt` file that places weapons and ammo, controlled by `ttt_use_weapon_spawn_scripts`. Community maps converted from other modes often rely on these.

Map changes happen after `ttt_round_limit` rounds or `ttt_time_limit_minutes`, whichever comes first. Without an addon the server moves through the map cycle; with a map vote addon - MapVote is the common choice on TTT servers - players pick from a list at the end of each map. Keep the list to fifteen or twenty maps you have tested with your player count and with and without CS:S content.

```diagram
title: How a TTT server reaches its players
ws = Workshop collection | maps and addons
srv = GMod server | +gamemode terrortown
css = CS:S content | mount.cfg
players = Players | own CS:S or see errors
vote = Map vote | after round limit
ws -> srv : host_workshop_collection
css -> srv : mounted
players <-> ws : downloads on join
srv -> players : rounds
srv -> vote
vote -> srv : next map
```

#### Addons TTT servers actually run

Every addon adds Lua that runs on the server, on clients, or both. These are the categories almost every public TTT server ends up with:

- **Admin mod.** ULX with ULib, or SAM. On TTT, add the TTT-specific command module for ULX, which adds commands such as slaying a player at the start of the next round and forcing roles for testing. [ULX and SAM for Garry's Mod](https://www.renode.space/blog/garrys-mod-ulx-and-sam-admin) compares the two.
- **Damage logs.** The single most important addon after admin. A damage log records every hit and kill with roles, so a staff member can open a menu and see whether that "RDM" was actually a traitor kill. TTT Damagelogs is the widely used one.
- **Map vote.** As above.
- **Custom weapons.** Workshop weapon packs that add guns to the traitor and detective shops. Add a few, not fifty. Unbalanced shop items are the fastest way to make a server feel random.
- **Pointshop.** Points earned for playing, spent on cosmetics. Popular, and the item models are extra downloads for every player. Points shops that sell gameplay advantages make for a worse server.

Keep addons to a list you can explain. Each addon is code with full access to the server, and some Workshop items include remote code loaders that let their author run Lua on your server later. Read an addon's code or reputation before installing it, and avoid anything that asks for HTTP access without a reason.

#### Performance and the first week

Most TTT servers that lag do so because of addons, not players. The common culprits are weapon packs with heavy effects, Pointshop item models, and addons running a `Think` hook for every player every tick. The diagnostic routine - watch for Lua errors in the console, remove half the addons on a test server, measure - is covered in [Garry's Mod performance and Lua errors](https://www.renode.space/blog/garrys-mod-server-performance-and-lua-errors).

Two habits keep a TTT server healthy:

1. **Restart daily at an empty hour.** Garry's Mod servers slowly accumulate memory and Lua state. On RE:NODE the Schedules tab runs a nightly restart from a cron expression, and the console graphs show memory against the plan's limit, so you can see whether it is creeping.
2. **Back up before changing the collection.** Your configs, ULX data and damage log settings are small files and easy to lose. A backup slot before each change costs nothing.

#### Troubleshooting

**The server starts in sandbox.** `+gamemode terrortown` is missing or misspelled, or a map with no TTT entities loaded. Check the startup line and the map prefix.

**Players see ERROR models and checkerboard textures.** Missing CS:S content on their side, or a Workshop item they did not download. Check `mount.cfg` on the server and tell players to mount CS:S.

**Rounds never start.** Fewer players than `ttt_minimum_players`, or everyone is in spectator mode. Check `ttt_minimum_players` and the spectator toggle in the F1 menu.

**No detectives appear.** Fewer than `ttt_detective_min_players` players, or detective karma requirements exclude everyone eligible. Lower the minimum on a small server.

**Karma resets when people reconnect.** `ttt_karma_persist` is `0`. Set it to `1`.

**The Workshop collection does not load.** Missing or invalid `-authkey`, or the collection is not public.

#### FAQ

##### Do I need to install TTT separately?

No. Trouble in Terrorist Town is bundled with Garry's Mod as the `terrortown` gamemode. Start the server with `+gamemode terrortown` on a `ttt_` map. TTT2 is a separate Workshop gamemode if you want the extended version.

##### Do players need Counter-Strike: Source for TTT?

For many maps, yes, to see textures and models correctly. Without it they see ERROR models. The server mounts CS:S content from the free CS:S dedicated server, but players must own CS:S themselves.

##### What is a good traitor percentage?

The default `0.25` - one traitor per four players - works for most servers. Small servers sometimes lower it so two traitors among eight does not feel crowded; large servers sometimes cap traitors with `ttt_traitor_max`.

##### Should karma be on?

Yes, with `ttt_karma_persist 1` so players cannot reset it by reconnecting. Karma does not replace admins and damage logs, but it filters out the worst random killing automatically.

##### Is TTT2 better than classic TTT?

It is bigger. TTT2 adds many roles and a large ecosystem, at the cost of complexity and addon compatibility. Classic TTT is simpler, lighter and still what many players expect. Pick one and build around it.

Garry's Mod servers on RE:NODE start from 1 GB and $5 a month, with launch variables on the Startup tab, a database slot for Pointshop or a SQL-backed admin mod, and backup slots on every plan. Addons go in through the Workshop, the file manager or SFTP - there is no whitelist.

[See Garry's Mod plans](https://www.renode.space/game-servers/garrys-mod)

---

### Garry's Mod ULX vs SAM admin permissions

Published 2026-10-07 by RE:NODE Team. https://www.renode.space/blog/garrys-mod-ulx-and-sam-admin

ULX with ULib is the free, long-standing admin mod for Garry's Mod; SAM is a paid alternative that is lighter on clients and stores ranks and bans in a database from the start. Either one gives you groups, per-group permissions, bans and a menu. The setup is the same shape for both: install the addon, restart, create the first superadmin from the server console because nobody has rights in game yet, build a small group ladder that inherits upward, and give each group only the commands it needs - with limits on whom it can target. The difference shows up later: ULX keeps its data in text files and SQLite on one server unless you add a MySQL addon, while SAM is built for several servers sharing one database. This guide covers both, the permissions model they share through CAMI, and the mistakes that let a moderator ban the owner.

#### What an admin mod does, and which ones exist

Garry's Mod has a basic notion of admin and superadmin built in, and nothing else: no groups, no bans with reasons, no menu. An admin mod adds:

- **Groups (ranks)** with inheritance, so a moderator inherits everything a trusted player can do.
- **Permissions** per command, per group, often with argument limits.
- **Targeting rules** - who a group may act on.
- **Bans** with reasons, lengths and history.
- **A menu**, chat commands and console commands.
- **A permission API** other addons use to ask "may this player do this?"

| Admin mod | Price | Storage | Notes |
| --- | --- | --- | --- |
| ULX + ULib | Free, open source | Text files and the server's SQLite | The default for a decade; huge addon support |
| SAM | Paid | SQLite, or MySQL for networks | Lighter client menu, built for multi-server |
| FAdmin | Bundled with DarkRP | DarkRP's database | Fine for small DarkRP servers; disable it if you install another |

Run exactly one. Two admin mods fight over the same chat commands and the same built-in admin flags, and the result is commands that work for some people and not others. On DarkRP, disable FAdmin before installing ULX or SAM - [the DarkRP server guide](https://www.renode.space/blog/garrys-mod-darkrp-server) shows the one line that does it.

#### Installing ULX and creating the first superadmin

ULX needs ULib, its library. Both are on the Workshop and on the authors' GitHub; use one source for both so their versions match. Add them to your Workshop collection or place them in `garrysmod/addons/`, then restart. [Garry's Mod Workshop and FastDL](https://www.renode.space/blog/garrys-mod-workshop-and-fastdl) covers collections if you have not set one up.

Nobody has permissions on a fresh install, so the first superadmin is made from the server console - the panel console or RCON - not from chat:

```text
ulx adduser "YourName" superadmin
ulx adduserid STEAM_0:1:12345678 superadmin
```

`ulx adduser` needs the player to be online and matches their name; `ulx adduserid` works with a SteamID whether they are online or not, which is the safer habit. Once you are superadmin, `ulx menu` - or `!menu` in chat - opens XGUI, the graphical menu where everything below can also be done.

ULX stores its data under `garrysmod/data/`:

```text
garrysmod/data/
  ulib/groups.txt     groups, inheritance, permissions
  ulib/users.txt      who is in which group
  ulx/config.txt      ULX settings, executed at start
  ulx/motd.txt        message of the day
```

These are plain text and easy to fix by hand when you lock yourself out - stop the server, edit, start. Recent ULib versions keep bans in the server's SQLite database (`garrysmod/sv.db`) rather than a text file; older versions used a file. Back up both the `data/ulib` folder and `sv.db`.

#### Groups and inheritance in ULX

ULX ships with four groups, each inheriting from the one below:

```text
superadmin -> admin -> operator -> user
```

You will usually want your own names and a slightly longer ladder. Create groups with the group they inherit from:

```text
ulx addgroup vip user
ulx addgroup moderator vip
ulx addgroup senioradmin admin
ulx groupallow moderator "ulx kick"
ulx groupallow moderator "ulx gag"
ulx groupallow moderator "ulx mute"
ulx groupallow moderator "ulx slay"
ulx groupallow moderator "ulx goto"
ulx groupallow moderator "ulx bring"
ulx groupdeny moderator "ulx noclip"
```

`groupallow` grants a command to a group and everything that inherits from it; `groupdeny` removes it. Grant at the lowest group that should have a command, and let inheritance do the rest. `ulx userallow` and `ulx userdeny` exist for one-off exceptions, but per-user permissions are hard to audit later - prefer a group.

A sensible ladder for a public server:

| Group | Inherits | Typical commands |
| --- | --- | --- |
| `user` | - | `ulx motd`, `ulx votemap` |
| `vip` | `user` | Cosmetic perks, reserved slot |
| `moderator` | `vip` | Kick, gag, mute, slay, goto, bring, short bans |
| `admin` | `moderator` | Longer bans, map change, noclip, jail |
| `superadmin` | `admin` | Everything, including `ulx rcon` and `ulx luarun` |

> [!WARNING]
> `ulx luarun` and `ulx rcon` run arbitrary code and console commands on the server. Any group with either one can do anything the server process can - read files, edit groups, ban you. Treat superadmin as equivalent to your panel password and keep it to one or two people.

#### Targeting rules: stopping a moderator banning you

Inheritance decides what a group can do. Targeting decides whom it can do it to. Without a targeting rule, a moderator with `ulx kick` can kick an admin, and a moderator with `ulx ban` can ban the owner. ULib's target strings fix that:

| Target | Means |
| --- | --- |
| `^` | Yourself |
| `*` | Everyone |
| `@` | The player you are looking at |
| `#group` | Members of exactly that group |
| `%group` | Members of that group and every group inheriting from it |
| `$id` | A player by SteamID or unique ID |
| `!` | Negates the next target |

`ulx setgroupcantarget` sets a group's targeting limit:

```text
ulx setgroupcantarget moderator !%moderator
ulx setgroupcantarget admin !%admin
```

The first line means moderators can target anyone except moderators and the groups that inherit from them - admins and superadmins included. That single command removes the most common staff-abuse incident on a Garry's Mod server. Set it for every staff group as soon as the group exists.

XGUI also lets you restrict command arguments per group, such as the longest ban a moderator may give or the maximum slap damage. Use it: a moderator who can ban for an hour but not permanently makes fewer mistakes that you have to undo.

#### Bans, logging and the everyday commands

| Command | Effect |
| --- | --- |
| `ulx kick <player> [reason]` | Remove a player |
| `ulx ban <player> [minutes] [reason]` | Ban an online player; `0` is permanent |
| `ulx banid <steamid> [minutes] [reason]` | Ban by SteamID, online or not |
| `ulx unban <steamid>` | Lift a ban |
| `ulx gag <player>` / `ulx mute <player>` | Block voice / block text chat |
| `ulx slay`, `ulx slap`, `ulx freeze`, `ulx jail` | Punishments in place |
| `ulx goto`, `ulx bring`, `ulx return` | Teleport to, teleport here, send back |
| `ulx map <map> [gamemode]` | Change map, optionally gamemode |
| `ulx asay <message>` | Message only admins see (also `@` in chat) |
| `ulx who` | List players with their groups |

ULX logs admin actions to `garrysmod/data/ulx_logs/` when logging is on, one file per day. That log is how you answer "who banned my friend" a week later; keep `ulx logFile 1` (with `ulx logEvents 1` and `ulx logChat 1` if you want the context) in `data/ulx/config.txt` and skim it weekly. [Server rules, moderation and staff](https://www.renode.space/blog/server-rules-moderation-and-staff) covers how to run a staff team that uses all this consistently.

##### Reserved slots and VIP perks

A `vip` group is where most servers put the perks for supporters and regulars, and the most common perk is a reserved slot. ULX handles this itself: the reserved-slot settings live in `data/ulx/config.txt` as `ulx rslotsMode`, `ulx rslots` and `ulx rslotsVisible`, and the group that gets the slot is the one granted the reserved-slot access. The modes differ in whether slots are held empty for admins or someone is kicked to make room; the comments in `config.txt` describe each, and they are worth reading before you pick one, because the kick-to-make-room mode surprises regular players who get dropped mid-round.

Keep VIP perks cosmetic or convenient. A paid group that can noclip, spawn weapons or avoid punishment turns a community server into a pay-to-win one, and depending on the game it can also break the publisher's rules for community servers. [Monetising a game server within the rules](https://www.renode.space/blog/monetising-a-game-server-within-the-rules) covers where that line sits.

#### Designing a staff ladder that lasts

Permissions are the easy part. What makes an admin setup hold up for years is the process around it.

1. **Start new staff on a trial group.** A `trialmod` group that inherits from `vip` with kick, gag, mute and nothing else. Promote after a few weeks of good judgement, visible in the logs.
2. **Grant the smallest set that does the job.** Every command a moderator does not have is a mistake they cannot make. Bans longer than a day can wait for an admin.
3. **Write down what each group is for.** One line per group in your staff channel. When someone asks for a new permission, the question becomes "does this match the group's purpose" rather than "do I like this person".
4. **Review the logs.** Ten minutes a week reading `ulx_logs` catches abuse long before players complain about it.
5. **Remove access the same day someone leaves.** `ulx removeuserid <steamid>` in game, their panel subuser removed, and any shared password - RCON, database - rotated if they ever had it. A former staff member with an old superadmin entry is how many servers get wiped.

The same ladder translates directly to SAM's ranks, so none of this is wasted if you switch later.

#### SAM: setup and how it differs

SAM is sold through a Garry's Mod addon marketplace, installed as a normal addon folder, and licensed per purchase. Like ULX, it starts with no admins, so the first rank is set from the server console - SAM's console command for this is `sam setrank` with a name or SteamID and the rank, though check the documentation for your version in case the syntax has changed. After that, the in-game menu does the rest.

The differences that matter when choosing:

- **Storage.** SAM uses SQLite by default and supports MySQL through the MySQLOO module, so several servers can share ranks and bans from one database. ULX can do the same only with a third-party MySQL addon.
- **Client weight.** SAM's menu is lighter than XGUI, which helps on servers with many addons where client Lua load time is already long.
- **Model.** Ranks with permissions and inheritance, targeting by rank immunity rather than ULib target strings. The concepts map across; the commands do not.
- **Ecosystem.** ULX has a decade of addons written directly against it - TTT command packs, logging addons, MOTD plugins. SAM supports CAMI, and has its own modules for common gamemodes.

For MySQL, MySQLOO is a binary module: a `.dll` file in `garrysmod/lua/bin/` built for the server's platform and branch. On the 64-bit server branch it needs the 64-bit build. Each game plan on RE:NODE includes a database slot with a generated host, user and password; check the engine it provides against what SAM or your ULX MySQL addon expects before migrating ranks into it.

```diagram
title: How addons ask for permission through CAMI
player = Player | runs a command
addon = Any addon | e.g. a door system
cami = CAMI | shared privilege API
admin = ULX or SAM | groups and ranks
db = Storage | files, SQLite or MySQL
player -> addon
addon -> cami : may this player?
cami -> admin
admin <-> db
admin -> cami : yes or no
```

#### CAMI: why your addons do not care which you pick

CAMI, the Common Admin Mod Interface, is a small shared library that lets any addon register a privilege and ask whether a player has it, without knowing which admin mod is installed. Both ULX and SAM support it. A gamemode that registers "may edit doors" through CAMI shows up as a permission in XGUI or in SAM's menu automatically, and you grant it to a group like any other command.

Two practical consequences. When you switch admin mods, CAMI-aware addons keep working; you only re-grant their privileges in the new mod. And when an addon's feature is missing for a staff member, look in the admin mod for a privilege the addon registered - it is usually there, granted only to superadmin by default.

#### Panel access is a separate question

In-game admin and server administration are different jobs. A moderator who needs to restart the server after a crash does not need the files, the database credentials or billing. On RE:NODE the panel's subusers and roles grant console access only, files only, or other narrow sets of permissions, with a per-server activity log, and access can be time-boxed. Pair that with the in-game ladder: a trusted admin might have console in the panel and `admin` in ULX, while nobody but the owner has file access and superadmin. [Subusers and least privilege](https://www.renode.space/blog/subusers-and-least-privilege) has the details, and [game server admin account security](https://www.renode.space/blog/game-server-admin-account-security) covers protecting the accounts themselves.

#### Troubleshooting

**`ulx adduser` says the player was not found.** They are offline or their name is ambiguous. Use `ulx adduserid` with the SteamID.

**Commands work for superadmins but not for a new group.** The group was created without inheriting from `user`, or the command was granted to a group it does not inherit from. Check the group's parent in XGUI.

**A moderator banned an admin.** No targeting rule. Set `ulx setgroupcantarget` for every staff group.

**Two menus open, or chat commands do nothing.** Two admin mods are installed - often FAdmin on DarkRP. Disable one.

**Ranks reset after a restart.** The data files were not writable, or a Workshop update replaced a legacy addon folder. Check `data/ulib/` timestamps and keep a backup.

**You locked yourself out after editing `groups.txt` by hand.** A missing brace or quote makes ULib discard the file and fall back to defaults, leaving nobody with rights. Stop the server, restore the file from a backup or fix the syntax, start again, and use `ulx adduserid` from the console if you still have no rights.

**An addon's admin feature is missing for staff.** It registered a CAMI privilege that only superadmin has by default. Find it in XGUI's permissions list or SAM's rank editor and grant it to the right group.

**MySQLOO fails to load.** Wrong platform or architecture build in `lua/bin/`. Match the module to the server branch.

#### FAQ

##### Should I use ULX or SAM?

ULX if you run one server, want something free and rely on addons written for ULX. SAM if you run several servers that should share ranks and bans, or want a lighter client menu and are happy to pay for it.

##### How do I make myself superadmin in ULX?

From the server console, not chat: `ulx adduserid <your SteamID> superadmin`. In-game commands need permissions you do not have yet.

##### Can I move from ULX to SAM without losing bans?

Yes, but it is a migration rather than a switch. SAM provides import tools for common admin mods; check its documentation, back up `data/ulib` and `sv.db` first, and test on a copy.

##### Where does ULX store groups and users?

In `garrysmod/data/ulib/groups.txt` and `garrysmod/data/ulib/users.txt`. ULX settings are in `garrysmod/data/ulx/config.txt`, and recent ULib versions store bans in `garrysmod/sv.db`.

##### Why can my moderators kick admins?

Because nothing stops them by default. Use `ulx setgroupcantarget moderator !%moderator` so moderators cannot target their own group or anyone above it.

Garry's Mod servers on RE:NODE come with a panel console you can use before any in-game admin exists, subusers with console-only access for staff, a database slot for SQL-backed admin mods, and backup slots on every plan to keep `data/ulib` and `sv.db` safe.

[See Garry's Mod plans](https://www.renode.space/game-servers/garrys-mod)

---

### Garry's Mod DarkRP server: install and jobs

Published 2026-09-21 by RE:NODE Team. https://www.renode.space/blog/garrys-mod-darkrp-server

DarkRP is a Garry's Mod gamemode, which means installing it is two folders and a launch parameter: the gamemode itself in `garrysmod/gamemodes/darkrp/`, and the `darkrpmodification` addon where all your changes live. Everything after that - jobs, shipments, salaries, who can ban whom - is Lua you edit in the addon and never in the gamemode. A server that follows that one rule survives DarkRP updates. A server that edits the gamemode directly loses every customisation the first time it updates, which is how most people learn the rule.

#### What DarkRP needs before you start

DarkRP runs on the standard Garry's Mod dedicated server, installed with SteamCMD as app `4020` under an anonymous login. The [Garry's Mod server setup guide](https://www.renode.space/blog/gmod-server-setup) covers the base install; this post assumes you have a server that starts in sandbox and accepts connections.

Two things DarkRP needs that sandbox does not:

- **Counter-Strike: Source content.** The classic DarkRP maps - `rp_downtown_v4c_v2` and most of its descendants - use CS:S textures and models. Without them your city is purple and black checkerboard. On a dedicated server you install the CS:S dedicated server content with SteamCMD (app `232330`) and point Garry's Mod at it in `garrysmod/cfg/mount.cfg`.
- **A plan with room for addons.** DarkRP itself is small. The workshop collection is not. A typical public DarkRP server carries a few gigabytes of addons before it has a single custom job.

garrysmod/cfg/mount.cfg:

```cfg
"mountcfg"
{
    "cstrike"   "/home/container/cstrike/cstrike"
}
```

The path is to the folder that contains `cstrike`'s own content directories. Get it wrong and nothing complains at startup; you find out when you load the map.

| Players | RAM | Notes |
| --- | --- | --- |
| Up to 16, small addon list | 2 GB | Comfortable for a private server |
| 24-32, normal DarkRP | 3-4 GB | The common public server |
| 40-64, large collection | 6 GB | Addon list is now the limiting factor |

One hard limit to know before you buy anything: the default Garry's Mod dedicated server is a 32-bit process, and a 32-bit process falls over somewhere around 3 GB of resident memory no matter what the plan allows. Garry's Mod also publishes an x86-64 branch which lifts that ceiling. If your server crashes at a consistent player count with no error, memory address space is the first suspect, not the plan.

#### Installing DarkRP and darkrpmodification

DarkRP and its modification addon are both published by FPtje on GitHub. Download the current release of each, or clone them.

1. Unpack DarkRP into `garrysmod/gamemodes/darkrp/`. The folder name must be exactly `darkrp`, lowercase, and it must contain `darkrp.txt` and a `gamemode/` folder. A zip from GitHub unpacks as `DarkRP-master`, so rename it.
2. Unpack the modification addon into `garrysmod/addons/darkrpmodification/`. Same rule: rename it from `darkrpmodification-master`.
3. Start the server with `+gamemode darkrp` and a DarkRP map.
4. Watch the console through the whole first start. Lua errors at load are the only warning you get that something did not install.

```bash
$ ./srcds_run -game garrysmod -console -port 27015 \
    +gamemode darkrp +map rp_downtown_v4c_v2 +maxplayers 40
```

On a panel the same values are fields on the Startup tab rather than a command you type, but they are the same values. Add `sv_defaultgamemode "darkrp"` to `garrysmod/cfg/server.cfg` as well, so a map change does not silently drop you back into sandbox.

Lowercase everything. Garry's Mod on Linux is case sensitive, and an addon folder named `MyAddon` with materials under `Materials/` produces missing textures that work perfectly on a Windows test server. This is the most common single cause of "it worked at home".

The structure you will actually be editing:

```text
garrysmod/addons/darkrpmodification/lua/
    darkrp_config/
        settings.lua           # every DarkRP setting
        disabled_defaults.lua  # switch off built-in jobs, entities, modules
        mysql.lua              # database connection
    darkrp_customthings/
        jobs.lua
        entities.lua
        shipments.lua
        food.lua
        ammo.lua
        doorgroups.lua
        agendas.lua
        categories.lua
```

Nothing in `gamemodes/darkrp/` should ever be touched. If a guide tells you to edit a file in there, it is out of date by about a decade.

#### Settings

`darkrp_config/settings.lua` arrives with every setting already present, each with a comment explaining it and its default. You change values in place; you do not add keys that are not already in the file.

darkrp_config/settings.lua:

```lua
GM.Config.startingmoney = 500
GM.Config.normalsalary  = 45
GM.Config.propertytax   = false
GM.Config.adminsents    = true
GM.Config.voiceradius   = true
```

The four decisions that shape a server more than any others:

- **Starting money and salary together set the economy's pace.** A high salary with cheap shipments means everyone has everything within an hour and the roleplay collapses into deathmatch. It is easier to start stingy and raise it than the other way round, because you cannot take money back from people who already have it.
- **Property tax** charges players for owned doors on each paycheck. It stops a handful of players owning the whole map and going inactive. It also drives new players away if they cannot afford a house at all.
- **Admin-only spawnable entities** (`adminsents`) keeps sandbox props and SENTs away from ordinary players. On a roleplay server, leave it on.
- **Voice radius** makes voice chat local rather than global, which is the single change that makes a server feel like roleplay instead of a lobby.

Changes to `settings.lua` are read when the gamemode loads, so they need a map change or a server restart. Testing them one at a time is slower and far quicker overall than changing fifteen and wondering which one broke jobs.

#### Jobs

Jobs live in `darkrp_customthings/jobs.lua` and are created with one function call. This is the whole API:

jobs.lua:

```lua
TEAM_MECHANIC = DarkRP.createJob("Mechanic", {
    color = Color(50, 100, 180, 255),
    model = {
        "models/player/gasmask.mdl",
        "models/player/riot.mdl",
    },
    description = [[Repair vehicles. Charge too much for it.]],
    weapons = {"weapon_physgun"},
    command = "mechanic",
    max = 3,
    salary = 60,
    admin = 0,
    vote = false,
    hasLicense = false,
    candemote = true,
    category = "Citizens",
})
```

The fields that matter and are routinely got wrong:

- `command` is what players type, so `/mechanic` here. It must be unique across every job.
- `max` is how many players can hold the job. `0` is unlimited. A decimal below 1 is read as a fraction of the current player count, so `max = 0.1` means ten per cent of the server - much better than a fixed number for police on a server whose population swings.
- `admin` is `0` for everyone, `1` for admins, `2` for superadmins.
- `TEAM_MECHANIC` is a global. Two jobs sharing a name means one silently replaces the other.
- `category` must match a category created with `DarkRP.createCategory`, or the job does not appear in the F4 menu even though it loaded fine.

For jobs restricted to donators or a staff rank, DarkRP has `customCheck`:

```lua
customCheck = function(ply)
    return CLIENT or table.HasValue({"superadmin", "vip"}, ply:GetUserGroup())
end,
CustomCheckFailMsg = "This job is for VIP members.",
```

The same file's neighbours work the same way. `DarkRP.createEntity` adds a buyable entity such as a printer, `DarkRP.createShipment` adds a weapon shipment with an `allowed` list of jobs that may buy it, `DarkRP.createFood` adds an item that restores health, and `DarkRP.createDoorGroup` lets you mark doors in the map as ownable only by certain jobs. Built-in jobs and entities you do not want are removed in `disabled_defaults.lua` rather than deleted from the gamemode.

> [!WARNING]
> A syntax error in `jobs.lua` - one missing comma - stops the whole file loading, and the server starts anyway with only the default jobs. If your new jobs did not appear, the answer is in the first twenty lines of the startup console, not in the config.

#### Admin: FAdmin, ULX and SAM

DarkRP ships with its own admin mod, **FAdmin**. It is adequate for a small private server and it knows about DarkRP concepts like jobs and doors. It is also the reason most ULX installs behave oddly on DarkRP, because two admin mods fighting over the same commands is exactly as much fun as it sounds. If you install another one, turn FAdmin off first:

darkrp_config/disabled_defaults.lua:

```lua
DarkRP.disabledDefaults["modules"]["fadmin"] = true
```

**ULX** with **ULib** is the free standard. Install both addons, restart, then create the first superadmin from the server console - not from in-game, because nobody has permission yet:

```text
ulx adduser "YourName" superadmin
ulx addgroup vip user
ulx groupallow vip ulx kick
```

ULX stores its groups in `garrysmod/data/ulib/groups.txt` and its users in `garrysmod/data/ulib/users.txt`. Both are plain text, both are worth backing up, and both are easier to fix by hand than through the menu when you lock yourself out. `ulx menu` opens XGUI in game for everything else.

**SAM** is the paid admin mod most large DarkRP servers moved to. It keeps ranks and bans in MySQL rather than text files, which matters once you run more than one server, and it is noticeably lighter in the client menu. Whether that is worth paying for depends entirely on whether your staff team is three friends or fifteen people you have never met.

Whichever you pick, keep the superadmin list short. A superadmin in any GMod admin mod can run arbitrary Lua on your server, which is the same thing as having your panel password. Panel access is a separate question with a better answer: [subusers and least privilege](https://www.renode.space/blog/subusers-and-least-privilege) lets a moderator use the console without being able to delete the server or see your billing.

#### The database

DarkRP stores money, owned doors and a few other things through MySQLite, which defaults to SQLite: a single file at `garrysmod/sv.db`. For one server that is genuinely fine. It is fast, it needs no configuration, and it has exactly one failure mode - the file. Back it up with everything else.

You want a real database when you run more than one server and want shared money, when you want to query or fix data without shutting the server down, or when you install an addon that expects MySQL anyway. The connection goes in `darkrp_config/mysql.lua`:

darkrp_config/mysql.lua:

```lua
DarkRP.registerDatabaseConfig{
    EnableMySQL      = true,
    Host             = "db.example.net",
    Username         = "s7_user",
    Password         = "generated-password",
    Database_name    = "s7_gmod",
    Database_port    = 3306,
    Preferred_module = "mysqloo",
    MultiStatements  = false,
}
```

That needs the `mysqloo` binary module in `garrysmod/lua/bin/`, and the file has to match the server's platform and architecture. Garry's Mod names these with a `.dll` extension even on Linux, which surprises everybody: `gmsv_mysqloo_linux.dll` for a 32-bit server and `gmsv_mysqloo_linux64.dll` for the x86-64 branch. The wrong one loads as nothing at all and DarkRP quietly falls back, so if money keeps resetting after you switched to MySQL, that file is why.

Every RE:NODE game plan includes one database slot created from the panel, with the host, user and password generated for you and an Open in phpMyAdmin button that signs you in with a single-use token. That covers the credentials above without you administering anything.

#### Keeping the server yours

DarkRP servers are targeted more than any other Garry's Mod gamemode, because there is an entire cottage industry of exploit menus aimed at them. Three settings and one habit deal with most of it.

garrysmod/cfg/server.cfg:

```cfg
hostname "Northside RP"
rcon_password ""
sv_password ""
sv_lan 0
sv_allowcslua 0
sv_allowupload 0
sv_allowdownload 1
sbox_godmode 0
sbox_noclip 0
```

`sv_allowcslua 0` is the important one. It blocks clients from running their own clientside Lua, which is the mechanism behind most of the free "DarkRP exploit" menus people download. `sv_allowupload 0` stops clients pushing files to your server. Leaving `rcon_password` empty disables RCON, which you do not need because you have a panel console - the reasoning is in [RCON, safely](https://www.renode.space/blog/rcon-safely).

The habit is not installing leaked paid addons. A leaked script is the most reliable way to get a backdoor onto a Garry's Mod server, and the person who uploaded it to a forum is not the author. [Keeping a modded server clean](https://www.renode.space/blog/keeping-a-modded-server-clean) covers how to audit what you already have.

#### Performance and troubleshooting

**Jobs did not appear.** A Lua error in `jobs.lua`. Read the console from the top of the startup, not the bottom.

**Purple and black textures, or ERROR signs.** Missing content. Textures are CS:S or a map's own material pack; ERROR models are an addon the client did not download. Client downloads are a separate system covered in [Workshop addons and FastDL](https://www.renode.space/blog/garrys-mod-workshop-and-fastdl).

**Money resets every restart.** The database is not writing. Either `sv.db` is not writable, or MySQL is enabled with a missing or mismatched `mysqloo` module.

**Everything broke after a DarkRP update.** Something was edited inside `gamemodes/darkrp/`. Reinstall the gamemode clean and move the change into `darkrpmodification`.

**The server drags only when it fills.** Almost always an addon with a loop that runs per player. A hundred printers each on their own timer costs the same whether four people are online or forty, but the per-player loops scale with the room. Remove half your addons, measure, then remove half of what is left.

**Consistent crash at the same player count.** Memory, and probably the 32-bit ceiling described earlier rather than the plan's limit.

Raising `-tickrate` costs CPU in direct proportion to players and buys less than people expect on a gamemode that is mostly standing still and talking - [what tick rate actually means](https://www.renode.space/blog/what-tick-rate-actually-means) has the honest version. Spend the CPU on the addon list instead.

On RE:NODE, a Garry's Mod plan comes with one port allocation, which covers the game and query port on `27015`; add another on the Network tab if you want SourceTV. The console is unfiltered, which is where a broken addon announces itself, the file manager edits `jobs.lua` in the browser with syntax highlighting, and backup slots are included on every plan - worth using before every addon change, because [a backup nobody has restored is a hypothesis](https://www.renode.space/blog/backups-that-actually-restore).

#### FAQ

##### Do I need Counter-Strike: Source for a DarkRP server?

For the usual maps, yes. `rp_downtown_v4c_v2` and most classic RP maps use CS:S textures. Install the CS:S dedicated server content with SteamCMD and mount it in `cfg/mount.cfg`, or pick a map that ships all its own content.

##### Where do I add custom jobs?

In `addons/darkrpmodification/lua/darkrp_customthings/jobs.lua`, using `DarkRP.createJob`. Never inside `gamemodes/darkrp/`. The modification addon exists precisely so DarkRP updates do not overwrite your work.

##### Should I use ULX or SAM?

ULX is free, well documented and fine for most servers. SAM is paid, stores ranks in MySQL and is lighter in game. Either way, disable DarkRP's built-in FAdmin first, or the two will argue over the same commands.

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

Two gigabytes for a private server with a short addon list, three to four for a normal public one at 32 players. Above that the addon list is usually the constraint, and the 32-bit server binary will stop you somewhere near 3 GB regardless.

##### Can I change jobs without restarting?

Not reliably. Jobs are registered when the gamemode loads, so a map change or a restart is the honest way to apply edits. Get into the habit of batching config changes and restarting once.

##### Why does my server show no addons for players who join?

Because mounting an addon on the server and telling clients to download it are two different systems. The server runs what is in `addons/`; clients only get what the workshop collection or `resource.AddWorkshop` tells them to fetch.

Garry's Mod servers on RE:NODE start from 1 GB, with SFTP and an in-browser file editor for `darkrpmodification`, an unfiltered console where Lua errors are readable, a database slot with phpMyAdmin sign-in for MySQL-backed DarkRP, and backup slots on every plan. Ports are addable on the Network tab when you need a second one.

[See Garry's Mod plans](https://www.renode.space/game-servers/garrys-mod)

---

### Garry's Mod Workshop addons and FastDL

Published 2026-09-21 by RE:NODE Team. https://www.renode.space/blog/garrys-mod-workshop-and-fastdl

Garry's Mod has two completely separate content systems and almost every "my players see ERROR signs" problem comes from confusing them. One is what the **server** loads and runs: addons in `garrysmod/addons/`, or a workshop collection mounted at startup. The other is what **clients** download before they can see any of it: workshop items Steam fetches for them, and loose files pulled over HTTP from a FastDL host. Mounting an addon on the server does not give it to players, and telling players to download something does not make the server run it. Once that is clear, the rest is mechanical.

#### What the server runs

The server loads content from three places, in practice:

- **Folders in `garrysmod/addons/`.** A legacy addon is a folder containing the usual directories - `lua/`, `models/`, `materials/`, `sound/`, `maps/`, `resource/` - and it is mounted as if those files were in `garrysmod/` itself.
- **`.gma` files in `garrysmod/addons/`.** The packed format. Same result, one file instead of a tree. The `gmad` tool in the server's `bin/` folder unpacks one if you need to look inside or serve its files another way.
- **A workshop collection**, mounted at startup with the `+host_workshop_collection` launch parameter. Items are downloaded into `garrysmod/cache/workshop/` as `.gma` files and mounted from there.

Anything the server itself needs to run - admin mods, your gamemode, server-side scripts - belongs in `addons/`, installed by hand. Do not put those in the client collection: you will be pushing an admin mod's UI to every player who joins for no reason. The [DarkRP server guide](https://www.renode.space/blog/garrys-mod-darkrp-server) has the same split from the gamemode side.

Every file path must be lowercase. Garry's Mod on Linux is case sensitive, and an addon that ships `Materials/Models/Thing.vmt` works on a Windows test server and produces purple checkerboard on a real one. This is the single most common cause of content that "works for me".

#### Workshop collections

A collection is the easiest way to run a server, and for most servers it is the right answer.

1. Create a collection on the Steam Workshop for Garry's Mod, add the addons every player needs, and set it Public.
2. Take the ID from the URL - the number after `?id=`.
3. Add `+host_workshop_collection 2519472571` to the launch parameters, or put it in the Startup tab field your panel provides.

At startup the server fetches the collection's item list, downloads anything it does not already have, and mounts it. Joining clients are told to download the same items, and Steam does that for them - out of your bandwidth, into their Steam workshop cache, where it stays for next time.

Reading the collection contents needs a Steam Web API key, passed on the command line with `-authkey`. You generate one from Steam's developer page against your own account. If the console reports that it could not retrieve the collection, that key is the first thing to check, and the Garry's Mod wiki is the place to confirm the current requirement, because this has changed over the years.

```bash
$ ./srcds_run -game garrysmod -console -port 27015 \
    -authkey XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX \
    +host_workshop_collection 2519472571 \
    +gamemode darkrp +map rp_downtown_v4c_v2 +maxplayers 40
```

What a collection is good at: updates. When an addon author publishes a fix, the server picks it up on next restart and every client's Steam updates to match. Hand-uploaded addons do not do that, and a server and client disagreeing about what version of an addon is installed is how you get errors nobody can reproduce.

What it is bad at: size. Everything in the collection is a download for every new player, and there is no partial join. A four-gigabyte collection is a ten-minute wait on a good connection before anybody sees your server, and most people will not wait.

The server's copy accumulates too. Remove an item from the collection and its `.gma` stays in `garrysmod/cache/workshop/` forever. On a plan with 10 or 20 GB of disk that is worth clearing out occasionally; delete the cache folder and the server re-downloads only what the collection currently lists.

#### resource.AddWorkshop, for finer control

`host_workshop_collection` is all-or-nothing. When you want a specific addon downloaded by clients without tying it to the server's mounted collection - or you want the list in version control rather than on a Steam page - use `resource.AddWorkshop` in a server autorun file:

garrysmod/lua/autorun/server/workshop.lua:

```lua
resource.AddWorkshop("104815552")   -- map pack
resource.AddWorkshop("2151453461")  -- shared props
resource.AddWorkshop("180530595")   -- weapon base
```

The ID is a string, not a number. The file runs at server start, so changes need a restart.

This adds the addon to the client download list. It does not mount anything on the server, which is exactly what you want for content that only the client needs to render - and exactly the trap if you assumed it installed the addon. If the server needs the addon too, it still has to be in the collection or in `addons/`.

Both approaches can coexist. A common arrangement on a large server is a small collection for the things the server genuinely mounts, plus a `resource.AddWorkshop` list for client-side content, kept in a file alongside the rest of the configuration. The general mechanics of workshop content on dedicated servers, across games, are in [Steam Workshop mods on dedicated servers](https://www.renode.space/blog/steam-workshop-mods-on-dedicated-servers).

#### Loose files and the slow way to send them

Not everything is on the Workshop. Custom maps, a logo, a font, a sound pack you made - these are loose files in the server's own folders, and clients need them too. You tell the client with `resource.AddFile`:

garrysmod/lua/autorun/server/resources.lua:

```lua
resource.AddFile("maps/rp_yourmap_v2.bsp")
resource.AddFile("materials/logo/banner.vmt")
resource.AddFile("materials/logo/banner.vtf")
resource.AddSingleFile("sound/ambient/radio_loop.wav")
```

Paths are relative to `garrysmod/`. `resource.AddFile` on a `.mdl` also queues the model's companion files; `resource.AddSingleFile` adds exactly one file and nothing else.

Here is the part people miss. With nothing else configured, those files are sent over the game's own network channel, which is slow by design - it was built for a server icon, not a content pack. `net_maxfilesize` caps the size of any single file, and the default is modest. A player joining a server with fifty megabytes of loose files on the game channel will sit at the download screen long enough to change their mind.

That is the problem FastDL solves.

```diagram
title: Where a joining player gets each kind of content
game = Game server | sends resource list
player = Player | joining
steam = Steam Workshop | collection items
fast = FastDL host | HTTP, .bz2
game -> player : list of required content
player -> steam : workshop addons
player -> fast : loose files and maps
player -> game : spawns in
```

#### Setting up FastDL

FastDL is just a web server. You put a copy of the content in a directory that mirrors `garrysmod/`, and you tell the game server where it is:

garrysmod/cfg/server.cfg:

```cfg
sv_downloadurl "https://files.yourserver.net/gmod"
sv_allowdownload 1
sv_allowupload 0
```

The URL points at the directory that contains `models/`, `materials/`, `sound/`, `maps/`, `resource/` and `particles/` - the same names, the same nesting, all lowercase. A client that needs `materials/logo/banner.vtf` requests exactly that path underneath your URL. No directory listing is needed and none should be enabled.

HTTPS works and is what you should use. What does not work reliably is a URL that redirects, so point at the real location rather than a shortener or a redirecting front door.

`sv_allowdownload 1` must stay on: it is what allows any client download at all, including over HTTP. Turning it off does not force players to have the content already, it just leaves them without it.

Compress everything. The client asks for `banner.vtf.bz2` before it asks for `banner.vtf`, so upload the compressed copy and the download is a fraction of the size:

```bash
$ cd /var/www/gmod
$ find . -type f ! -name '*.bz2' -exec bzip2 -k {} \;
```

`-k` keeps the original, which is worth doing while you are testing. Once you trust the setup, the `.bz2` files alone are enough.

Where to put it: any static web hosting will do, and it wants disk and bandwidth rather than CPU. A small [web hosting](https://www.renode.space/web-hosting) plan serves the directory perfectly well, takes the files over SFTP or the file manager, and includes a proxy slot - point an A record at the address shown and the certificate is issued and renewed for you, so `https://files.yourserver.net` works without you touching certbot. [Your domain and its certificate](https://www.renode.space/blog/your-domain-and-its-certificate) covers the DNS side.

One honest note on bandwidth: a FastDL host serving a 2 GB pack to every new player on a busy night moves real traffic. Unmetered means you are not billed per gigabyte, not that saturating a shared uplink is fine - [bandwidth and fair use](https://www.renode.space/blog/bandwidth-and-fair-use) is the version of this conversation nobody enjoys having later.

#### Which system for which content

| Content | Server gets it from | Client gets it from |
| --- | --- | --- |
| Workshop addon everyone needs | collection | Steam |
| Client-only workshop content | not mounted | `resource.AddWorkshop` |
| Admin mod, server scripts | `addons/` | nothing |
| Custom map not on the Workshop | `maps/` | FastDL |
| Your own materials and sounds | `addons/` | FastDL |

The honest default for a new server: put everything you can on the Workshop and use a collection, and keep FastDL for the handful of things that are not on it. Steam's delivery is faster than yours, it is cached on the player's machine between sessions, and it updates itself. Servers that put a mirror of their entire workshop content on FastDL are usually solving a problem they invented.

#### Keeping the download small

This is the part that decides whether people join twice.

- **Audit the collection by size, not by count.** A single high-resolution vehicle pack can outweigh thirty scripts. The Workshop shows file size on each item's page.
- **Delete the duplicate weapon bases.** Most servers accumulate three overlapping packs because each new addon shipped one.
- **Prop packs are for maps that use them.** If no map or job references it, it is pure download.
- **Decide what is required versus what is nice.** A player does not need your staff team's custom player models to play.
- **Test the real number.** Join with a Steam account that has never been on the server, from a normal connection, and time it. Under two minutes is good. Over five and you are losing people.

Disk on the server matters too. A Garry's Mod install is a few gigabytes before addons, the workshop cache grows with the collection, and demos and logs accumulate. Fast storage shortens the mount time at startup, which is most of what you feel on a restart - [what NVMe actually changes](https://www.renode.space/blog/what-nvme-actually-changes) puts realistic numbers on that.

#### Troubleshooting missing content

**Purple and black checkerboard.** A missing material. Either the client did not download it, or the path case is wrong on a Linux server, or the addon ships the `.vmt` without the `.vtf`.

**ERROR signs floating in the world.** A missing model. Same three causes, different file type.

**Only some players see it.** Their `cl_downloadfilter` is set to something other than `all`. `none` blocks every download and `nosounds` blocks audio; both are things people set once years ago and forgot. You cannot change it for them, but you can tell them.

**Everyone downloads forever, then times out.** FastDL path is wrong. Open the URL for one specific file in a browser - if `https://files.yourserver.net/gmod/materials/logo/banner.vtf.bz2` does not download, neither will the game. A 404 here is the whole problem.

**The workshop collection did not load.** Check the console at startup for the collection fetch, confirm the collection is Public, and confirm the API key. A private or friends-only collection fails silently from the server's point of view.

**Content works locally, breaks on the server.** Case sensitivity, nine times out of ten. Rename everything to lowercase, including directory names, and restart.

**An addon updated and now nothing works.** Workshop addons update under you. If a server is stable and you need it to stay stable for an event, that is an argument for hand-installed `.gma` files for that week - and the [base server setup guide](https://www.renode.space/blog/gmod-server-setup) covers where they go.

On RE:NODE, the file manager unpacks an uploaded archive in place, so a `.gma` or a content pack goes straight into `addons/`, and SFTP handles bulk uploads when a collection is too big to drag into a browser. The console is unfiltered, which is where the collection fetch and every missing-file complaint appear. Backup slots are on every plan, which is worth using before an addon audit rather than after it.

#### FAQ

##### Do players download addons from my server or from Steam?

From Steam, for anything in the workshop collection or added with `resource.AddWorkshop`. Only loose files - custom maps, your own materials and sounds - come from your server or your FastDL host.

##### Is FastDL still needed if I use the Workshop?

Only for content that is not on the Workshop. Most servers need it for a custom map and a handful of files, and nothing else. If everything you run is a workshop addon, you can skip FastDL entirely.

##### Why does the server mount addons that clients do not get?

Because they are two lists. The server mounts what is in `addons/` and in the collection; clients download what the collection and the `resource.Add` calls tell them to. An admin mod is deliberately in the first list and not the second.

##### How big should my collection be?

Small enough that a new player joins inside two minutes. In practice that means keeping the client-required content well under a gigabyte. Server-only addons do not count towards it, which is another reason to keep them out of the collection.

##### Do I need a Steam Web API key?

For `host_workshop_collection`, yes - the server needs it to read the collection's item list, and it is passed with `-authkey`. Addons installed by hand in `addons/` need no key at all.

##### Can I host FastDL on the game server itself?

No. A game plan runs the game, not a web server. Use any static web hosting for the directory, point `sv_downloadurl` at it, and keep the files compressed with bzip2.

Garry's Mod servers on RE:NODE start from 1 GB with NVMe storage, SFTP and an in-browser file manager that unpacks archives in place, an unfiltered console for tracking down missing content, and backup slots on every plan. A small web plan alongside it serves FastDL with a domain and an automatically renewed certificate.

[See Garry's Mod plans](https://www.renode.space/game-servers/garrys-mod)

---

### Garry's Mod server setup: addons and Workshop

Published 2026-07-17, updated 2026-09-21 by RE:NODE Team. https://www.renode.space/blog/gmod-server-setup

Garry's Mod is a sandbox in the literal sense: the server runs whatever Lua your addons contain, and the performance you get is a property of that code rather than of the game. Two servers on the same plan can behave completely differently, and the difference is the addon list. The install itself is one SteamCMD command and a start line; everything after that is content delivery, Lua discipline and a handful of console variables. A sandbox server for a dozen friends fits in 1-2 GB. A forty-slot DarkRP server with a large Workshop collection wants 4-6 GB and will still be limited by one CPU core.

#### What you are actually running

A Garry's Mod server is a Source dedicated server - `srcds` - running the `garrysmod` game directory, with app id `4020` on Steam. It installs anonymously, needs no game licence, and is small compared with most modern games. On top of that sits the Lua sandbox: a gamemode, any number of addons, and the Workshop plumbing that gets them onto players' machines.

Three facts shape everything else:

- **The server is 32-bit by default.** The standard branch runs a 32-bit binary that can address roughly 3-4 GB whatever your plan says. A server that dies with an allocation error while the panel shows memory free is not being throttled; it hit the 32-bit ceiling. There is a `x86-64` beta branch that installs 64-bit binaries alongside the 32-bit ones, and it is worth using for big collections - but every compiled binary module you use has to exist in a 64-bit build too.
- **Lua runs on one thread.** Everything the gamemode and every addon do happens in sequence, inside the tick. No amount of extra cores makes a badly written `Think` hook cheaper.
- **Clients need the same content you do.** The server owning an addon means nothing by itself. Getting it to the player is a separate job, and it is where most "my server is broken" reports come from.

#### Requirements and resource usage

| Server | RAM | CPU | Notes |
| --- | --- | --- | --- |
| Sandbox, 8-16 players, small collection | 1-2 GB | 1 core | The usual friends-only server |
| TTT / murder / prop hunt, 16-24 | 2-3 GB | 1-1.5 cores | Round-based modes are well behaved |
| DarkRP, 32-40 players | 4-6 GB | 2-2.5 cores | Entities, jobs and printers, all Lua |
| Anything with a 200-item collection | 4-6 GB | 2+ cores | Memory is the collection, not the players |

Memory in Garry's Mod tracks the size of the Workshop collection much more closely than the player count. Each addon's Lua, models and materials are held by the server, and a hundred prop packs cost the same whether one person is connected or forty. Disk is modest - the base install is a couple of gigabytes, and a large collection adds several more.

CPU is the ceiling everyone actually meets. The number to watch is the server's frame time: if the server cannot finish a tick inside its budget, movement stutters for everybody at once. Run `stats` in the console and read the `fps` and `cpu` columns; on a healthy server `fps` sits at or just above your tick rate. Garry's Mod plans here start at 1 GB and run to 6 GB, which covers everything from a sandbox box to a busy roleplay server.

#### Installing the server and the launch line

```bash
$ steamcmd +force_install_dir /home/gmod/server +login anonymous \
    +app_update 4020 validate +quit
$ cd /home/gmod/server
$ ./srcds_run -game garrysmod -console -usercon -port 27015 \
    +maxplayers 24 +gamemode sandbox +map gm_construct \
    +host_workshop_collection 123456789 -authkey <steam_web_api_key>
```

On a panel you do not type that; the same values appear as fields on the Startup tab. Either way these are the parameters that matter:

| Parameter | What it does |
| --- | --- |
| `-game garrysmod` | Which game directory srcds loads |
| `-console` | Run in the console rather than opening a window |
| `-usercon` | Enables RCON. Without it `rcon_password` does nothing |
| `-port 27015` | Game port |
| `+maxplayers 24` | Slot count. Cannot be changed without a restart |
| `+gamemode sandbox` | Gamemode folder name under `garrysmod/gamemodes` |
| `+map gm_construct` | First map loaded |
| `+host_workshop_collection` | Workshop collection id the server downloads at boot |
| `-authkey` | Steam Web API key, required for the line above to work |
| `-tickrate 33` | Ticks per second, set explicitly |
| `+sv_setsteamaccount` | Game Server Login Token |

Two of those deserve more than a row. `-authkey` is a Steam Web API key from Steam's developer page, and without it `host_workshop_collection` silently downloads nothing - the server starts, the collection is ignored, and players arrive to a sandbox with none of your addons. And `-tickrate` is worth setting rather than inheriting: sources disagree about what Garry's Mod defaults to, so put a number in the start line and stop guessing. 33 is a sensible floor for a prop-heavy sandbox, 66 for anything where aim matters. Doubling the tick rate roughly doubles the per-player CPU cost and does nothing for a server that is already behind - [what tick rate actually means](https://www.renode.space/blog/what-tick-rate-actually-means) is the longer version of that argument.

If the server never appears in the browser, check for a Game Server Login Token as well as the port. Tokens are created against app id `4000` for Garry's Mod and set with `sv_setsteamaccount`; [Steam game server tokens](https://www.renode.space/blog/steam-game-server-tokens-gslt) explains what they are, how they get banned and why one per server matters.

#### server.cfg and the sandbox limits

`garrysmod/cfg/server.cfg` is executed on every map load. A reasonable starting file:

garrysmod/cfg/server.cfg:

```cfg
hostname "Prop hunt, Thursdays, no minges"
sv_password ""
rcon_password "long-random-string"
sv_lan 0
sv_region 3
sv_allowcslua 0
sv_kickerrornum 10

sv_allowdownload 1
sv_allowupload 0
sv_downloadurl "https://files.example.com/gmod/"
net_maxfilesize 64

sbox_maxprops 150
sbox_maxragdolls 5
sbox_maxnpcs 10
sbox_maxeffects 50
sbox_maxvehicles 6
sbox_maxthrusters 30
sbox_maxwheels 30
sbox_maxdynamite 10
sbox_godmode 0
sbox_noclip 1
sbox_playershurtplayers 1

gmod_physiterations 4
```

You do not have to guess at defaults: type any cvar on its own in the server console and it prints its current value and the shipped default. A few of them carry more weight than their names suggest:

- `sv_allowcslua 0` stops clients running arbitrary client-side Lua on your server. Leave it at 0. Every guide that tells you to set it to 1 is a guide for a single-player test box.
- `sv_kickerrornum` removes a client after that many Lua errors. A client with a broken addon otherwise produces thousands of error lines a minute and buries anything useful in the console.
- `sbox_maxprops` is the difference between a sandbox server and a slideshow. The physics cost of props is not linear - one player welding a hundred barrels together costs more than ten players with ten props each.
- `gmod_physiterations` raises physics accuracy at a directly proportional CPU cost. Do not raise it to fix lag; it is the opposite of a fix.
- `sv_region` sets where the browser files your server. `3` is Europe.

Per-map settings go in `garrysmod/cfg/<mapname>.cfg`, executed after `server.cfg` when that map loads. That is the clean way to give one map different prop limits without a plugin.

#### Ports and connecting

| Port | Protocol | Purpose |
| --- | --- | --- |
| `27015` | UDP | Game traffic and Steam queries |
| `27015` | TCP | RCON, if `-usercon` is set |
| `27020` | UDP | SourceTV, if you enable it |
| `27005` | UDP | Outbound client port, nothing to open server-side |

Source uses the same number for game traffic and the server browser query, which is why Garry's Mod needs fewer allocations than DayZ or Arma. Garry's Mod plans here come with one allocation, and extra ports are added on the Network tab when you want SourceTV or a second server.

Players who cannot find the server in the browser can always join directly from their console with `connect 203.0.113.10:27015`. That is also the fastest diagnostic: if a direct connect works, the server is fine and the listing is the problem - a missing token, the wrong region, or the browser being the browser. [Game server ports explained](https://www.renode.space/blog/game-server-ports-explained) covers the query-versus-game-port distinction in general, and [RCON safely](https://www.renode.space/blog/rcon-safely) is worth five minutes before you put a password in that file, because `rcon_password` over the internet is a plaintext protocol with a single secret.

#### Workshop collections, FastDL and missing content

Point the server at a Workshop collection and let it fetch what it needs. Uploading addons by hand works right up until an update, at which point the server and every client disagree about what is installed and nobody can connect.

There are three separate routes content can take, and a working server usually uses all three.

```diagram
title: Three ways content reaches a player
collection = Workshop collection | host_workshop_collection
server = GMod server | resource.AddWorkshop
fastdl = FastDL web host | bz2 files
mount = Mounted game | CS:S content
client = Player
collection -> server : downloaded at boot
server -> client : workshop list at join
fastdl -> client : sv_downloadurl
mount -> client : owned by the player
```

**The Workshop collection** is for addons. Create one collection, make it public, put its id in `host_workshop_collection`, and add `-authkey`. The server downloads the addons for itself. To make clients download them too, list them in Lua:

garrysmod/lua/autorun/server/workshop.lua:

```lua
resource.AddWorkshop("1234567890")
resource.AddWorkshop("1234567891")
```

**FastDL** is for everything that is not a Workshop addon: legacy maps, sounds, custom models dropped into the game directory. Set `sv_downloadurl` to a web server holding a copy of your `garrysmod` folder structure, with each file bzip2-compressed. Without it clients download over the game port at a rate that feels broken. With it they download at whatever the web host can push. The full recipe, including the folder layout and the compression step, is in [Workshop collections and FastDL](https://www.renode.space/blog/garrys-mod-workshop-and-fastdl).

**Mounted games** are the case you cannot fix. Many community maps were built with Counter-Strike: Source textures. If the player does not own and have CS:S installed, they see purple-and-black checkerboards and `ERROR` models, and nothing you do on the server changes that - `garrysmod/cfg/mount.cfg` mounts content the machine already has, it does not create a licence. Either pick maps that only use Half-Life 2 content, or tell people plainly in your MOTD what they need.

> [!TIP]
> Keep prop-heavy addons out of the collection unless the gamemode actually uses them. Every addon in the collection is memory on the server and a download for every new player, and the download is the thing that loses you first-time visitors.

#### Gamemodes, admins and DarkRP

A gamemode is a folder in `garrysmod/gamemodes/`, and the folder name is what you pass to `+gamemode`. This trips up nearly everyone installing DarkRP for the first time: **DarkRP goes in `garrysmod/gamemodes/darkrp`, not in `addons`**, while `darkrpmodification` - the folder you are meant to edit - goes in `garrysmod/addons/darkrpmodification`. Putting either in the wrong place gives you a server that boots into sandbox and prints nothing obviously wrong. [Running a DarkRP server](https://www.renode.space/blog/garrys-mod-darkrp-server) goes through jobs, entities and the money system.

For administration, ULX with ULib is the free standard: both are addons, and ULib keeps its user list in `garrysmod/data/ulib/users.txt`. Admins use the in-game menu with `!menu`, and you can grant the first superadmin by editing that file with the server stopped if nobody is an admin yet. SAM and ServerGuard are paid alternatives with better interfaces and lower overhead; on a busy server the overhead is a real consideration, because admin mods hook into chat, spawning and damage.

Whatever you use, set it up before you invite anybody. An unmoderated Garry's Mod server discovers its first prop-spamming visitor within a day, and the tools to deal with them are useless if they are installed after the fact. [Keeping a modded server clean](https://www.renode.space/blog/keeping-a-modded-server-clean) covers the rest of that job - where addons come from, and what to check before you run someone else's Lua as root of your game loop.

#### Performance: where the tick goes

Most gamemodes are fine at their intended player count and fall apart above it, because a Lua loop that runs per player is cheap at twelve and expensive at forty. If the server drags only when it fills, the addon list is the place to look before the plan is.

A short diagnostic order that works:

1. `status` in the console - how many players, and are any of them at a terrible ping while everyone else is fine.
2. `stats` - server fps and CPU. If fps is at the tick rate and the CPU column is low, the server is not the problem.
3. Watch the console for Lua errors. A single addon erroring inside a `Think` hook runs its error handler thirty-three times a second per player. Errors name the addon path; that is usually the entire investigation. [Reading the console](https://www.renode.space/blog/reading-the-console) has more on what to keep and what to ignore.
4. Remove half the collection on a test server and measure again. Bisecting an addon list is unglamorous and it is the only method that reliably finds the culprit.

Two structural things help more than tuning. Keep the prop and entity limits low enough that players cannot make the server unplayable by accident - `sbox_maxprops` plus a cleanup timer on disconnect is most of it. And restart on a schedule. Garry's Mod servers accumulate entities, timers and memory over days; a nightly restart when nobody is on costs nothing and keeps frame times flat. [Restart schedules that help](https://www.renode.space/blog/restart-schedules-that-help) covers the interval, and the panel's Schedules tab runs it with a cron expression.

An empty server does almost nothing, by the way: srcds hibernates when the last player leaves, so an idle Garry's Mod server barely registers on a CPU graph. If yours does, something in your addon list is running a timer whether anyone is there or not, and that is worth finding.

#### Troubleshooting

**The server starts but has none of my addons.** Missing or invalid `-authkey`, or the collection is not public. Check the boot log for the Workshop download lines.

**Players spawn to `ERROR` models and checkerboard textures.** Missing content on the client. Workshop addons need `resource.AddWorkshop`; legacy content needs FastDL; CS:S content needs the player to own CS:S.

**Everyone downloads for two minutes and half of them leave.** No `sv_downloadurl`, so files are trickling over the game port. Set up FastDL.

**The server crashes with an out-of-memory error while memory looks free.** The 32-bit address space, not your plan. Trim the collection or move to the `x86-64` branch.

**"Reliable channel overflowed" disconnects.** An addon is sending too much data to clients at once, usually on spawn. Find it by removing addons; the client console names the last thing it received.

**A binary module stopped working after an update.** Modules in `garrysmod/lua/bin/` are compiled per platform and per branch. Switching to 64-bit, or a Garry's Mod update changing the runtime, needs the matching build of every module. [When a mod update breaks](https://www.renode.space/blog/what-to-do-when-a-mod-update-breaks) is the general case.

**The map changes and half the addons stop working.** Some addons only initialise on certain gamemodes, and some conflict. The console prints the Lua error on map load; read the first error, not the hundredth.

#### FAQ

##### How much RAM does a Garry's Mod server need?

1-2 GB for sandbox with a small collection, 2-3 GB for round-based gamemodes, and 4-6 GB for DarkRP or a large Workshop collection. The collection drives memory far more than the number of players, and the 32-bit binary cannot use much beyond 3-4 GB regardless.

##### Do players need to own the addons on my server?

No. Workshop addons listed with `resource.AddWorkshop` are downloaded by the client automatically. What they may need to own is another Valve game whose content a map uses - Counter-Strike: Source most often - and no server-side setting can supply that for them.

##### Why does my server not show in the server browser?

In order of likelihood: the query port is not reachable, no Game Server Login Token is set, `sv_lan` is 1, or the browser is simply slow. Test with `connect <ip>:27015` from the client console; if that works, only the listing is broken.

##### Should I run the 64-bit branch?

If your collection is large enough to crash a 32-bit server, yes. Otherwise it is a trade: more memory headroom against having to find 64-bit builds of every binary module you depend on.

##### Is a higher tick rate worth paying for?

Rarely. Going from 33 to 66 costs roughly double the CPU per player and helps only in gamemodes where shooting accuracy matters. A server that is already behind on frame time gets worse, not better.

##### How do I stop people spawning a thousand props?

Lower `sbox_maxprops` and the related `sbox_max*` limits, keep `sv_allowcslua` at 0, and install an admin mod with a cleanup command before you open the server to strangers. Limits set after the first incident are consolation, not prevention.

Garry's Mod servers on RE:NODE start at 1 GB with an unfiltered console - which is where a misbehaving addon announces itself - plus SFTP, an in-browser file editor for `server.cfg` and your Lua, backup slots on every tier, and a Schedules tab for the nightly restart.

[Compare Garry's Mod plans](https://www.renode.space/game-servers/garrys-mod)

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