Squad Server Tick Timing: Which Hardware Actually Holds the Tick

How the tick budget actually works

Squad runs on Unreal Engine with dedicated server builds that simulate server-authoritative gameplay at a 60 Hz tick by default, though many communities run 30 Hz for larger matches. That means the server has roughly 16.6 ms (at 60 Hz) or 33.3 ms (at 30 Hz) of wall-clock time to complete a full simulation pass: movement validation, vehicle physics, projectile replication, and network replication to every connected client. Miss that window consistently and players see movement rubber-banding, delayed hit registration, and desynced vehicles.

The critical detail is that the tick is a mostly serial workload. Replication and much of the game code run on a single thread; physics may be spread across a small worker pool, and Unreal does parallelise some tasks, but the critical path through the tick is bound by one core’s speed. This is why adding cores past a certain point stops helping, and why a fast, high-clocking CPU beats a many-core server with a lower ceiling.

Single-thread clock versus core count

For Squad specifically, the useful core count is modest. A dedicated server process needs roughly four to six cores to run comfortably: one or two for the tick and replication thread, one to two for physics and animation workers, and a couple for the OS, the anti-cheat service, the RCON tooling, and whatever else you put on the box. Beyond that, additional cores mostly help if you run multiple server instances on one machine.

What matters far more is single-core turbo frequency and memory latency. A modern high-clock part at 4.8-5.4 GHz sustained will hold a stable tick at 100 players where an older 2.2 GHz server part with four times the cores will not. When comparing candidates, look at the SKU’s all-core turbo, not its headline boost, and prefer parts with large L3 cache — the simulation’s hot data set benefits noticeably.

If you plan to host two or three instances on one machine, core count becomes relevant again: budget four to six dedicated cores per instance, and pin each instance to its own core set so one match cannot starve another’s tick thread.

Memory needs by player count

Squad servers are memory-hungry relative to most shooters because of map size, vehicle assets, and the number of replicated actors. The base image plus a standard map typically sits around 3-4 GB resident, and each additional loaded layer or mod can add several hundred megabytes. Player count adds comparatively little per head, but the peaks come from asset loading and from replication buffers on large matches.

  • 50 players: 8 GB is workable, 16 GB comfortable with room for OS cache.
  • 72 players: 16 GB is the sensible floor; 32 GB if you run mods or a second service on the box.
  • 100 players: 32 GB, and 64 GB if two instances share the machine.

Always enable ECC. A long-running game server with a single-bit flip in the physics state produces anomalies that look exactly like a game bug and cost hours to diagnose. ECC is cheap insurance on a box that runs for weeks between restarts.

Why storage matters mostly at map load

Once a map is loaded, the server does very little disk I/O. The critical storage moments are map change, layer loading, and initial startup, where several gigabytes are read from disk under a hard deadline that begins when the round ends. On a slow SATA SSD, a large map load can take long enough that players time out; on NVMe, it is a few seconds.

You do not need a high-endurance write-optimised drive. A mainstream enterprise NVMe with roughly 1 DWPD is plenty, mirrored with RAID 1 so a failure does not take the instance down. The single most useful storage configuration for a game node is a fast read path plus redundancy, not a large array. Keep logs and any database on a separate volume so log rotation never competes with a map load.

Hardware profile by player count

Component 50 players 72 players 100 players
CPU 4 cores, 4.5 GHz+ all-core 6 cores, 4.5 GHz+ all-core 8 cores, 4.8 GHz+ all-core
Single-thread priority High High Critical
RAM 16 GB ECC 32 GB ECC 32-64 GB ECC
Storage 2x 480 GB NVMe, RAID 1 2x 960 GB NVMe, RAID 1 2x 960 GB NVMe, RAID 1
Network 1 Gbps, 5-10 TB cap 1 Gbps, 10 TB cap 1 Gbps, 10-20 TB cap
Bandwidth per player ~40-60 kbps ~40-60 kbps ~40-60 kbps

Bandwidth is rarely the constraint for Squad. At 50-60 kbps per player, 100 players consume roughly 5-6 Mbps sustained, with short spikes at round start. A 1 Gbps port with a reasonable monthly cap is ample; the limit you will hit first is CPU, not network.

Measuring whether the tick actually holds

Do not judge a server by feel. Instrument it. Unreal exposes server frame time through the stats system, and you can log tick duration continuously and alert when the p95 exceeds 80% of your budget (13 ms at 60 Hz, 26 ms at 30 Hz).

  • top -H -p $(pgrep -f SquadServer) — per-thread CPU, showing whether the tick thread is pegged.
  • mpstat -P ALL 1 — per-core utilisation to spot a single saturated core.
  • pidstat -u -p $(pgrep -f SquadServer) 1 — process-level CPU with context switch counts.
  • In-server stat unit — frame, game, and draw timing from inside the engine.

If one core sits at 100% while others idle, you are clock-bound, not core-bound, and the fix is a higher-frequency CPU rather than more cores. If all cores are busy, look at replication load and player count before buying hardware. For more on matching server specifications to real workload behaviour, see our notes on dedicated server hosting for gaming workloads.

Leave a Reply