Every Factorio deadlock traces back to the same mistake: a rail signal sitting where a chain signal should be. That’s it. The whole system reduces to one rule — chain signal in, rail signal out — because a chain signal reads the state of the signal beyond it, and a rail signal doesn’t. Once you understand why that lookahead exists, every junction you’ve ever wired wrong stops being a mystery and starts being a five-second fix.
This guide covers the mechanism behind both signal types in full — including the four-state color logic almost no guide explains completely — then hands you a diagnostic table that maps your exact symptom to the exact broken signal causing it. If you’re setting up interplanetary logistics on top of this, the Factorio Space Age Trains guide covers platform-to-planet handoff timing; this one covers the signal logic underneath every rail network you’ll ever build.
Verified against Factorio 2.0 (Space Age). Signal mechanics are core-engine behavior, not balance-patched content — these rules haven’t changed across major updates and aren’t likely to.
Quick Start: 6 Steps Before You Place a Signal
- Chain signals on every entrance to a junction, rail signals on every exit — the one rule, no exceptions until you understand why it can bend (see below)
- Never place a rail signal where a stopped train would block a different train’s path — that’s the actual test, not just “is this a junction”
- Pick one maximum train length before you wire anything — signal spacing math depends on it
- Leave a gap at least as long as your longest train after every exit signal — undersized gaps cause the single most common Factorio deadlock
- Hold a signal in your hand near any junction to see live block coloring — this is the fastest diagnostic tool in the game, before you touch a wrench
- Never wire a roundabout like a normal junction — it’s the one layout where the rule inverts (see the Roundabouts section)
Blocks: The Foundation Every Signal Rule Builds On
A block is a section of track with no signal breaking it up, and Factorio enforces exactly one rule on every block: only one train may occupy it at a time [1]. That’s the entire physics of the signal system — everything else is bookkeeping on top of that constraint.
When a train enters a block, every signal that leads into it turns red. Nearby signals may flash yellow first — that’s the block being reserved for an approaching train a moment before it physically arrives [3]. A signal that’s blinking instead of showing a solid color isn’t broken from traffic; it’s invalid — either it isn’t placed on a rail, or the block it’s monitoring is the same block that comes before it [3]. Delete and replace it; a blinking signal will never resolve on its own because it isn’t reading a real block state.
This is also why signal placement side matters: a train in automatic mode won’t drive past a signal on the left side of the track unless there’s also one on the right at that same point [1]. Get the side wrong and the train ignores the signal entirely — not a deadlock, just a train that drives through a red light because, as far as the game’s concerned, there wasn’t a valid signal there.
Rail Signals vs Chain Signals: The Four States Nobody Explains Fully
Most guides tell you rail signals are “simple” and chain signals “look ahead,” then move on. That skips the actual mechanic you need to read a junction correctly. Both signal types run on four states, and the states mean different things for each one.
| Rail Signal State | What It Means |
|---|---|
| Green | The monitored block is empty [3] |
| Yellow | A train is approaching and already has approval to enter the block — it can’t stop before it now [3] |
| Red | The block is occupied, or another signal watching it is showing yellow [3] |
| Blinking | Invalid placement — not on a rail, or monitoring the block immediately behind itself [3] |
| Chain Signal State | What It Means |
|---|---|
| Green | All exits reachable from this block are free [2] |
| Yellow | The block is reserved for a train, forcing every other entrance signal into that block to red [2] |
| Red | All exits are occupied — no valid path through [2] |
| Blue | Some exits are free and some aren’t; a train may or may not stop, depending on which exit its own path actually uses [2] |
Blue is the state that trips people up. It only appears where a track splits, and it doesn’t mean “caution” the way yellow does on a rail signal — it means the chain signal is evaluating multiple possible exits and can’t give one universal answer. A train assigned to the clear exit sails through a blue signal without slowing down. A train assigned to the blocked exit stops at it, at the same moment, on the same signal. If you’ve ever watched two trains react differently to what looks like one shared signal, this is why.
The One Rule: Chain In, Rail Out — And Why It Actually Works
A chain signal looks ahead to the exit signals of the next block. If the exit signal your train’s path actually depends on won’t let it through, the chain signal stops the train before it enters — not inside the block, before it [1][2]. A rail signal has no such lookahead. It only checks the block immediately in front of it, which means a train can pass a rail signal, enter a junction, and then have nowhere to go once it’s already sitting in the middle of the crossing.
That’s the entire mechanical reason the rule exists: use chain signals in and before crossings, and regular signals at the exits of crossings [1]. Put them backward — rail signals on the entrances — and a train commits to the junction before checking whether the far side is clear, which is exactly how two trains end up nose-to-nose in the middle of an intersection with neither one able to back out.
There’s one legitimate exception worth knowing, not because you should design around it, but because it explains behavior that otherwise looks like a bug: if a train’s destination is reachable from a chain signal without crossing any other signal, the chain signal skips the exit check entirely and lets it straight through [2]. That’s the game trusting a train’s confirmed path over a general lookahead — it only applies right at the very end of a route, not mid-network.
Turn that into a decision you can apply at any junction:
- If a stopped train would block a different train’s path through the same area — chain signal on that entrance.
- If a train stopping there affects nothing else — open track, dead-end sidings — a plain rail signal is correct. Upgrading it to a chain signal adds nothing but extra path-checking overhead.
- If the track splits into more than one usable exit — chain signal, so the lookahead can evaluate whichever branch a given train is actually taking.
- If you’re closing a loop back on itself — skip chain signals inside the loop. See Roundabouts below; this is the one place the rule flips.
Signal Spacing: The Rule That Breaks Perfectly-Wired Junctions
You can get every signal type correct and still deadlock — this is the second-most common failure after wrong signal type, and it’s purely a distance problem. After the exit signal of any junction, the next signal downstream needs to sit far enough away to fit your longest train in the gap between the two [1]. A four-wagon train that only half-fits in that gap occupies the block anyway — its tail is still sitting in the junction’s exit block even though its head cleared the crossing, and every signal feeding that block stays red until the whole train is clear.
Pick a maximum train length before you build a single rail, not after. Retrofitting spacing across an existing network means moving every downstream signal on every junction, which is a far bigger job than getting it right once at the start.
Diagnostic Table: Match the Symptom to the Broken Signal
Every one of these deadlocks traces back to a specific, findable cause — not a “rebuild the junction” problem, a “find the one wrong signal” problem.
| Symptom | Root Cause | Fix |
|---|---|---|
| Two trains stopped nose-to-nose in the middle of a crossing | Rail signals sit on the crossing’s entrances instead of chain signals | Replace every entrance signal with a chain signal — a rail signal lets a train commit before checking the exit; a chain signal won’t |
| A train’s head clears the junction but its tail is still stuck inside it | The next downstream signal is closer than your longest train | Move the exit-side signal back until the gap equals or exceeds your longest train’s length |
| A whole loop of trains freezes permanently, none of them visibly inside an intersection | A circular block has more trains assigned to it than can physically fit | Break the loop into a real block chain, or cut the number of trains sharing that circuit |
| A train drives most of the way around a roundabout, then stops dead mid-loop | Chain signals were placed inside the roundabout itself, and the train’s path recalculated while it was already circling [4] | Strip every chain signal from inside the loop; guard the whole roundabout as one block with rail signals only at entry and exit [4] |
| A single train sits stalled on open track with nothing else nearby | The signal it’s waiting on is blinking — invalid placement, not a real block | Delete and replace the signal; it isn’t reading a valid block, so it will never resolve on its own |
| Trains keep diverting away from one exit even when a different exit is busier | The chain signal is reading the specific exit each train’s path is assigned to, not the junction as a whole | Check the exit signal tied to the branch the diverted trains are actually headed for — that’s the one turning the chain signal red or blue |
Wiring a Four-Way Intersection Correctly
A four-way crossing is where the rule gets tested hardest, because every entrance can conflict with three other paths, not just one. Every entrance gets a chain signal. Every exit gets a rail signal. No entrance is exempt because it “looks” like the low-traffic direction — a rail signal on even one entrance is the single entry point a deadlock needs.
The spacing rule still applies at every exit independently: each of the four rail signals downstream needs its own longest-train gap before the next signal. A four-way junction wired with chain signals on all entrances but a too-tight exit gap on just one of the four directions will still deadlock — just less often, and only when traffic happens to hit that one direction hard. That intermittent failure pattern is often mistaken for a random bug when it’s actually the same spacing rule, just failing under specific traffic instead of every time.
Roundabouts: Why They Break the Rule Everywhere Else
A roundabout is the one Factorio layout where “chain in, rail out” actively works against you. Chain signals placed inside the loop create the conditions for a train to enter, travel most of the way around, and then get stuck behind its own reserved path when the game recalculates its route mid-circle — which happens any time you edit rail anywhere on the map, not just near the roundabout itself [4]. The train effectively traps itself inside a loop it already committed to.
The community-tested fix inverts the whole approach: treat the entire roundabout as a single block, guarded only by rail signals at the entry and exit points, with no chain signals anywhere inside the loop [4]. That sacrifices throughput — only one train can be in the roundabout at a time — but it removes the self-trapping failure mode entirely. If you need higher throughput than a single-train roundabout supports, the better fix isn’t more chain signals inside the loop; it’s replacing the roundabout with a spaced sequence of T-junctions or cross intersections, which route the same traffic without ever closing a loop back on itself [4].
Signal Guide by Player Type
| Player Type | Priority | Biggest Risk | Shortcut |
|---|---|---|---|
| New player | Get the one rule right on a single T-junction before building anything bigger | Mixing signal types on one crossing without knowing why it broke | Hold a signal near any junction — the game shows live block colors before a train ever gets stuck |
| Casual player | Standardize one train length across your whole base before wiring a single junction | Spacing drift between junctions built at different points in the game | Pick your longest train size once, then always leave that many rail-lengths after every exit signal — never recalculate per-junction |
| Hardcore / optimiser | Use blue-state chain signal branching at multi-exit yards instead of duplicating track | Trusting the direct-destination exception to skip an exit check that’s masking a real downstream jam | Treat every stall as a lookup against the diagnostic table above, not a rebuild |
| Completionist | Document a block map for every junction, including roundabouts | A roundabout that only fails once traffic density crosses a threshold, long after it was built | Skip true roundabouts entirely — spaced T-junctions give the same flexibility without the self-trapping failure mode |
Frequently Asked Questions
Why does the game let me place a rail signal inside an intersection if it just causes deadlocks?
Because signal placement is a physics rule, not a design rule — the game only enforces “one train per block,” not “this layout won’t jam.” A rail signal inside a junction is a perfectly valid placement that creates a structurally unsound junction. The game will never stop you from building a trap; it only tells you where the walls of the trap are.
Is it ever correct to use a rail signal instead of a chain signal at a junction entrance?
Only if you can guarantee no other train will ever need to pass through that junction while one is stopped at that entrance — which in practice means it isn’t really a junction, it’s a single-path stretch of track that happens to be near one. The cost of defaulting to chain signals everywhere near a crossing is a handful of extra signals. The cost of guessing wrong is a permanent deadlock you have to manually drive a train backward to clear.
Do chain signals slow trains down compared to rail signals?
No — when the path ahead is clear, a chain signal and a rail signal behave identically; a train passes through at full speed either way. The only difference shows up when the path isn’t clear: a chain signal holds the train before the junction, a rail signal lets it in and then holds it inside. That’s a placement difference, not a speed penalty.
Why does my roundabout still deadlock even though I followed “chain in, rail out” everywhere else?
Because the roundabout is the one topology where that rule inverts. Everywhere else, chain signals prevent a train from stopping somewhere that blocks other traffic. Inside a closed loop, a chain signal lets a train commit to a path it can end up trapped behind once the game recalculates routes elsewhere on the map [4]. Strip the chain signals from inside the loop and guard it as a single rail-signal-only block instead.
Key Takeaways
Every signal in Factorio is answering the same question: can a train sit here without blocking a different train’s path? A rail signal answers that question only for the block directly in front of it. A chain signal answers it for the entire path ahead, up to the next rail signal or the train’s own destination. Chain in, rail out isn’t a rule you memorize — it’s the direct consequence of that lookahead difference, and once you can explain why it works, the diagnostic table above turns every future deadlock into a two-minute fix instead of a rebuild.
For the wider Space Age progression this fits into, see the Factorio Space Age Beginner’s Guide, and for the order to tackle each new planet’s rail network, see the Factorio Space Age Planet Order guide.
Sources
- Tutorial: Train Signals — Official Factorio Wiki
- Rail Chain Signal — Official Factorio Wiki
- Rail Signal — Official Factorio Wiki
- Train Roundabouts — Factorio Forums
- Mastering Train Systems in Factorio: A Comprehensive Guide — XGamingServer
I've been playing video games for over 20 years, spanning everything from early PC titles to modern open-world games. I started Switchblade Gaming to publish the kind of accurate, well-researched guides I always wanted to find — built on primary sources, tested in-game, and kept up to date after patches. I currently focus on Minecraft and Pokémon GO.