【Factorio】Train Deadlock: Causes and Prevention Design

When trains stop at junctions or station entrances in Factorio, the root causes usually break down into three categories: signal placement, junction capacity, and insufficient station waiting lines. In vanilla v2.0 and Space Age, the fundamental rail principles remain consistent, so organizing these elements can prevent a significant portion of deadlocks.

When I first connected multiple ore patches, the waiting queue before the station overflowed into the junction and brought the entire line to a halt. Once I properly sized the waiting line to match train composition and converted the junction approach to chain signals, flow resumed immediately.

This article systematically covers the difference between regular and chain signals, then walks through when to use single-track, dual-track, roundabouts, and stackers. Rather than debugging after designs fail, this focuses on preventing blockages through proper design from the start.

Target Version and Prerequisites

Clarifying the Target Version

This article focuses on Factorio vanilla v2.0 and Space Age. Space Age is a paid DLC with a release date of 21 October 2024 ().

The key point is that train deadlock prevention works on the same core principles in both versions. The concept of placing chain signals before junctions and letting trains through only when the exit is clear applies equally. When I expanded an existing world in v2.0, I found that repositioning junction entrances toward chain signal placement worked just as well. Version differences matter less than whether the design logic is sound.

That said, Space Age tends to scale factory and rail traffic much larger. This doesn't change the signal fundamentals so much as make poor execution more visibly problematic. Sloppiness at scale shows up faster.

Space Age

wiki.factorio.com

Scope and Assumptions

From here on, I focus exclusively on rail-centric deadlock prevention: junctions, merges, single-track passing, dual-tracking, station waiting areas, roundabouts, and train limits. I exclude inter-planetary logistics specifics and higher-level routing.

The core principle remains: understand where trains should stop and where they must not. Adding planets doesn't change this—a poorly placed signal at a junction will deadlock you regardless. A station with insufficient waiting space will overflow into the main line and paralyse everything else.

Deadlock, as used here, means trains mutually blocking each other such that they cannot proceed without manual intervention. This can happen with just two trains. It's distinct from congestion, which is slow but eventually clears.

Terminology Quick Reference

Regular signals watch only the next block. They suit straight sections where flow is already simple. However, placing them before junctions makes trains enter and stop inside the intersection.

Chain signals check whether the entire path ahead—to the next regular signal or station—is clear before permitting entry. The logic is: "don't enter if you'd have to stop inside." This is the standard for junction and merge entries.

Blocks are sections delimited by signals. Generally, one train occupies one block at a time. How you divide blocks determines deadlock behaviour. Poor block division causes far more deadlocks than excessive train count.

These three concepts alone make the standard rule—chain in, regular out—natural and obvious.

This article focuses on deadlock, but the full context of train networks (dual-track layout, station placement, waiting-line strategy, signal roles) is covered in the parent pillar. Reading them together builds deeper understanding.

In my experience, deadlock usually isn't a single miscue but a combination of poor junction design + inadequate station buffers + weak line capacity. So this guide addresses all three together rather than in isolation.

What Is Deadlock? Essential Conditions

Deadlock vs Congestion

Deadlock, in Factorio terms, is a state where trains mutually wait indefinitely—requiring manual intervention to resolve—because their route reservations have become circular and unresolvable. It may look like minor crowding, but nothing moves no matter how long you wait. The official Train Signals Tutorial confirms that deadlock can occur with just two trains.

Congestion, by contrast, is slow movement that eventually clears given time. Trains do progress, even if queued.

The key distinction: congestion is slow but progressible; deadlock is blocked by reservation geometry.

I once spent hours debugging why two trains deadlocked. The cause was simple: my signal placement allowed them both to enter the junction, then one stopped inside while the other arrived, and they blocked each other's exit. Lessons learned: it's not about train count; it's about where trains can legally stop.

Tutorial:Train signals

wiki.factorio.com

Three Common Patterns

Most practical deadlocks reduce to three patterns, all rooted in the same flaw: trains stop where they shouldn't.

Junction interior waits happen when you use a regular signal at a junction entrance. The train sees the next block as free, enters, then stops inside when the exit backs up. Now another direction is blocked too. Classic and easy to do.

Single-track head-on collisions occur when passing sidings are too few or too short. Two trains from opposite directions claim the same block and deadlock. Single-track is cheap early on, so the discipline to support it via passing infrastructure is essential. Traffic growth makes this worse fast.

Station overflow into main line: inadequate waiting space forces queue tails onto the main line or into junctions. The station itself is fine—it's the queue that paralyses everything.

All three stem from the same root: poor stop-position design.

Spotting It in Practice

In-world, watch where the lead train stops, not the total count. Quick inspection:

Check between which signals the train stopped. Inside the junction, on the merge, just past the split? Likely the entrance was too permissive. Wait, the train is well ahead of the junction? Then signal logic is sound; suspect capacity or buffer shortage instead.

Also note whether it stopped before or inside the junction. Before = acceptable. Inside = the train got permissions it shouldn't have.

Finally, does the waiting queue's tail extend into branches or junctions? If so, a station's buffer shortage is blocking other directions. Identify the queue's rear car, not the front.

In my maps, deadlock is often one train in the "wrong" place triggering a cascade. Zooming into the symptom fast beats scanning the whole network.

Deadlock Cause #1: Signal Placement Errors

Regular vs Chain Signal Behaviour

This is where names can confuse, but behaviour is clear. Regular signals see only the next block. If the immediately following segment is free, the train enters—even if the path beyond is jammed. The train then stops inside the intersection, blocking cross traffic. Disaster.

Chain signals see ahead to the next regular signal or station. They ask, "Is the entire path free?" not "Is the next square free?" As the Tutorial puts it, they enforce the principle: don't enter if you'd stop inside.

This difference is enormous at junctions. A regular signal looks safe (there's a signal there!) but functions as a trap. I once thought more internal signals would help; they didn't—the entrance was still too eager.

Junction/Merge Basics

Chain at the entrance, regular at the exit. This is the golden rule ("chain in, rail out"). It works because:

• Entry must be strict: "Can you clear the junction?" only, not "Is the next square free?"
• The junction interior is for passing, not waiting.
• Exit returns to normal block control.

This ensures trains queue before the junction, not inside it. Other directions stay clear.

The official Wiki examples show that leaving entrance signals as regular at junctions makes trains stoppable inside, which is precisely the problem. Changing entrance signals to chain fixes this. My experience confirms this is the biggest single impact: rarely is it "not enough signals," usually it's "entrance is too permissive."

Short Exit Runs Warrant Exit Chain Signals Too

The rule is "regular at exit," but there's a practical exception: if the exit segment is very short and leads immediately to another merge, split, or station entrance, a regular signal won't prevent the train's rear from still occupying the junction while its front enters the next block. In such cases, make the exit a chain signal too, checking even further ahead.

This community practice ("chain out" on short exits) reflects reality: the visual exit isn't the true exit if obstacles lie immediately beyond. The train must clear completely to be safe.

I've done this at small station merges: swap the exit to chain, and suddenly trains don't ghost through junctions. It's a modest change with large effect.

Common Errors and Fixes

The most frequent mistake: entire junction entrances built with regular signals, mimicking straight-track practice. Misguided, but understandable.

Fix sequence:

1. Identify the junction entrance signals
2. Replace any regular signals with chain signals
3. Confirm the exit has a regular signal
4. If the exit immediately precedes another choke point, make that exit a chain too
5. Verify trains now queue ahead of the junction, not inside

The objective is moving stop positions outside the junction, not adding more signals. In my saves, flipping a single junction entrance to chain has instantly freed up a deadlocked network. The effect is "closed entrance, not smarter signals."

Figure Captions: "Changing junction entrance to chain signal," "Short exit chain signal setup"

For figures, clarity beats complexity. "Changing junction entrance to chain" should show: regular signal = trains enter and jam inside; chain signal = trains wait outside, interior stays clear. The contrast shows intention.

"Short exit chain signal setup" should illustrate: when exit directly feeds into a tight spot (next merge or station), chain the exit too so the entire path must be clear. Include the downstream obstacle to show why chain makes sense.

Both should emphasize: **it's not about signal count, but about stop *positions***. The train "where should it wait?" drives the design, not signal abundance.

Chain signals look complex but solve a simple problem: entrance permission. Grasping this makes deadlock prevention instinctive.

Deadlock Cause #2: Junction and Roundabout Capacity Limits

Roundabout Size vs Train Count

Here's the hard truth: correct signals don't guarantee deadlock-free flow if the junction is too small. The previous section was about design discipline, not raw capacity. Roundabouts look clever and space-efficient, so I used them early. But when traffic grew, small roundabouts became bottlenecks.

The issue: multiple trains enter from different directions, occupy internal space, wait for exits to clear, block each other. The Tutorial confirms two trains can deadlock, meaning capacity crises strike sooner than large-scale networks. I've also experienced it: a small RA full of one idle train prevents everyone else from entering.

Corollary: train length and roundabout size must match. A short RA holding a long train fails when flow picks up. Community consensus: account for max train length within the roundabout plus space for flow.

"One Train In" Design: Pros and Cons

A stricter approach: strict entrance control to permit only one train inside at a time. This keeps the roundabout as pure transit, eliminating internal waits. Safety is maximal.

Pros: roundabout interior is clean, stops are predictable, debugging is straightforward.

Cons: trains rejected at entrance queue outside instead. This trades internal congestion for external queuing. That queue must be absorbed somewhere—your station buffers or main-line waits.

So tightening a roundabout works only if you enlarge waiting space elsewhere. I've seen players squeeze roundabout flow only to see congestion migrate to the station entrance. The problem didn't vanish; it moved.

Growing Main Line Waits? Expand Station Buffers

If strict roundabout entry pushes more trains outside, they wait in main-line queues. To keep those from creeping backward into junctions, provision dedicated station waiting areas (stackers).

The logic: trains wait in stackers, not on main rails. Stations with slow service, multiple suppliers, or remote-control gating especially benefit. Make waiting voluntary and you break the cascade.

Stacker design is critical: each waiting line must hold a full train length. Community practice bears this out. A short stacker that doesn't contain its train leaves the rear sticking into the junction—the worst of both worlds.

(Edits: Community conventions cite roughly 37 tiles for 1-4-0 compositions as a typical stacker length target, though this is a rule of thumb, not an official metric. The principle—"one train fits entirely"—matters more than exact figures.)

Expanding station capacity isn't just adding more platforms; it's adding waiting infrastructure to protect the main line.

Figure Captions: "Small roundabout deadlock example," "Adequate size with controlled entry"

"Small roundabout deadlock" should show: multiple directions feed a tiny loop, one train interior blocks others, entrance signals cascade red, main-line queue grows. Visual: small RA with one stuck train causing system-wide red.

"Adequate size with controlled entry" should depict: larger RA, chain-controlled entrance, internal movement steady, external queues feed from dedicated waiting areas. Illustrate the stacker feeding the RA to show the system design.

The through-line: junction capacity (size + discipline) + waiting infrastructure (stackers) = stable flow. Neither alone suffices.

Deadlock Cause #3: Station Waiting Area Shortfall

Stacker (Waiting Line) Purpose

When stations jam, the culprit is usually not the station itself but where trains wait to enter. This is where stackers (dedicated waiting lines) come in. Role: hold queued trains outside the main line, ready to enter as platforms free up.

Why this matters: the instant a waiting train occupies main-line blocks, it threatens junctions and branches upstream. One station's delay becomes network-wide chaos. Early-game ore receivers taught me this the hard way—queues overflowing into branch points, bringing everything down.

Stackers are main-line protection buffers. The slower or more contentious a station, the more critical its buffer.

Train Length and Waiting Block Sizing

Critical principle: the longest train in your network must fit entirely within each waiting line's signal block. Community design consistently applies this rule. A stacker shorter than your longest train isn't containing anything—the rear spills into the intersection it's meant to protect.

If you run mixed compositions, size for the longest, not the shortest. I learned this the hard way when short trains worked fine but long ones overflowed, creating phantom "junction failures."

(Edits: Community measurements place 1-4-0 trains at roughly 37 tiles as a sizing target—a rule of thumb, not official. The principle—train entirely in block, rear doesn't touch the branch—is what matters.)

Stacker count should accommodate the station's peak intake. Can three trains arrive simultaneously? Have room for three outside. Ration the entrance via chain signals, not by starving stacker capacity.

Failure Example: Queue Blocks Branch/Main Line

Classic: a short stacker where the waiting train's rear extends past the branch point. The station is "waiting for space," but that queue now blocks trains headed elsewhere. I fixed this in an ore receiver: a two-row stacker was too short, leaving the branch obscured. Extending to full train length and repositioning the signals isolated the station from the main line. Suddenly, the whole network flowed.

Symptoms: you see red signals at the junction, but the root is station queue overflow.

Circuit Control and Train Limit Basics

Using circuits to manage station train limits is powerful: activate stations only when they have cargo to load, prevent oversupply to full stations, etc. But stacker discipline doesn't disappear.

Community practice uses this rule: maintain open receiving capacity (number of free platforms across all stations) roughly >= active train count. If all receiving slots fill simultaneously, queues back up everywhere and deadlock becomes likely.

Stackers enable this: they absorb queued trains without starving the main line. Smart circuits direct trains; stackers physically buffer them.

In large networks, I often cycle stations on/off via circuit to keep queue depth constant and main-line free. This works because I have adequate stacker room. Limit alone, without physical infrastructure, is fragile.

Figure Captions: "Train fully contained in waiting area," "Queue blocking branch—bad layout"

"Train fully contained in waiting area" should show: two or three trains waiting, each wholly within a signal block, none touching the junction ahead. Clean, orderly, main line protected.

"Queue blocking branch" should illustrate: station waiting, but rear train sticks past the branch point, blocking trains that need to fork elsewhere. The conflict is obvious.

Emphasize: **station capacity = platforms + *external buffers***. Skimp on buffers and you gain nothing from extra platforms.

Single-Track, Dual-Track, Roundabout: When to Choose

Single-Track Conditions and Passing Siding Expansion

Single-track shines in early-game space constraints and low-traffic routes (remote mines, one-off connections). Rail is cheap; it's fast to lay. I always single-track a distant ore patch at first.

But single-track needs passing sidings—it's not truly viable without them. Two trains head-on = instant deadlock. The Tutorial confirms deadlock happens on minimal networks, so single-track discipline is essential from the start.

Passing sidings multiply effectiveness. A single siding + internal signal division can hold two trains instead of one, letting you run more trains on the same line. Expansion patterns matter: upgrade siding length as traffic grows, not just count.

Key: the siding must fully contain the train. A short siding with the train's rear still on the main line is worse than useless.

Dual-Track One-Way Adoption

Traffic growth shifts the optimum to one-way dual-track. Fixed directions, no head-ons, cleaner signal logic. Stations, branches, and junctions are easier to reason about.

Mid-game onward, this becomes the standard. It scales better, expands more naturally, and mistakes have gentler consequences. Multi-player? Dual-track intent is clearer to teammates.

The cost is initial space and build effort. But retracing early single-track into dual-track later is painful. If expansion is planned, start dual-track saves rework.

Roundabout Adoption and "Tight Entrance Control"

Roundabouts offer compact multi-directional flow. Many players blueprint them. But they only work if entrances are strictly chain-controlled, admitting only one train when exit paths are clear.

Small roundabouts + weak entrance = internal pile-ups. Tighter entrance logic pushes queues outside. That's fine if your station buffers absorb them. If they don't, you've traded visible internal crowding for invisible external blocking.

Use roundabouts for low-to-medium traffic junctions. High-capacity main-line crossings need dual-track intersections.

Comparison Table

Default safe choice: one-way dual-track + station stackers. Single-track for isolated early routes, roundabouts for tight junctions, but dual-track for anything you plan to expand.

Figure Captions: "Single-track with internal siding division," "Dual-track merge," "Roundabout appropriate scale"

"Single-track with internal siding division" shows: passing siding divided by signals, holding two trains instead of one. Flow improves vs an un-divided siding.

"Dual-track merge" shows: one-way main lines, merge point with chain-controlled entry, clear flow.

"Roundabout appropriate scale" shows: roundabout sized for expected trains, entrance chain-controlled, queue flows from dedicated staging area. Contrast with "too small."

Visuals cement understanding faster than prose.

Quick Deadlock-Prevention Checklist

Junction Inspection

Deadlocks at intersections come from not stopping in the right places. Fast diagnosis needs three checks: entrance, interior, exit.

Entrance: Are the signals chain? Regular signals say "next block free?" and miss the bigger picture. Chain signals check the whole path. Public wiki and the Tutorial both emphasize this.

Interior: Can trains stop here? Unsafe if the rear extends into the intersection. Track the tail, not the head.

Exit: Is the next block short? If an exit immediately feeds a tight spot, make that exit chain too so the whole path is pre-checked.

Checklist:

• Entrance signals are chain, not regular?
• No stopping possible interior to the junction?
• Short exit directly feeds a congestion point, requiring exit chain control?
• Do trains queue ahead of the junction?

Station Entrance Inspection

Does the queue stay outside the main line and branches?

• Waiting queue doesn't block junctions or diverges?
• Each waiting block is ≥ longest train length? (Community rule of thumb for 1-4-0: ~37 tiles.)
• Stacker count matches realistic simultaneous arrivals?
• Are trains queued in dedicated stackers, not on main rails?

Single-Track Inspection

• Passing sidings exist?
• Each siding contains a full train, internally signal-divided?
• Branch/merge entrances use chains?

Trains/Circuit Management

• Station train limits avoid jamming (open capacity ≥ train count roughly)?
• Trains have valid destinations (no "path to void")?

Prioritized fix order:

1. Flip junction entrances to chain
2. Move station queues into dedicated stackers
3. Lengthen stackers to train-length
4. Add passing sidings to overloaded single-track
5. Upgrade busy single-track to dual-track

This order lets you isolate which change fixed what, building intuition.

Vanilla v2.0 vs Space Age: What Shifts?

Shared Principles

Rail signal fundamentals don't change between v2.0 and Space Age. Chain at junction entries, regular at exits, don't stop trains inside intersections, keep stackers outside main lines. The Tutorial logic holds everywhere.

Space Age doesn't revolutionize signals; it scales the problem. Longer distances, more hubs, higher complexity. But the core? Unchanged.

My v2.0 save expanded into Space Age—the railway adjustments were scale-ups, not redesigns. Stricter circuit control, more stackers, larger buffers. Same principles, bigger infrastructure.

Where Importance Amplifies

Space Age's multi-location complexity makes preventing deadlock more critical than fixing it. A single-line jam isn't local anymore; it ripples across planetary routes.

Corollary: design waiting areas and buffer capacity first, then route trains. Treat stacker capacity as part of the train limit system, not an afterthought.

Circuit discipline becomes essential: route trains only to destinations with open slots. One jam cascades if train flow logic is lazy.

My practice: parallel stacking (multiple waiting lines to the same station), redundant depo paths, explicit circuit logic for train distribution. A bottleneck that would mildly clog v2.0 paralyses Space Age networks without these measures.

Space Age Baseline

Space Age launched 21 October 2024. It adds complexity but not new signal rules. The rail discipline here applies fully; it just matters more.

Three Common Failure Patterns and Immediate Fixes

Interior Junction Wait Fix

Trains entering and stopping inside the junction is the #1 early symptom. Fix: replace junction entrance regular signals with chain.

If the exit area is very short, also make the exit chain so the full path beyond must clear.

Effect: trains now queue ahead of the intersection. Intersection stays clear. Throughput recovers.

Station Overflow Fix

Station queue tails block main-line junctions. Fix: extend and dedicate stackers, ensuring each holds a full train completely.

Checklist: waiting train's rear doesn't touch the branch, stacker has room for peak simultaneous arrivals.

Effect: main line is protected. Station waits are localized.

Single-Track Collision Fix

Add or extend passing sidings, internally signal-divided. Chain entrance, regular exit.

If passing sidings still don't contain traffic growth, migrate to one-way dual-track.

Effect: trains can pass. Single-track becomes viable for higher volumes, or you unlock the next design phase.

Figure Captions: "Bad ↔ Good side-by-side"

"Junction interior wait—Bad vs Good": Left shows regular signal entrance (trains stop inside). Right shows chain entrance (trains queue ahead). Emphasis on stop positions, not signal quantity.

"Station queue overflow—Bad vs Good": Left: queue tail blocks branch. Right: queue entirely in stacker, branch clear.

"Single-track pass collision—Bad vs Good": Left: no siding (head-on). Right: siding with internal signals (trains pass).

Each should highlight the position shift, the core fix.

Conclusion

Deadlock is solvable by examining how trains stop. The three-point breakdown—signal misuse, junction capacity, station buffer shortage—isolates the cause. Once you identify which, the fix is usually obvious.

Core rules are simple: don't let trains stop inside intersections, don't overflow stations into main lines, make single-track passing infrastructure, scale to dual-track when traffic demands. Adherence to these transforms maps from fragile to stable.

Check in priority order (junction entry → station buffer → single-track passing), fixing one layer before the next. You'll see where flow unlocks.

FAQ

Why does my two-train line deadlock?

Two trains can deadlock through geometric impossibility, not volume. Check whether your junction interior has signal placement that permits trains to stop inside. Likely the entrance is regular. Change to chain.

Can I expand a single-track line indefinitely?

No. Each passing siding added gains marginal benefit. Once you're adding sidings constantly, switch to one-way dual-track. Simpler, more scalable.

Do stackers need to match platform count?

Not exactly. Each stacker holds one train. If your station has 4 platforms and 3 frequently arrive together, 3 stackers suffice. But size each stacker to a full train, always.

Do circuits fix deadlock?

Circuits manage flow (train limits, destination blocking, load balancing). But they don't substitute for physical layout. A tight junction remains tight; a short stacker still overflows. Circuits + good layout = stable large networks. Circuits alone = fragile.

Space Age changes rail signals?

No. Same principles. Space Age scales problems, making adherence more critical. Larger networks punish sloppiness faster.