Skip to content

Hosting and hardware

A CPU with strong per-core performance will generally be a better choice than one with more, slower cores. Gameplay, JavaScript, spatial streaming and incoming packet processing share the main thread. Faster individual cores help that work finish within the available tick time.

Replication workers distribute outgoing connection work across additional cores. A balance of core count and per-core performance is useful for this workload. For a VM, the CPU model, dedicated or shared CPU time and sustained usage quotas can all affect the available performance.

On 12 November 2026, we tested a Release server on a Windows PC with an Intel Core i5-14600KF and 32 GB RAM. The CPU has six performance cores, eight efficient cores and 20 logical processors. Intel specifications.

The server was assigned six logical processors. Simulated clients ran on the other 14, on the same machine. Server and generator resource usage were measured separately.

Part Test conditions
Players and streaming 300 connected players in groups of 128, 128 and 44, separated by 1,000 metres. Each player in a full group observed 127 others. Each player in the last group observed 43.
Movement Every player moved continuously, with a 25 ms sync interval, targeting 40 updates per second.
Initial synced metadata Each player had a profile containing an ID, name and level, plus a team, job and equipment list.
Changing synced metadata Once per second, each player’s activity metadata was updated with a sequence number and position. Those changes were replicated to observers.
Script events Each player sent one event per second with its index, sequence number and position. The server processed it and replied with an acknowledgement, totalling about 300 events and 300 replies per second.
Replication Three replication workers and send_rate = 1048576 bytes per second per connection.

This used a small test script and the test world. GTA clients, voice traffic, resource downloads and a production mod were excluded from the test.

Each run lasted 110 seconds. Measurements cover the interval from 60 to 100 seconds.

Server metric First run Repeat
Average CPU usage 3.32 CPU equivalents 3.33 CPU equivalents
Peak private memory 105.3 MiB 104.9 MiB
Peak working set 129.9 MiB 129.3 MiB
Game traffic received by all clients 42.33 MB/s, about 339 Mbit/s 42.38 MB/s, about 339 Mbit/s
Mean update delivery 39.98 Hz 39.96 Hz
Lowest observer average 39.91 Hz 39.88 Hz
p99 update age 50 ms 50 ms

One CPU equivalent means one CPU-second of work per second of elapsed time. For example, 3.32 represents total server CPU work across its threads, equivalent to keeping about 3.3 logical processors fully busy. Per-thread measurements help show whether one busy thread limits performance despite spare CPU capacity.

Private memory measures memory committed exclusively to the process. The working set measures its resident memory in RAM. The small test script and world account for the low memory figures. Your mod’s state, scripting heap and dependencies add to them.

The simulated clients consumed another 5.5–5.7 CPU equivalents. A dedicated game host only carries the server side of that workload.

The lowest observer value is that receiver’s average across its peers. Update ages are upper bounds from 10 ms histogram buckets, measured on loopback. Both runs maintained the input workload and had no failed script acknowledgements during the measurement window.

For 500 players under the same conditions, two simple CPU projections give:

  • Scaling by connected players: 3.32 × 500 / 300, or about 5.5 CPU equivalents.
  • Scaling by sender-to-receiver pairs in the same group layout: about 6.0 CPU equivalents.

The corresponding projections for 1,000 players are about 11–12 CPU equivalents. These estimates assume similar work per player or observer pair. Main-thread limits, worker distribution and transport costs can change the result. Additional cores help only the work that can use them.

These projections use the same dense groups, including a final partial group, with every player moving. MB/s uses decimal megabytes. One MB/s equals 8 Mbit/s.

Connected players 25 ms interval, 40 Hz 40 ms interval, 25 Hz
100 About 0.10 Gbit/s About 0.07 Gbit/s
300 0.34 Gbit/s measured About 0.23–0.24 Gbit/s
500 About 0.61 Gbit/s About 0.41–0.43 Gbit/s
1,000 About 1.23 Gbit/s About 0.82–0.86 Gbit/s

Only the 300-player result at 25 ms was measured for the populations in this table. The other entries scale traffic by sender-to-receiver pairs. The 40 ms model reduces the sync portion while keeping other application traffic at its previous rate. Its range accounts for different assumptions about transport overhead. Compression ratios may also change at another interval.

The measured traffic is the sum of simulated clients’ transport receive rates. We recommend allowing headroom for real-network overhead and retransmissions, voice and other services sharing the uplink. At 1,000 densely grouped players, the 40 ms projection leaves limited room on a 1 Gbit/s link. The 25 ms projection exceeds that link’s capacity.

Actual resource usage depends on a set of factors, including your mod’s overhead:

Factor Effect on the workload
Nearby players and entities More observers create more outgoing updates. The test’s 128-player groups describe its layout. stream_distance sets a radius, so a crowded area can contain more entities.
Activity Idle players usually generate less traffic. Movement, combat, vehicles and frequent streaming changes add work.
Metadata and script events Payload size, update frequency and the number of recipients affect CPU work and traffic.
Mod logic and state Callbacks, timers, entity processing, stored state and database integration add CPU and memory costs.
Voice and hosted services Voice, databases, caches and resource downloads consume their own CPU, RAM or bandwidth on whichever host runs them.
Network conditions Latency, loss and retransmissions affect delivery and outgoing traffic.

Several implemented measures can help when load grows:

  • sync_interval = "auto" starts at 25 ms and can gradually increase to 45 ms under sustained load. Less frequent sync can reduce CPU work and traffic.
  • [transport] bandwidth_budget provides an outgoing game-traffic target for automatic interval adjustment and the admission guard. A budget below the available uplink capacity leaves room for voice and other traffic.
  • overload_guard = true can pause new admissions if pressure persists. With automatic sync enabled, it waits until the interval reaches 45 ms. Admissions resume after recovery.

See load-protection messages for the reported load and state changes. The measurements above used a fixed 25 ms interval. For tests with automatic adjustment, time spent at each interval helps explain changes in the delivered update frequency.

These suggested allocations include headroom. Actual requirements may be lower or higher, depending on a set of factors and your mod’s overhead.

Connected players CPU allocation RAM Available uplink
100 4 fast physical cores 16 GB 1 Gbit/s
300 6 fast physical cores 16 GB 1 Gbit/s
500 8 fast physical cores 32 GB 1 Gbit/s
1,000 12–16 fast physical cores 32 GB 2.5 Gbit/s port with at least 2 Gbit/s usable upstream

These are starting points for host selection. CPU estimates assume dedicated time on cores with sustained performance comparable to the test host’s performance cores. RAM allocations allow for a real mod and service overhead. Databases, caches and resource hosting add their own requirements. A load test with your mod would help validate the estimates for 500 and 1,000 players.

SSD storage is recommended, with room for packages, scripts, persistent data, logs and a previous deployment for rollback. External hosting and a CDN can keep resource downloads off the game server’s uplink. Sustained outbound bandwidth and monthly transfer allowances are useful points to compare between hosting plans.

Runtime and OS requirements are listed in Requirements and compatibility.

A staged load test can show how the host handles joins, leaves, streaming changes, vehicles, combat, database work and voice. Real GTA clients and representative network latency also help assess how the result feels to players.

The monitoring guide covers delivery, queue growth, script failures and disconnects. Recording the generators’ CPU usage and actual send frequency helps distinguish server limits from an overloaded test machine.

A useful starting value for max_players is the population that meets your delivery target with room for workload spikes. Saving the tested configuration and deployment versions alongside the results makes later comparisons easier.