# Assetto Corsa Server Hosting - everything RE:NODE has published

> A Assetto Corsa 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/assetto-corsa, 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/assetto-corsa.

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

## What it is

Assetto Corsa freeroam servers with AI traffic, on the custom server that supports them.

- Genres: Indie, Racing, Simulation, Sports
- Developer: Kunos Simulazioni
- Released: 19 Dec, 2014
- Steam: https://store.steampowered.com/app/244210/

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

### Which Assetto Corsa plan do you need?

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

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

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

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

### General questions

### Getting started

**How quickly is my server ready?**

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

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

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

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

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

**Can I try before buying?**

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

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

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

### Running the server

**Do I get full file access?**

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

**Can I install mods and plugins?**

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

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

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

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

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

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

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

### Backups and safety

**Are backups included?**

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

**Where are backups stored?**

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

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

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

### Billing

**How do I pay?**

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

**Can I pay in Georgian lari?**

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

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

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

**Can I upgrade or downgrade later?**

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

**Do you offer refunds?**

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

### Support and the honest bits

**How do I get help?**

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

**Where are the servers?**

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

**Is there an uptime guarantee?**

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

**Who actually runs this?**

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

## Plans and prices

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

| Plan | Price / month | Memory | CPU | NVMe disk | Databases | Backups | Ports |
|---|---|---|---|---|---|---|---|
| Starter | $8 | 2 GB | 1 vCPU | 20 GB | 1 | 2 | 2 |
| Standard | $11 | 3 GB | 1.5 vCPU | 30 GB | 1 | 2 | 2 |
| Advanced | $15 | 4 GB | 2 vCPU | 40 GB | 1 | 2 | 2 |
| Pro | $19 | 6 GB | 2.5 vCPU | 50 GB | 1 | 2 | 2 |
| Premium | $24 | 8 GB | 3 vCPU | 70 GB | 1 | 2 | 2 |


## Panel how-to

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

### Ordering a server

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

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

Open the shop and find what you want to run:

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

Compare the plans and pick one:

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

Choose how long, then pay:

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

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

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

After you pay:

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

### The console

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

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

### Files and SFTP

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

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

### Backups

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

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

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

### Subusers, roles and teams

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

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

### Scheduled tasks

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

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

### Games that need a key from you

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

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

## Tutorials

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

- [Assetto Corsa server with Content Manager](https://www.renode.space/blog/assetto-corsa-content-manager-and-tracks) (2026-10-07): Use Content Manager to build an Assetto Corsa server: presets, packing content, mod track and car folders, layouts and pit boxes, checksums, CSP and download links.
- [Assetto Corsa Server Manager championships](https://www.renode.space/blog/assetto-corsa-server-manager-championships) (2026-10-07): Run an Assetto Corsa league: Server Manager championships, points and classes, locked entry lists, sign-ups, reversed grids, pit windows and results files.
- [Assetto Corsa server: config, cars, tracks](https://www.renode.space/blog/assetto-corsa-server-guide) (2026-09-21): Run an Assetto Corsa dedicated server: server_cfg.ini and entry_list.ini explained, sessions, dynamic track, ports, mod content and AssettoServer.

---

### Assetto Corsa server with Content Manager

Published 2026-10-07 by RE:NODE Team. https://www.renode.space/blog/assetto-corsa-content-manager-and-tracks

Content Manager is the community launcher most Assetto Corsa players already use, and it is also the easiest way to build a server: its Server section edits presets that become `server_cfg.ini` and `entry_list.ini`, checks that every car, skin and track layout you chose actually exists, and can pack the server binary, config and the content data the server needs into one archive you upload to a host. Mod tracks and cars then work exactly like stock ones, with two conditions that cause nearly every failed join: the server and every driver must have the same version of each mod (the server checks file checksums), and the folder names in the config must match the folders on disk, character for character - on a Linux server, including capitals.

The server's own files are covered in detail in [the Assetto Corsa server guide](https://www.renode.space/blog/assetto-corsa-server-guide). This post is the content side: Content Manager's server presets, how track and car folders are laid out, layouts and pit boxes, what the server actually checks, Custom Shaders Patch requirements, and getting the right files to your drivers.

#### What Content Manager does for a server

Content Manager (CM) is a replacement launcher for Assetto Corsa, written by the community. For server admins it does four useful things:

- **Edits server presets** in a form instead of raw ini files - track and layout picker, car list, entry list with skins, sessions, weather and assists.
- **Validates content**: it knows which cars, skins and layouts are installed on your PC and flags anything missing before you run the server.
- **Runs the server locally**, so you can test a preset on your own machine before uploading anything.
- **Packs a preset** with the server binaries, config and the content data the server needs, ready to upload to a host.

CM has a free version and a paid full version that unlocks extra features. The server tools are usable without paying; if a specific option mentioned here is greyed out in yours, that is the likely reason.

CM stores presets in the game folder under `server/presets/`, one folder per preset (`SERVER_00`, `SERVER_01` and so on), each containing its own `server_cfg.ini` and `entry_list.ini`. Those are the same files `acServer` reads; CM is a front end, not a different format. That matters, because you can open the files a preset produced, read them, and edit them by hand on the server later without CM.

#### Building a preset

In CM, the server section lists presets on the left; create one and work through the tabs:

1. **Main**: name, password, admin password, the track and its layout, and the car list. Pick the layout explicitly - this sets `CONFIG_TRACK`.
2. **Entry list**: one row per grid slot, each with a car and a skin. CM shows the track's pit box count and warns when the list is longer.
3. **Rules and conditions**: assists, damage, fuel and tyre rates, sessions, time of day, weather, dynamic track.
4. **Run it locally** and join from the same PC. If you can join your own local server, the preset is valid.

Then pack it. The pack option produces an archive containing the server executable for the platforms you choose, the `cfg` folder, and a `content` folder holding only the data files the server needs from each car and track - not the textures and 3D models. A server folder built this way is a few megabytes per car rather than hundreds.

```diagram
title: From Content Manager on your PC to a hosted server
cm = Content Manager | preset and content
pack = Packed archive | binary, cfg, data
host = Hosted server | acServer
drivers = Drivers | full mod content
cm -> pack : pack preset
pack -> host : upload and unpack
drivers -> host : join, checksums compared
```

Upload the archive to the server and unpack it in place - a file manager that unpacks archives where they land saves a lot of time here - or extract locally and upload the folders over SFTP. [SFTP and the file manager](https://www.renode.space/blog/sftp-and-the-file-manager) covers both. On a host, the server binary is already installed, so what you need from the pack is `cfg/` and `content/`.

> [!TIP]
> Keep the CM preset as the master copy and treat the server's files as output. When you want to change the grid or the session, change the preset, test it locally, re-pack and upload. Hand-editing the server and the preset separately means the two drift, and the next upload undoes your server-side fix.

#### How track folders are laid out

Tracks live in `content/tracks/<track_folder>/`. The folder name is what goes in `TRACK=`, and it is often nothing like the display name: a mod track called "Circuit of the Example Hills" might live in `ex_hills_2024`. Read the folder, not the name in the menu.

A track with several layouts has a subfolder per layout, and `CONFIG_TRACK=` names one of them:

```text
content/tracks/ex_hills_2024/
  gp/
    data/
      surfaces.ini
      ...
  national/
    data/
  ui/
    gp/ui_track.json
    national/ui_track.json
  models_gp.ini
  models_national.ini
```

A single-layout track has its `data/` folder directly under the track folder, its UI files directly under `ui/`, and `CONFIG_TRACK` left empty.

| Track type | `TRACK=` | `CONFIG_TRACK=` |
| --- | --- | --- |
| Single layout | Folder name | Empty |
| Several layouts | Folder name | Layout subfolder name |
| Several layouts, left empty | Folder name | Usually fails at start |

**Pit boxes** are the hard limit on grid size. A track's `ui_track.json` for each layout states its pit box count, and `MAX_CLIENTS` and the entry list must not exceed it. Mod tracks vary widely here - a club circuit may have twelve, a converted public road five. CM shows the number when you pick the layout; check it before promising a 24-car grid.

#### How car folders are laid out

Cars live in `content/cars/<car_folder>/`, and `CARS=` in `server_cfg.ini` is a semicolon-separated list of those folder names.

```text
content/cars/ex_gt3_2024/
  data.acd
  skins/
    01_red/
    02_blue/
  ui/
    ui_car.json
  ...model and sound files
```

The physics data is usually packed into `data.acd`. Some mod cars ship an unpacked `data/` folder instead or as well. Either way, the physics data is part of what the server compares against each driver's copy, so two drivers with different builds of the same car folder are not interchangeable.

Skins are cosmetic. The entry list assigns one per slot with `SKIN=`, naming a folder under `skins/`. A driver who does not have that skin sees a default instead; it does not stop them joining. Skin packs are a nice touch for a league and not worth blocking anyone over.

#### Checksums: what the server actually compares

When a driver connects, the server compares checksums of key files in the driver's copy of the track and car with its own. Any difference and the driver is rejected. The comparison covers the files that affect driving - track surfaces and layout data, car physics - not textures, sounds or skins.

That has practical consequences:

- **The server needs the right data files, not full content.** That is why CM's packed content is small, and why a server with only `data.acd` and the track data folders works.
- **A visual mod does not break checksums**, but a mod that edits physics or surface data does. A "graphics update" for a track that also touches `surfaces.ini` is a different track as far as the server is concerned.
- **Re-downloading a mod can change it.** Mod sites reissue files quietly. "It worked last week" usually means one driver or the server got a newer build.
- **The error names the file.** Read it - a checksum failure on a track's surface data points to the track, on a car's data to that car.

> [!WARNING]
> Never fix checksum failures by giving the server a different build than the drivers. The fix is to agree on one build, publish exactly which one, and make the server match it. A server with its own private version of a car is a server nobody can join.

#### Linux servers and folder names

Most hosted Assetto Corsa servers run the Linux `acServer`. Linux file names are case-sensitive and Windows file names are not, which means a preset built on Windows can work perfectly on your PC and fail on the server.

If `TRACK=Ex_Hills_2024` and the folder is `ex_hills_2024`, Windows finds it and Linux does not. The same applies to car folders, layout folders and skin folders. The fix is to make the config match the folder exactly - copy names from the server's own file listing rather than from CM's display or from memory. When the server exits at start-up, its log names the folder it could not find; [reading the console](https://www.renode.space/blog/reading-the-console) is about getting that line quickly.

#### Custom Shaders Patch and requirements

Custom Shaders Patch (CSP) is a widely used extension to the game's renderer and engine. Many modern mod tracks and cars use CSP features - extra lighting, rain effects, physics extensions - and some do not work properly, or at all, without it.

For a server this raises a question the vanilla game never asked: what version of CSP must drivers have? CM's server settings can declare a minimum CSP version for a preset, so drivers without it are told before they join rather than discovering a broken track mid-session. AssettoServer, the open-source replacement for `acServer` described in the main guide, goes further and builds features on top of CSP - synchronised weather and time, traffic and more.

The decision is about audience. A public server that requires a recent CSP version excludes players with a plain install. A league whose drivers all run CSP gains a lot from requiring it. Either way, put the requirement in the server name or description, and publish it with the content list.

#### Getting content to your drivers

The vanilla server never sends content to drivers, so distribution is the admin's job. What works:

- **A content list with exact versions and links.** Car and track names, the folder names, the version, and where to download that version. Pinned in your Discord, updated whenever the server changes.
- **One archive for the whole set.** For a league, pack every car and track into one download hosted somewhere stable. Drivers drag it into CM, which installs Assetto Corsa content from archives.
- **Download links advertised by the server.** Community server wrappers and AssettoServer can expose download links for missing content to CM, so a driver who joins without a car is shown where to get it. This is the closest Assetto Corsa gets to download-on-join, and it depends on the tools you run, so check what your server software supports before promising it.

Keep the list next to your server backups. The configuration a league spent three weeks agreeing on is small and easy to lose; the content list is what lets you rebuild the server when a mod site disappears. [Backups that actually restore](https://www.renode.space/blog/backups-that-actually-restore) explains why to test the restore as well. On RE:NODE, backup slots come with every Assetto Corsa plan, so the `cfg` and `content` folders can be saved before each content change and restored with one button.

Server disk use grows with content even though only data files are needed. A traffic or freeroam server with dozens of cars and a large map can still reach several gigabytes, mostly from tracks. Clear out cars and tracks you no longer use when you change the preset; old content is the usual reason a server's disk fills.

#### Troubleshooting

**"Checksum failed" for a car.** The driver's build of that car differs from the server's. Compare versions and agree on one.

**"Checksum failed" for the track.** Same, for the track - often a graphics or update pack that also changed surface data.

**The server exits at start naming a folder.** A folder name or capitalisation mismatch, or `CONFIG_TRACK` empty on a multi-layout track.

**The grid starts with cars in odd places or the session breaks.** More entries than the layout has pit boxes.

**Drivers without CSP see a broken track.** The track needs CSP. Declare the requirement in the preset and the server name.

**The preset works locally, not on the host.** Linux case sensitivity, or content you did not upload. Compare the server's `content/` folder with the packed archive.

**Skins appear as defaults.** The driver does not have the skin pack. Cosmetic only.

#### FAQ

##### Do I need Content Manager to run an Assetto Corsa server?

No. `acServer` reads two ini files and a content folder, and you can write them by hand. Content Manager makes it faster and catches mistakes such as missing skins or too many entries for the pit boxes.

##### Does the server need the full mod car and track files?

No, only the data files used for checksums. Content Manager's packing option copies exactly those, which keeps the server small. Drivers need the full content to see and drive it.

##### Why do drivers fail the checksum on a mod track?

Their version differs from the server's. Many mod tracks have several builds and update packs in circulation. Publish the exact build and make sure the server has it too.

##### How do I choose a track layout on the server?

Set `TRACK=` to the track folder and `CONFIG_TRACK=` to the layout's subfolder name. In Content Manager, choosing the layout in the preset sets both.

##### Can the server send cars and tracks to players automatically?

The vanilla server cannot. Community wrappers and AssettoServer can advertise download links that Content Manager shows to drivers with missing content, which is the nearest equivalent.

##### Should my server require Custom Shaders Patch?

If your tracks or cars depend on it, yes, and say so in the server name. For a public server on stock or older content, leaving it optional lets more players join.

Assetto Corsa servers on RE:NODE start at 2 GB with two ports allocated, a file manager that unpacks a Content Manager archive in place, SFTP for larger content folders, and backup slots on every tier so each preset and its content can be kept and restored.

[See Assetto Corsa plans](https://www.renode.space/game-servers/assetto-corsa)

---

### Assetto Corsa Server Manager championships

Published 2026-10-07 by RE:NODE Team. https://www.renode.space/blog/assetto-corsa-server-manager-championships

Vanilla `acServer` does not know what a championship is. It runs the sessions you configure, loops them if you ask, and writes one JSON results file per session - standings, points and who is booked into which car are somebody else's problem. That somebody is usually Assetto Corsa Server Manager (ACSM), a free web front end that builds `server_cfg.ini` and `entry_list.ini` for each event, launches `acServer` itself, collects the results and turns them into a points table with classes, teams, sign-ups and penalties. If you would rather not run another program, the same league can be run from the two config files and a spreadsheet, and this guide covers both: the Server Manager way, and the settings underneath it that you need to understand either way.

If you have not set up the base server yet, start with the [Assetto Corsa server guide](https://www.renode.space/blog/assetto-corsa-server-guide), which goes through `server_cfg.ini`, sessions, ports and mod content key by key. This post assumes that works and moves on to running the same field of drivers week after week.

#### What vanilla acServer gives a league, and what it does not

Everything a league needs from the game itself is already there; it is just not joined up.

- **Results.** At the end of every session `acServer` writes a JSON file into its `results` folder, named with the date, time and session type - something like `2026_10_7_20_45_RACE.json`. It holds every car, every lap, best laps, total times and the contact events the server saw.
- **Fixed slots.** `entry_list.ini` with a `GUID` per entry and `LOCKED_ENTRY_LIST=1` gives each driver their own car, skin and grid slot.
- **Balance tools.** `BALLAST` and `RESTRICTOR` per entry, with `MAX_BALLAST_KG` in `server_cfg.ini` as the ceiling.
- **Race formats.** Practice, qualifying and race sessions in sequence, plus a reversed-grid second race and a mandatory pit window, all set in the config.

What it does not have is memory. Nothing carries over from one race night to the next: no points, no success ballast, no record that a driver was penalised last week. Every championship tool, ACSM included, is a layer that reads the results files, keeps state between events and writes new config files before the next one. Knowing that makes troubleshooting much easier, because almost every league problem is one of those three steps going wrong.

#### Assetto Corsa Server Manager in brief

ACSM is a single Go binary with a browser interface, originally built by Emperor Servers and published as open source on GitHub. The original repository is now archived and read-only, so you are running finished software rather than something that will change under you. That is mostly a comfort for a game that has not moved in years, but it does mean bugs will not be fixed upstream and forks are where any new work happens.

The pieces you configure live in `config.yml` next to the binary:

config.yml:

```yaml
steam:
  install_path: assetto
  executable_path: acServer
http:
  hostname: 0.0.0.0:8772
  session_key: generate-a-long-random-string
  server_manager_base_URL: https://league.example.com
store:
  type: boltdb
  path: server_manager.db
accounts:
  admin_password_override:
server:
  audit_logging: true
  performance_mode: false
  persist_mid_session_results: false
```

| Setting | What it does |
| --- | --- |
| `http.hostname` | Address and port of the web interface. `8772` is the shipped default |
| `http.session_key` | Encrypts login sessions. Set your own random value |
| `server_manager_base_URL` | Used for links in championship messages and sign-ups |
| `store.type` | `boltdb` keeps everything in one file; `json` writes one file per event |
| `store.path` | Where that data lives. This is the file to back up |
| `admin_password_override` | Emergency reset of the `admin` password |
| `audit_logging` | Records which user started, stopped or deleted what |
| `performance_mode` | Turns live timing off to save CPU |

The first login is the user `admin` with the password `servermanager`, and you are made to change it immediately. If you lose it later, put a temporary value in `admin_password_override`, restart, log in with it and set a new one. Create separate accounts for each steward rather than sharing the admin login; the audit log is only useful if names in it mean something.

> [!WARNING]
> The web interface listens on all addresses by default. If the machine is on the internet, so is the login page. Set a real password on the first login, and if only you need the interface, bind it to `localhost` and reach it through an SSH tunnel.

Where it runs matters. ACSM launches and stops `acServer` itself, so it wants to be the thing in charge of the process. That fits a machine you control - your own box or a [dedicated server](https://www.renode.space/dedicated-servers) - where you open `9600` TCP and UDP, `8081` TCP and the web port. On a game panel the panel is the process manager, so the practical pattern there is the file-based workflow described below: the panel runs `acServer`, and you replace the two config files between events.

#### Building a championship: classes, points and events

A championship in ACSM is a list of classes, a list of entrants and a list of events. Each event is a track, a layout, a session sequence and a start time; when you start an event, ACSM writes the config for that event, launches the server and attaches the results to the championship when the sessions finish.

##### Classes

A class is a set of cars plus its own points table. Single-make series need one class. A multi-class endurance grid - GT3 and GT4 sharing the track - needs one class per category, each scored separately, which is the only fair way to score a field where the slower class can never win overall.

##### Points

The default table is the Formula 1 one, and every field is editable per class:

| Field | Default | What it awards |
| --- | --- | --- |
| Places | 25, 18, 15, 12, 10, 8, 6, 4, 2, 1 | Points by finishing position in class |
| Best lap | 0 | Bonus for the fastest lap of the race |
| Pole position | 0 | Bonus for topping qualifying |
| Collision with driver | 0 | Points deducted per car-to-car contact |
| Collision with environment | 0 | Points deducted per wall contact |
| Cut track | 0 | Points deducted per counted cut |
| Second race multiplier | 1 | Scales points for a reversed-grid second race |

The collision and cut deductions are tempting and usually a mistake. The server counts every touch, including the one where somebody else punted you, so automatic deductions punish victims as readily as culprits. Leave them at zero and handle incidents with stewarding. A small best-lap bonus is fine; a large one rewards drivers who pit for fresh tyres in the last two laps instead of racing.

Ties are broken by countback - the driver with more wins ranks higher, then more second places, and so on - which is the convention most leagues use anyway. Publish it in your rules so nobody is surprised in the last round.

##### Events

Add events in calendar order and give each one the full session sequence: practice, qualifying, race, and a second race if you run them. You can copy an event and change only the track, which keeps session lengths and assists consistent across a season. Change one thing at a time between seasons, not between rounds.

#### Entry lists for a league

The entry list is where a league either feels organised or does not. You have three ways to fill it.

**A fixed list.** You add every driver yourself with their SteamID64 as the GUID, their car, skin and team. With a locked entry list, nobody else can take their slot and they always spawn in the same car. This is the most work and the least trouble.

**Open entrants.** The championship accepts whoever joins and adds them to the entrant list automatically. With the persist option on, the car and skin a driver first joins with become theirs for the season. This suits a public "Thursday night" series with a changing field; it does not suit a league with a waiting list.

**A sign-up form.** ACSM can publish a registration page where drivers enter their name, Steam GUID, team and preferred car and skin, optionally with custom questions and reCAPTCHA protection configured in the `championships` section of `config.yml`. Requests can be accepted automatically or approved by hand. Approved drivers land in the entrant list with their GUID filled in, which removes the most error-prone step - copying seventeen-digit numbers out of Discord messages.

Whichever you use, the rules from the base server still apply underneath:

- The number of entries, and `MAX_CLIENTS`, must not exceed the track's pit boxes. A 32-car grid does not fit on a 24-box track, and the failure looks like a broken session rather than a clear error.
- Every `MODEL` must be in the event's car list and every `SKIN` must exist in that car's `skins` folder on the server, or the server falls back or refuses the entry.
- Drivers need the same version of every mod car and track. Publish the content list with download links before round one - [Assetto Corsa content, Content Manager and mod tracks](https://www.renode.space/blog/assetto-corsa-content-manager-and-tracks) covers packaging it so people actually install it.

##### Ballast and restrictor

Two ways to use them. Fixed balance is a per-entry value set for the season - a rookie class or a handicapped veteran. Success ballast changes per round: the championship leader carries 30 kg, second 20 kg, and so on. Vanilla `acServer` has no idea who is leading, so success ballast means editing the entry list before each round, which ACSM's per-event entrant editing makes quick. Keep `MAX_BALLAST_KG` above the largest value you will use, or the server clamps it silently.

Restrictor is a percentage power cut and feels different from ballast: ballast hurts braking and cornering, restrictor hurts straights. For balancing different cars, use restrictor; for slowing a driver who is simply faster, ballast is less punishing on tracks with long straights.

#### Race formats: reversed grids, pit windows and race weekends

Most league formats are a handful of keys in `server_cfg.ini`, which ACSM exposes as form fields:

cfg/server_cfg.ini:

```ini
[SERVER]
LOCKED_ENTRY_LIST=1
PICKUP_MODE_ENABLED=0
MAX_BALLAST_KG=100
REVERSED_GRID_RACE_POSITIONS=8
RACE_PIT_WINDOW_START=10
RACE_PIT_WINDOW_END=20
RACE_EXTRA_LAP=0
QUALIFY_MAX_WAIT_PERC=120

[RACE]
NAME=Race
LAPS=25
WAIT_TIME=90
IS_OPEN=0
```

| Key | What it does |
| --- | --- |
| `REVERSED_GRID_RACE_POSITIONS` | `0` no second race; `N` runs a second race with the top N reversed; `-1` reverses the whole field |
| `RACE_PIT_WINDOW_START` / `_END` | The lap (or minute, in a timed race) range in which the mandatory stop must be made |
| `RACE_EXTRA_LAP` | `1` adds a lap after the timer runs out in a timed race |
| `QUALIFY_MAX_WAIT_PERC` | How long the server waits for drivers on a lap when qualifying ends, as a percentage of the best lap |
| `IS_OPEN` | `0` closes the race to late joiners; `1` lets them in; `2` lets them in until 20 seconds before the start |

The reversed grid is the classic two-race format: a sprint from qualifying order, then a second race with the top eight reversed. Pair it with a `Second race multiplier` below 1 - 0.5 is common - so the lottery race does not decide the title.

A pit window turns a sprint into a strategy race and is the closest vanilla gets to a mandatory stop. A driver who does not stop inside the window is penalised at the end. Explain it in the pre-race briefing; somebody always forgets.

ACSM also has **race weekends**: a chain of sessions that can be run at different times - qualifying on Wednesday, races on Thursday - where each session's grid is built from the results of an earlier one, with filters such as reversing or splitting the field. It is the feature to reach for when your grid is bigger than the pit boxes and you need a qualifying split into two races, or when people cannot commit to one long evening.

#### Running race night

A routine that keeps the evening calm:

1. **Before the night.** Confirm the content list is final, the entry list matches the approved drivers and the event's track layout is right. Start the event an hour early with practice open so problems surface before the grid forms.
2. **Thirty minutes before.** Post the server name, password and a reminder of the content versions. Most failed joins are checksum errors from somebody's out-of-date mod.
3. **During qualifying.** Watch live timing for drivers who have not set a time. Somebody missing at this point is usually stuck on a join error, not late.
4. **During the race.** One steward watches, nobody else touches the controls. Admin chat commands - `/admin` with the admin password, then `/kick`, `/next_session`, `/restart_session` - are for emergencies, not for adjusting results.
5. **After the race.** Let the results file write. Do not stop the server the instant the leader crosses the line: the results are written when the session ends, after `RACE_OVER_TIME`.

That last point catches organisers constantly. A server stopped mid-session writes nothing for that session. ACSM's experimental `persist_mid_session_results` option tries to protect against this by forcing a session change before stopping, but the safer habit is to let sessions end on their own.

#### Results, penalties and appeals

The results JSON is the source of truth. ACSM imports it into the championship automatically when the event ends, and you can also import a results file manually - which is how you recover a race that was run outside the championship by mistake, or on a different server.

Penalties are applied in the results view as time added or positions dropped, and points are recalculated from that. Set the stewarding process before the season starts:

- **A deadline for protests**, such as 24 hours after the race, with a replay timestamp required.
- **A small panel**, not one person, and not anyone involved in the incident.
- **A fixed penalty scale** - five seconds for a minor avoidable contact, a drive-through equivalent for a serious one - so decisions are consistent rather than personal.

Keep a copy of every raw results file even after penalties are applied. If a decision is overturned, you want the original to recalculate from rather than a chain of edits. [Server rules, moderation and staff](https://www.renode.space/blog/server-rules-moderation-and-staff) covers the human side of this in more depth, and [game server events and tournaments](https://www.renode.space/blog/game-server-events-and-tournaments) has the wider playbook for running organised nights.

##### The file-based alternative

Without ACSM, a league is three folders and a routine. Keep one pair of `server_cfg.ini` and `entry_list.ini` per round, named for the round, and copy the right pair into `cfg/` before the night. After the race, take the JSON from `results`, enter the finishing order into a spreadsheet with your points table and countback rule, apply penalties there, and update the next round's entry list with any success ballast. It is more manual and entirely workable for a twelve-car league, and it has one real advantage: every round's config and every result is a plain file you can read in ten years.

This is also how a league runs on a panel-managed server. On RE:NODE you edit both files in the browser editor or upload a round's pair over SFTP, download the results folder from the file manager, and restart the server from the console. A Schedules entry can restart the server into the next session sequence at a fixed time, and backups can be taken on demand right before race night. If you do want ACSM's web interface, that is a job for a machine you run the processes on yourself.

#### Backups and keeping a season safe

What is irreplaceable in a league is small, and that is exactly why people forget to copy it:

- `server_manager.db` (or the JSON store folder) - every championship, entrant, event and result in ACSM.
- `config.yml`, including the session key; losing it logs everybody out but loses no data.
- The `results` folder from `acServer`, which is your fallback if the database is ever damaged.
- Your content list with exact versions and links.

Back these up after every round, not weekly. A season is one file that changes once a week, which makes it the easiest thing in the world to protect and the most painful to rebuild from memory. [Backups that actually restore](https://www.renode.space/blog/backups-that-actually-restore) explains why one test restore before the season starts is worth more than any number of untested copies.

#### Troubleshooting

**The event started but the championship shows no results.** The session was stopped before it ended, so no results file was written. Check the `results` folder; if a file exists, import it manually.

**A driver is in the championship twice.** They joined once with a different Steam account, or open entrants added them before you did. Merge by keeping one GUID and deleting the duplicate before the next round, because points do not follow a name.

**Drivers are kicked as soon as they join.** Locked entry list with a GUID that does not match, a skin that does not exist, or a checksum error. The server log names which.

**The grid is shorter than the entry list.** `MAX_CLIENTS` or the track's pit boxes are lower than your entrant count. Use a race weekend with split qualifying.

**The second race never starts.** `REVERSED_GRID_RACE_POSITIONS` is `0`, or the race has no laps left to run after `RACE_OVER_TIME`. Check the value in the generated `server_cfg.ini`, not in the form.

**The web interface is unreachable.** The web port is not open, or `hostname` is bound to `localhost`. [Game server ports explained](https://www.renode.space/blog/game-server-ports-explained) covers testing one port at a time; [reading the console](https://www.renode.space/blog/reading-the-console) is about finding the line in the log that says which address it bound to.

#### FAQ

##### Is Assetto Corsa Server Manager still maintained?

The original open-source repository is archived and read-only. The software still works, because Assetto Corsa's server has not changed in years, but fixes and new features only appear in community forks.

##### Can I run a championship without Server Manager?

Yes. Keep a pair of config files per round, read the JSON results files after each race and score them in a spreadsheet. It is slower per round and much simpler to host, which suits small leagues on a panel-managed server.

##### How do I stop strangers taking league slots?

Put each driver's SteamID64 in the GUID field of their entry and set `LOCKED_ENTRY_LIST=1`. Add a join password as well, so the server does not fill with people who are then kicked.

##### What is the second race multiplier for?

It scales points for a reversed-grid second race. A value of 0.5 gives half points, which keeps the reversed race meaningful without letting a lucky result outweigh a full feature race.

##### Should I deduct points automatically for collisions?

Usually not. The server counts every contact regardless of fault, so automatic deductions punish the driver who was hit as well as the one who hit them. Stewarding with replays is fairer.

##### Where are race results stored?

In the `results` folder of the server, one JSON file per session. Server Manager imports them into its own database, but the raw files are worth keeping as a backup and an audit trail.

Assetto Corsa servers on RE:NODE start at 2 GB with two port allocations, `server_cfg.ini` and `entry_list.ini` editable in the browser, results downloadable from the file manager, and backup slots on every tier for the files a season depends on. Extra ports can be added on the Network tab if a timing plugin needs one.

[See Assetto Corsa plans](https://www.renode.space/game-servers/assetto-corsa)

---

### Assetto Corsa server: config, cars, tracks

Published 2026-09-21 by RE:NODE Team. https://www.renode.space/blog/assetto-corsa-server-guide

An Assetto Corsa dedicated server is `acServer`, a small headless program that ships with the game and is also a free SteamCMD download. It is configured by two text files, `cfg/server_cfg.ini` and `cfg/entry_list.ini`, it needs TCP and UDP on `9600` plus an HTTP port on `8081`, and 2 GB of memory will run a full grid. It does not distribute content: every driver must already own or have installed the exact cars and track you configured, or they are rejected at the checksum.

That last point is the one that surprises people arriving from other games. There is no download-on-join. A mod car server means telling your drivers what to install and where to get it, and a version mismatch in a single file produces a kick with a message nobody finds helpful. Get that right and the rest is a pleasant afternoon of picking session lengths.

#### What the Assetto Corsa dedicated server is

`acServer` is Kunos's own server binary. It holds the session structure, tracks lap times and positions, applies penalties, and relays car state between clients. Physics still run on each driver's machine; the server is the authority on who is where and what the session is doing.

Three properties define how you work with it:

- **It is single-threaded in practice.** The `NUM_THREADS` setting exists, but a full grid on one modern core is fine and adding cores does not make a server faster.
- **It serves content by reference, not by value.** `TRACK=ks_nordschleife` means "the track in everyone's `content/tracks/ks_nordschleife` folder". The server has a copy so it can compute checksums; it never sends it to anyone.
- **The HTTP port is not optional.** Lobby registration and the in-game server details panel both go through it. A server with `9600` open and `8081` closed runs perfectly and appears to nobody.

Assetto Corsa is old enough that the ecosystem around it matters as much as the base server. Content Manager is what nearly everybody uses to edit these files and to launch and browse servers, and AssettoServer is a full replacement for `acServer` that most modern freeroam and traffic servers run. Both are covered below, but learn the vanilla files first: everything else is built on them.

#### Requirements and resource usage

| Grid | RAM | vCPU | Notes |
| --- | --- | --- | --- |
| Up to 12 cars | 2 GB | 1 | Practice and small leagues |
| 16-24 cars | 2-3 GB | 1.5 | A normal race server |
| 24-32 cars | 3-4 GB | 2 | Limited by pit boxes more than by hardware |
| AssettoServer with AI traffic | 4-8 GB | 2-3 | The AI cars are simulated server-side |

- **CPU**: clock speed over cores, as above. The exception is AssettoServer running hundreds of AI traffic cars, which is a genuinely different workload and the one case where an Assetto Corsa server gets expensive.
- **Disk**: the server binary is tiny. Content is what fills a disk - a stock install is a couple of gigabytes, and a mod traffic server with fifty cars and a 100 km road network can reach tens of gigabytes.
- **Network**: every client's state is broadcast to every other client, so traffic grows roughly with the square of the grid size, multiplied by `CLIENT_SEND_INTERVAL_HZ`. A 24-car server is a real, if modest, upstream load. Latency and jitter are what drivers feel; see [latency, jitter and packet loss](https://www.renode.space/blog/latency-jitter-and-packet-loss).

#### Installing the server

The server folder is already in your game install at `steamapps/common/assettocorsa/server/`, containing `acServer.exe` and a Linux `acServer` binary. For a headless machine, pull it directly:

```bash
$ steamcmd +force_install_dir /home/ac/server +login anonymous \
    +app_update 302550 validate +quit
$ cd /home/ac/server
$ ./acServer
```

The layout is:

```text
acServer
cfg/server_cfg.ini
cfg/entry_list.ini
content/cars/
content/tracks/
```

Copy in the car and track folders you intend to use. For stock content you can take them from your game install; the server needs the data files for checksums, not the high-resolution textures, but copying the whole folder is simpler and disk is cheap. [SteamCMD explained](https://www.renode.space/blog/steamcmd-explained) has the general pattern for scripted installs and updates, and [SFTP and the file manager](https://www.renode.space/blog/sftp-and-the-file-manager) is the practical way to move a large content folder onto a hosted server.

#### server_cfg.ini: the settings that matter

cfg/server_cfg.ini:

```ini
[SERVER]
NAME=Thursday GT3 League
CARS=ks_ferrari_488_gt3;ks_mclaren_650_gt3;ks_porsche_911_gt3_r_2016
CONFIG_TRACK=
TRACK=ks_brands_hatch
SUN_ANGLE=16
PASSWORD=
ADMIN_PASSWORD=change-this
MAX_CLIENTS=20
UDP_PORT=9600
TCP_PORT=9600
HTTP_PORT=8081
CLIENT_SEND_INTERVAL_HZ=18
REGISTER_TO_LOBBY=1
PICKUP_MODE_ENABLED=1
LOCKED_ENTRY_LIST=0
LOOP_MODE=1
RACE_OVER_TIME=180
RESULT_SCREEN_TIME=60
ALLOWED_TYRES_OUT=2
START_RULE=2
DAMAGE_MULTIPLIER=50
FUEL_RATE=100
TYRE_WEAR_RATE=100
ABS_ALLOWED=1
TC_ALLOWED=1
STABILITY_ALLOWED=0
AUTOCLUTCH_ALLOWED=1
TYRE_BLANKETS_ALLOWED=1
FORCE_VIRTUAL_MIRROR=1
MAX_CONTACTS_PER_KM=5
KICK_QUORUM=85
VOTING_QUORUM=80
VOTE_DURATION=20
BLACKLIST_MODE=1
```

| Key | What it does |
| --- | --- |
| `NAME` | The name in the lobby. Put the class and the day in it |
| `CARS` | Semicolon-separated folder names from `content/cars` |
| `TRACK` | Folder name from `content/tracks` |
| `CONFIG_TRACK` | The layout, for tracks that have several. Empty for the default |
| `MAX_CLIENTS` | Grid size. Cannot exceed the track's pit boxes |
| `ADMIN_PASSWORD` | Typed in chat as `/admin password` to gain admin rights |
| `PASSWORD` | Join password |
| `PICKUP_MODE_ENABLED` | `1` lets drivers take any free slot. `0` is booking mode |
| `LOCKED_ENTRY_LIST` | `1` restricts each slot to the GUID listed for it |
| `LOOP_MODE` | `1` restarts the session sequence forever |
| `START_RULE` | `0` locked until green, `1` teleport to pits, `2` drive-through |
| `ALLOWED_TYRES_OUT` | Wheels allowed off track before a cut is counted. `-1` disables |
| `DAMAGE_MULTIPLIER` | Percentage. `0` is no damage, `100` is full |
| `FUEL_RATE`, `TYRE_WEAR_RATE` | Percentages of the real consumption |
| `ABS_ALLOWED`, `TC_ALLOWED` | `0` denied, `1` factory setting, `2` forced on |
| `STABILITY_ALLOWED` | Stability control. `0` for anything competitive |
| `MAX_CONTACTS_PER_KM` | Kicks drivers who keep hitting things. `0` disables |
| `KICK_QUORUM`, `VOTING_QUORUM` | Percentage of drivers needed to pass a vote |
| `CLIENT_SEND_INTERVAL_HZ` | Update rate to clients. `18` is the shipped value |
| `REGISTER_TO_LOBBY` | `1` lists the server publicly |

Some notes that save an evening:

- `CARS` and `TRACK` are **folder names**, not display names. `ks_brands_hatch`, not "Brands Hatch". Open `content/tracks` and copy what you see.
- `CONFIG_TRACK` is the layout subfolder. Brands Hatch has Indy and GP; Nordschleife has several. Leaving it empty on a track that has no default layout is a common reason the server exits at start.
- `MAX_CLIENTS` above the track's pit box count does not give you more cars. It gives you a server that misbehaves at session start. Check the track before you set a grid size.
- `CLIENT_SEND_INTERVAL_HZ` is the closest thing this game has to a tick rate setting. Raising it past the shipped value costs bandwidth for very little; if drivers report warping, look at packet loss first. [What tick rate actually means](https://www.renode.space/blog/what-tick-rate-actually-means) is worth reading before you turn this dial.
- `ADMIN_PASSWORD` is entered in the in-game chat as `/admin` followed by the password, after which commands such as `/kick`, `/ban`, `/next_session` and `/restart_session` are available to you.

The timing keys decide how a public server behaves when nobody is organising it. `LOOP_MODE=1` makes the session sequence repeat forever, which is what you want unless a person is present to restart it. `RACE_OVER_TIME` is how long stragglers get to finish after the winner crosses the line - 180 seconds is generous for a sprint and mean for an endurance race. `RESULT_SCREEN_TIME` is dead time at the end of every cycle, so on a busy pickup server keep it short.

The voting keys are worth setting deliberately rather than leaving at the defaults. `KICK_QUORUM=85` means it takes 85 per cent of the grid to remove somebody, which on a six-car server means everybody. If your server is public and unattended, lower it; if it is a league, raise it to 100 or turn voting off entirely and rely on `ADMIN_PASSWORD`, because a vote kick is a tool people misuse when a race goes badly.

There is also a plugin interface - `UDP_PLUGIN_LOCAL_PORT`, `UDP_PLUGIN_ADDRESS` and `AUTH_PLUGIN_ADDRESS` - which is how external tools such as lap time trackers and rating systems attach to a server. If you are not running one, leave all three empty.

#### Sessions, the dynamic track and weather

The session sequence is defined by which sections exist and in what order they are written. A server with only a `[PRACTICE]` section is an open practice server; add `[QUALIFY]` and `[RACE]` and you have a race weekend on a loop.

```ini
[PRACTICE]
NAME=Practice
TIME=20
IS_OPEN=1

[QUALIFY]
NAME=Qualify
TIME=15
IS_OPEN=1

[RACE]
NAME=Race
LAPS=12
WAIT_TIME=60
IS_OPEN=1

[DYNAMIC_TRACK]
SESSION_START=94
RANDOMNESS=2
LAP_GAIN=30
SESSION_TRANSFER=80

[WEATHER_0]
GRAPHICS=3_clear
BASE_TEMPERATURE_AMBIENT=20
BASE_TEMPERATURE_ROAD=6
VARIATION_AMBIENT=2
VARIATION_ROAD=1
WIND_BASE_SPEED_MIN=0
WIND_BASE_SPEED_MAX=10
WIND_BASE_DIRECTION=30
WIND_VARIATION_DIRECTION=15
```

`TIME` is minutes for practice and qualifying; a race uses `LAPS` instead, or `TIME` for a timed race. `WAIT_TIME` is the seconds on the grid before the lights go out. `IS_OPEN` controls whether latecomers may join a session in progress - set it to `0` on the race for a league and leave it at `1` for a public server, where refusing joins just means an empty server.

The dynamic track is grip as a percentage, and it is the most underused feature in the file. `SESSION_START=94` begins slightly green, `LAP_GAIN=30` means grip improves by one percent every thirty laps driven by the field, and `SESSION_TRANSFER=80` carries eighty per cent of the gained grip into the next session. Set the start below 90 and your first practice session will feel broken to anyone used to hotlapping offline, so tell people.

Weather sections are numbered from zero, and the server picks between them. `GRAPHICS` is the weather preset id, which is a folder name in the game's weather content, so mod weather works if everyone has it. `BASE_TEMPERATURE_ROAD` is an **offset above ambient**, not an absolute value: ambient 20 with road 6 means a 26 degree track. Getting that wrong is why a server sometimes has bizarre tyre behaviour.

#### entry_list.ini and the grid

Every slot on the grid is an entry. The number of entries must be at least `MAX_CLIENTS`, and neither may exceed the track's pit boxes.

cfg/entry_list.ini:

```ini
[CAR_0]
MODEL=ks_ferrari_488_gt3
SKIN=rosso_corsa
SPECTATOR_MODE=0
DRIVERNAME=
TEAM=
GUID=
BALLAST=0
RESTRICTOR=0

[CAR_1]
MODEL=ks_mclaren_650_gt3
SKIN=00_mclaren
SPECTATOR_MODE=0
DRIVERNAME=
TEAM=
GUID=76561198012345678
BALLAST=20
RESTRICTOR=0
```

Four fields do the work:

- `MODEL` must be one of the cars listed in `CARS`, and `SKIN` a folder under that car's `skins` directory.
- Leave `GUID` empty for an open slot. Fill it with a SteamID64 and, with `LOCKED_ENTRY_LIST=1`, that slot belongs to that driver alone - which is how a league guarantees everyone their number and livery.
- `BALLAST` in kilograms and `RESTRICTOR` as a percentage are the per-driver balance tools. They are the honest way to keep a mixed-ability league close, applied per entry rather than per car.
- `SPECTATOR_MODE=1` marks an entry as a non-driving observer slot.

Editing this by hand for a 24-car grid is tedious, and this is where Content Manager earns its place: it generates both files, checks that models and skins exist, and can pack a content set for your drivers.

#### Ports, the lobby and connecting

| Port | Protocol | Purpose |
| --- | --- | --- |
| `9600` | UDP | Car state |
| `9600` | TCP | Connection and chat |
| `8081` | TCP | HTTP: lobby registration and server details |

```diagram
title: How a driver reaches an Assetto Corsa server
driver = Driver | AC client
lobby = Kunos lobby | public server list
http = HTTP endpoint | port 8081
server = acServer | TCP and UDP 9600
server -> lobby : registers over HTTP
driver -> lobby : browses
driver -> http : entry list and details
driver <-> server : joins and races
```

All three need to be reachable from the internet. The classic failure is opening `9600` on both protocols, forgetting `8081`, and then not understanding why a server that friends can join by direct connection never appears in the list. [Game server ports explained](https://www.renode.space/blog/game-server-ports-explained) covers why a game splits itself across ports like this.

Drivers join through the in-game list, through Content Manager's browser, or by direct connection to `address:9600`. A hostname works as well as an address - [connecting a domain to a game server](https://www.renode.space/blog/connecting-a-domain-to-a-game-server) has the A record - and is worth setting up if you expect people to type it.

#### Mod content, AssettoServer and CSP

Mod cars and tracks are why Assetto Corsa is still alive a decade on, and they are entirely a distribution problem. The rules:

- Install the mod on the server exactly as on a client: the car folder into `content/cars`, the track folder into `content/tracks`.
- Every driver needs the **same version** of the same mod. Assetto Corsa checksums key files, and a driver with a different build of the same car is rejected with a checksum error. There is no partial compatibility.
- Publish the exact download link and version for everything on your server, and keep that list with your config backups. Mod sites reissue files quietly, and "it worked last week" usually means somebody re-downloaded.

AssettoServer is an open-source replacement for `acServer`. It reads the same `server_cfg.ini` and `entry_list.ini`, adds its own `extra_cfg.yml`, and provides the things the vanilla server never had: server-side AI traffic, real-time weather and time progression synchronised through Custom Shaders Patch, a plugin system, and much better admin tooling. Nearly every freeroam and traffic server you have joined is running it.

The trade is that the interesting features need Custom Shaders Patch on the client, so a CSP-dependent server is not joinable by a plain install. For a league running fixed sessions on stock content, vanilla `acServer` is simpler and entirely sufficient. For anything freeroam, AssettoServer is what you want, and the AI traffic is the part that needs the extra memory and CPU in the sizing table above.

#### Troubleshooting

**"Checksum failed" when a driver joins.** Their copy of a car or track differs from the server's. Same mod, different version, or a skin pack that overwrote a data file. Compare versions rather than reinstalling blindly.

**The server runs and is not in the list.** `REGISTER_TO_LOBBY=1`, then the HTTP port. It is almost always the HTTP port.

**The server exits immediately at start.** Read the output: it names the car or track folder it could not find. Usually a typo in `CARS`, a missing `CONFIG_TRACK` layout, or content copied to the wrong folder. [Reading the console](https://www.renode.space/blog/reading-the-console) is about getting the answer out of that output quickly.

**Cars spawn in odd places or the session breaks at the start.** `MAX_CLIENTS` or the entry list is larger than the track's pit boxes.

**Everyone gets a drive-through at the start.** `START_RULE=2` plus drivers who move before green. Either explain the rule or set it to `0`.

**Drivers warp or rubber-band.** Packet loss between them and the server, not `CLIENT_SEND_INTERVAL_HZ`. Have them check their route before you change a server setting that affects everybody.

**Lap times are not saved between sessions.** The vanilla server writes results to its results folder and nothing else. Persistent standings come from a plugin on the UDP interface or from AssettoServer.

Back up `cfg/`, your content list and any plugin configuration. The content itself is re-downloadable; the configuration that took a league three weeks to agree on is not, and a backup you have never restored is a hypothesis - see [backups that actually restore](https://www.renode.space/blog/backups-that-actually-restore).

#### FAQ

##### Do I need to own Assetto Corsa to run a server?

No. The dedicated server is a separate free application, app id `302550`, and installs with an anonymous SteamCMD login. The copy in your game folder is the same thing.

##### How many cars can a server hold?

Up to the number of pit boxes on the track, which is usually between 18 and 32 for stock circuits. `MAX_CLIENTS` above that number causes problems rather than adding slots.

##### Does the server send mods to players?

No. There is no download-on-join. Every driver installs the same cars and tracks themselves, at the same versions, or they are rejected at the checksum.

##### What is the difference between acServer and AssettoServer?

`acServer` is Kunos's original server. AssettoServer is an open-source replacement that reads the same config files and adds AI traffic, dynamic weather and time through Custom Shaders Patch, and a plugin system. Freeroam servers run AssettoServer; fixed-session leagues often do not need it.

##### Why is my server missing from the lobby?

Nearly always the HTTP port, `8081` by default, being closed. Lobby registration goes through it, separately from the `9600` game ports.

##### How do I reserve a slot for a specific driver?

Put their SteamID64 in the `GUID` field of an entry in `entry_list.ini` and set `LOCKED_ENTRY_LIST=1`. That slot, car and skin is then theirs alone.

Assetto Corsa servers on RE:NODE start at 2 GB with two port allocations, `server_cfg.ini` and `entry_list.ini` editable in the browser, and SFTP for uploading a content folder full of mod cars and tracks. Backup slots are included on every tier, and ports can be added on the Network tab if a plugin needs one.

[See Assetto Corsa plans](https://www.renode.space/game-servers/assetto-corsa)

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