Measuring…
The verdict for this game appears once the first full second of packets is in.
Comparing with other tests to this server…
Measuring…
The verdict for this game appears once the first full second of packets is in.
Comparing with other tests to this server…
Are you sure you want to delete all results?
| Date & Time | Duration | Avg Ping | Avg Jitter | Packet Loss | Actions |
|---|
Thrown back to a map download with the word desync? Placing buildings that appear and then vanish?
Factorio's multiplayer is unlike anything else in this catalogue. The game does not send you the state of the factory - it sends everybody's inputs and lets every machine compute the identical result, sixty times a second. That is why a map with tens of thousands of active machines uses almost no bandwidth, and it is also why the failure mode is so dramatic: if your simulation diverges from everyone else's by a single value, there is no way to nudge it back and the game has to hand you the whole map again.
What this test sends: 60 packets per second of 200 bytes, matching Factorio rather than a generic ping. verified
Factorio's simulation runs at a fixed 60 UPS and multiplayer is deterministic lockstep against exactly that number.
Run the test above for at least 60 seconds. Here is what each number means for this game specifically.
In a lockstep model, every input has to reach every machine, in order. Loss forces retransmission and stalls the shared clock, and in the worst case leaves a client computing from an incomplete picture. That is the road to a desync, and a desync is not a hitch - it is a forced re-download of the map.
Factorio deliberately shows your own actions immediately rather than waiting for confirmation, so building and walking feel responsive at latencies that would be intolerable otherwise. What it cannot hide is anything that depends on the shared simulation agreeing - which is why some actions feel instant and others do not.
Because all machines must advance in step, the group runs at the speed of its slowest link. Uneven delivery from any one player produces stutter for everyone, and the game will tell you when it is waiting. That makes a single unstable connection a shared problem in a way most games avoid.
What you see in game, and which number on this page explains it.
| What you see in Factorio | Look at | What it means |
|---|---|---|
| Desync followed by a full map download | loss | Your simulation diverged and there is no partial way to repair it. |
| Your own building placement feels instant | ping | Latency hiding showing your input before the shared simulation confirms it. |
| Everyone stutters when one player is online | jitter | Lockstep: the session advances at the pace of its slowest link. |
| Fast line, still bad multiplayer | loss | Throughput is irrelevant here. Ordered delivery is what matters. |
Nearly every game in this catalogue works the same way at heart. A server holds the authoritative state, clients receive updates about the parts of it they can see, and the amount of data grows with how much is happening. Factorio would be a catastrophe under that model - a large factory has tens of thousands of belts, inserters and machines all changing state constantly, and streaming that to every player is not feasible.
So it does the opposite. Every machine runs the identical simulation from the identical starting point, and the only thing sent over the network is what the players did. Because the simulation is deterministic - the same inputs always produce the same outputs, on every machine, in the same order - everyone arrives at the same factory without ever being told what it looks like. The bandwidth cost of an enormous base is essentially the same as an empty map.
The price is that determinism is all-or-nothing. There is no such thing as being slightly out of sync: either your simulation matches or it does not, and once it does not, every subsequent tick diverges further. The game therefore checks continuously, and when it finds a mismatch it stops you, writes a report, and gives you the whole map again from the authoritative machine. That is what a desync is, and why it is so much more disruptive than the equivalent event elsewhere.
For diagnosis this has one useful consequence and one counter-intuitive one. The useful one: your own actions are shown immediately through latency hiding, so raw ping matters far less than you would expect for a game this precise. The counter-intuitive one: bandwidth is irrelevant and speed tests are actively misleading. What decides whether Factorio multiplayer works is whether small packets arrive, in order, reliably - which is exactly the three numbers on this page.
If the chart above shows packet loss or high jitter, work through these in order.
The Symptom: You are dropped and the map re-downloads.
A desync means your simulation stopped matching the authoritative one, and the game writes a report about it rather than failing silently. Repeated desyncs on a clean connection usually point at mods differing between machines; repeated desyncs alongside loss on this chart point at the connection.
The Symptom: Everyone stutters when one person plays.
In a lockstep game the group advances together, so the worst connection in the session sets the pace for everyone. If you host, or if you are the one the others wait for, a cable stops being a personal preference and becomes the group's frame rate.
The Symptom: Fast connection, still stuttering multiplayer.
Only inputs travel, so even an enormous factory needs very little throughput. A gigabit line that drops packets is worse here than a modest one that does not, and a speed test will tell you nothing useful. Loss and jitter are the relevant numbers, which is what this page measures.
The Symptom: Stutter that follows the household's activity.
The traffic is small, constant and strictly ordered - the profile that suffers most behind a saturated upload queue. Router QoS that prioritises interactive packets protects the shared clock at no cost to anything else.
A desync means your machine's simulation stopped producing identical results to everyone else's. Mismatched mods are the most common cause, and connection problems that leave a client working from incomplete input data are the other. The game writes a report when it happens.
Because it does not send you the state of the world. Every machine runs the same deterministic simulation and only player inputs are exchanged, so a factory with tens of thousands of moving parts costs no more to transmit than an empty map.
The game deliberately shows your own inputs before they have been confirmed by the shared simulation, a technique usually called latency hiding. Anything that depends on agreement between machines cannot be treated that way, which is the difference you are feeling.
Yes, more directly than in most games. All machines must advance in step, so the session runs at the pace of its slowest participant and the game will show that it is waiting for someone.