Train Deadlock Prevention in [[Factorio]]: Root Causes and Workaround Design

When trains stop at intersections or station entrances in Factorio, the cause usually breaks down into three areas: signal placement, intersection capacity, and insufficient station waiting lines. In vanilla Factorio v2.0 and Space Age, the fundamental principles of rail design remain consistent, so organizing these points alone can prevent deadlocks significantly.

I still remember my first experience: when I connected multiple ore mines, the station waiting queue spilled into the branch, bringing the entire network to a halt. After properly resizing the waiting line to match train composition and converting the intersection approach to chain signals, flow resumed immediately on the spot.

This article walks through the distinction between regular and chain signals, then systematically covers when to choose single-track, double-track, roundabouts, and stackers based on traffic conditions. Rather than fixing congestion after design, the focus is on preventing it during the design phase itself—practical steps you can follow as you build.

Covered Versions and Prerequisites

Clarifying Target Versions

This article covers Factorio vanilla v2.0 and Space Age. Space Age is a paid DLC released on October 21, 2024, as documented in the Space Age section of the Factorio Wiki.

The key point is that train deadlock prevention operates on nearly identical core principles between vanilla v2.0 and Space Age. The approach of placing chain signals before intersections where you don't want trains to stop, then handling trains at exit signals, works consistently across both versions. Even when I extended an existing v2.0 world into the Space Age content, the fundamental principle of moving intersection entrances toward chain signals remained equally effective. Here, consistent design logic matters more than version differences.

Space Age does tend to increase overall factory logistics scale, and train networks often carry heavier traffic. Rather than the signal rules themselves changing, poor fundamentals become more visibly problematic under increased load—that's the more accurate way to think about it.

Space Age

wiki.factorio.com

Scope and Assumptions of This Article

From this section forward, the focus is strictly on rail-centric deadlock prevention. Specifically: intersections, branches, single-track passing sections, double-tracking, station waiting lines, roundabouts, and using train limits to regulate inflow—topics covering rail network design itself.

What this article doesn't cover in detail is inter-planetary logistics or the broader space-side network in Space Age. Those are fascinating areas, but the core principle of deadlock prevention remains: knowing where trains should stop and where they absolutely must not. Even across multiple planets, a regular signal placed at an intersection entrance will cause the same deadlock, and insufficient station waiting space will block the mainline just as severely.

Here, deadlock means trains become trapped in mutual waiting, unable to move without manual intervention. It can occur with just two trains, not just large networks. Sometimes it looks like "a bit of congestion," but the route reservation is actually in permanent deadlock—quite different from ordinary congestion.

Mini Glossary of Terms

Let's clarify the terminology first. Initial mentions in the text will include context, but establishing these concepts upfront makes the article more readable.

A regular signal checks whether a train can enter the next block. It works well for straightaways or sections with already-simple routing. However, placing one before a branch or intersection makes trains push partway into the intersection before stopping.

A chain signal looks further ahead—it checks whether the path to the next regular signal or station can be cleared—before allowing entry. In essence: "if we'd have to stop inside, don't enter in the first place." This is why chain signals belong at intersection and branch entrances.

A block is the section of track between signals—the occupancy unit. Generally, only one train per block. Since trains repeat the cycle of occupying and releasing blocks as they move, how you divide the track into blocks becomes hugely important for deadlock analysis. Honestly, when trains jam up, the culprit is usually block division, not train count.

With just these three concepts clear, the golden rule—"chain signal before intersection, regular signal after exit"—becomes almost intuitive.

This article drills deeply into deadlock prevention, but understanding station placement, waiting line strategy, and signal role allocation in broader network design context makes the concepts stick better. The deadlock issues I've encountered usually involve all three factors (intersection, station, mainline capacity) rather than isolated mistakes. So the sections ahead treat them as an integrated system, not individual quick fixes.

What Is a Factorio Deadlock? Essential Conditions

Defining Deadlock vs. Congestion

A deadlock in Factorio is a state where trains wait for each other indefinitely, unable to resume without manual intervention. It might look like "just a bit crowded," but route reservations have truly collided with no way forward. The Factorio Wiki's train signal tutorial makes clear: deadlocks can occur with just two trains, not just big networks. That detail was surprisingly critical for my understanding.

Congestion, by contrast, is delayed but moving—when the blockage clears, flow resumes in order. It's slow and frustrating, but theoretically time resolves it. Deadlock is "the routing math broke"; congestion is "the pipeline is full."

I spent hours initially baffled by how two trains alone could jam. The answer was simpler than expected: both trains were allowed to enter the intersection, and both stopped inside it. The issue wasn't train count—it was where the design permitted stopping.

Tutorial:Train signals

wiki.factorio.com

Three Common Patterns

Most real-world deadlocks fit three patterns, all stemming from trains stopping where they shouldn't:

Pattern 1: In-intersection waiting. Place a regular signal before a branch and trains think "next block is clear, I can enter." They push into the intersection, encounter a full exit, and stop—blocking other directions. This is the most typical and happens to everyone.

Pattern 2: Single-track head-on deadlock. Without enough passing sections, trains approaching from both sides fight for the same track and jam indefinitely. Single-track demands tight passing-section discipline; traffic growth quickly exposes this.

Pattern 3: Station backlog invading the mainline. When station waiting space is too short, the queue spills onto the main track or into branch points, blocking the intersection upstream. A station problem becomes a network problem.

All three share a root: insufficient design control over where trains can stop. Fix the stopping logic, and you've addressed the core issue.

Spotting Deadlocks On-Map

When frozen traffic appears, I check exactly where the train's nose points, not overall congestion. This split usually comes clear fast.

Look at where the stopped train's front and rear sit relative to signals and intersections. If a train stops inside the intersection or on a branch, the entry logic is too lenient—it permitted "stopping inside." If it's queuing neatly before the intersection, signals are sound; now suspect capacity or waiting-space shortages.

Also note: does the waiting queue's tail spill into a branch or mainline block? If a station's waiting line extends beyond its designated space, the queue is occupying track meant for transit. That queue's last car might be the only thing blocking an entire upstream direction.

From experience, deadlock usually boils down to one culprit—often a single train stopped in the wrong place. Overhead maps can be misleading; zoom in on the train's exact position and the cause becomes much clearer.

Root Cause #1: Signal Placement Mistakes

Regular vs. Chain Signal Behavior

The name alone can confuse; the actual mechanics are distinct. A regular signal looks at the immediate next block only. If that one square is clear, it allows entry—even if the intersection itself or exit is jammed. The train then pushes into the intersection and stops partway, blocking perpendicular routes.

A chain signal previews the entire path ahead to the next regular signal or station. It permits entry only if the train can clear that full stretch. In effect: can this train exit safely? If not, don't let it enter. The official wiki tutorial frames it exactly this way.

This difference hammers intersections hard. A regular-signal-only intersection looks safe because signals exist, but it's actually an "intersection where trains can stop mid-crossing" design. That baffled me early on; the signal lights were red, so what was wrong? The answer: signal presence ≠ safe stopping design.

Intersection and Branch Fundamentals

The core rule is remarkably simple: chain signals before branches/intersections, regular signals at exits. This is the famous "chain in, rail out" pattern. It works because intersection interiors aren't waiting areas—they're throughways. Exit signals restore normal block management afterward.

This setup keeps trains queuing outside intersections, keeping interiors clear for transit. The official wiki illustrates exactly this problem: convert intersection-approach regular signals to chain signals, and the deadlock potential drops dramatically. From my own fixes, most jam-prone intersections weren't under-signaled—they had too-permissive entry logic.

When Exit Blocks Also Need Chains

There's one practical exception: short exit sections. If the intersection exit immediately reaches another branch, merge, or station approach, and a full train can't fit, exit-only regular signals can leave the train's rear still occupying the intersection.

In such cases, convert the exit to chain as well, extending lookahead to that second constraint. This forces the train to wait outside until the entire downstream path clears. Community best practices call this "chain-out," recognizing that the true exit point isn't the intersection boundary but wherever the train finally has clearance.

I've used this several times at tight station-front merges. Swapping the exit from regular to chain instantly settled the jams—suddenly trains weren't entering the intersection to have their rears block the exit zone.

Common Mistakes and Quick Fixes

The most frequent error: all intersection approaches use regular signals. When you extend straight-track instinct into intersections, this naturally happens—and it backfires. The fix is straightforward:

1. Identify the deadlocked intersection
2. Check signals at all approach points—they should be chain
3. Ensure exit signals are regular (or chain if the exit zone is tight)
4. Verify the train stops before the intersection, not inside it

The goal isn't more signals; it's moving the stop point outside the intersection. In my own fixes, just converting the intersection approach from regular to chain has repeatedly broken deadlocks without any other changes—same day, problem gone.

Figure Caption Ideas: "Before/After: Intersection Entry Signal Swap"

A diagram showing the same intersection with regular signals (trains stopping mid-crossing, other directions blocked) versus chain signals (trains queuing outside, through-traffic flowing) makes the impact visceral. Emphasizing where trains stop rather than signal count underscores the real lesson.

Chain signals are often seen as complex, but the logic is pragmatic: next-block-only regular signals fail at intersections; full-path chain signals prevent mid-crossing stops. That difference is worth visualizing.

Root Cause #2: Intersection and Roundabout Capacity Shortfall

Roundabout Size vs. Train Count

Here's the trap: signals can be perfect, yet a too-small roundabout still deadlocks. The previous section covered "don't let trains enter if they'll stop inside"; this covers "what if the interior simply has no room?"

Roundabouts look tidy and appeal early—four directions handled compactly. I used them constantly. But as traffic grows, trains bunch at the roundabout entrance, waiting for interior trains to exit, and the queue backs onto the mainline. The wiki confirms: deadlocks happen with just two trains. A small roundabout containing one idling train can lock out all other entries simultaneously.

Community consensus holds that trains can easily deadlock against their own rear in tight roundabouts—the vehicle's stern end blocks its own forward route. Even small capacity additions help drastically. I've changed just the roundabout diameter and had an otherwise-identical network handle 50% more trains.

"Single-Train Entry" Design: Pros and Cons

One stabilization approach: control entry so only one train occupies the roundabout at a time. Strict chain-signal entry ensures this. The roundabout becomes a pure transit zone; trains wait outside, not inside.

Pros: Interior doesn't jam; failure modes are predictable; the roundabout itself stays unclogged.

Cons: The waiting line simply moves outward. If that train now queues on the mainline or blocks a branch, you've merely shifted the problem. Curing the roundabout didn't cure the network.

To truly help, add station waiting space to absorb these displaced queues. Tighten the roundabout; enlarge the station buffer in tandem. I've done this and watched flow improve only after also adding stacker capacity—proving the roundabout control alone was incomplete.

Mainline Waiting Grows; Expand Station Waiting

If you restrict roundabout entry, trains queue further back. That's fine if there's designated waiting space. Without it, the queue spills into transit lanes, defeating the intersection fix.

The solution: increase station stacker (waiting line) capacity. Let trains queue in intended waiting areas, not on through-lanes. The principle mirrors intersection design: clear intention about where trains can pause.

Waiting-line sizing follows the same rules: one full composition per block minimum. A 1-4-0 train needs roughly 37 tiles to rest completely unseen (community measurements; not official figures). The precision matters less than ensuring trains fit entirely, rears not reaching forks or mainlines.

I've often started with under-sized stackers, then expanded them once I saw trains queuing past the designated zone. The immediate difference is dramatic: controlled waiting in stacker space versus chaotic mainline backlog creates night-and-day results.

Common Failure: Queues Blocking Forks / Overflowing Mainline

Biggest stacker mistake: waiting trains don't actually wait safely—their rear extends past the branch point.

This looks like capacity; it's actually position design. A train parked at the station isn't the problem; a train parked on a branch point absolutely is.

Solution: make the waiting area long enough that the entire train plus successors fit before any fork or merge. I've fixed single-station bottlenecks just by relocating the stacker entrance farther from the branch point and extending its length. Flow improved not because the station itself changed, but because queues no longer invaded transit space.

Visual checks: run trains toward a full station and watch where the blocking red signal first appears. If it's on the branch or intersection upstream, the stacker is too short or positioned too close to the fork.

Figure Caption Ideas: "Undersized Roundabout Cascade vs. Proper Sizing with Stacker"

Left side: small roundabout, multiple entries, one train stuck inside blocking all directions, queue backing onto mainline and branch. Right side: larger roundabout or tighter entry control, clear stacker before the intersection, only one train at a time on the roundabout, mainline stays open.

The caption should emphasize: capacity and signal design go together. Controlling entry without adding stacker depth only moves the queue. Both changes together restore flow.

Root Cause #3: Insufficient Station Waiting Space

The Stacker (Waiting Line) Role

When a station jams, the cause is often not station throughput but where overflow trains wait. That's the job of station stackers—dedicated waiting areas that prevent inbound queues from invading the mainline.

Once a train stops on the mainline while waiting to enter, the problem isn't local. That one train's presence can block a branch, an intersection, or another station upstream. A small station delay becomes network-wide paralysis. I've lived this: a short stacker let one waiting train's rear extend into a branch point, which choked an entire intersection three transfers away.

Stackers are mainline protection buffers. The slower the station, the more critical the stacker.

Train Composition and Stacker Block Length

Core rule: the longest composition you run must fit completely within one stacker block. Community design practice treats this as non-negotiable.

This means measuring against your actual fleet, not just one train type. If you mix 1-2-0 and 1-4-0 trains, you design for the longer. Short stackers hide the 1-2-0 traffic but fail the moment a 1-4-0 approaches. I've done exactly this and gotten blindsided when longer trains arrived—tail extending into the branch, blocking everything.

Community-derived measurements suggest 1-4-0 trains occupy roughly 37 tiles (not official; this is empirical data). Rather than memorizing numbers, the principle is: verify your longest train disappears entirely into the stacker with clearance to spare. If any part extends past the fork, you've failed the design.

Failure Mode: Queue Blocks Branch / Overflows Mainline

Most dangerous stacker mistake: the waiting line exists, but the waiting train's rear still occupies a branch or mainline block.

This happens when stacker length is underestimated. A train parked in its assigned space is fine; a train parked with its rear on a branch point is a disaster. The queued train isn't the issue; the queued train's geometry overlapping transit space is.

Fix: extend stackers so the entire composition, plus expected queues, remains clear of branches and mainlines. I've solved chronic jams just by relocating stacker entrances farther from branch points and lengthening the line. Flow settled down not because stations improved, but because overflow stopped invading intersection space.

Circuit Control and train_limit Basics

Circuit network|Circuit control with train_limit is powerful: enable only stations with available cargo, block full stations. Under heavy traffic, this really helps. But stacker thinking doesn't disappear.

Making routing smarter only raises the question: where do trains wait while logic decides? If you restrict entry to one station, the waiting trains need somewhere to queue. Without stacker depth, the queue spills mainline anyway, negating the circuit control benefit.

Community wisdom: keep total available station slots exceeding actual train count. That way, some station is always accepting arrivals, so trains always find a destination and don't jam everywhere waiting for non-existent capacity. But this only works if stackers exist to hold these queues.

I've used circuits to gate station entry, but only because I also designed ample stacker depth. The smarter control is only effective if the physical waiting infrastructure matches the logic. Circuits don't replace stackers; they organize their use.

Figure Caption Ideas: "Full-Composition Stacker vs. Short NG Stacker"

Left: stacker long enough that the composition vanishes, rear nowhere near the branch, queued trains lined up cleanly, mainline visible beyond. Right: short stacker where the waiting train's tail overhangs the branch, blocking perpendicular traffic.

Key insight: stacker size is about geometry, not just count. A long, single waiting line beats multiple short ones if those short ones leave train rears exposed.

Choosing Single-Track, Double-Track, or Roundabouts

When to Use Single-Track and When to Add Passing Sections

Single-track excels for early-game low-traffic routes—connecting a remote mine to base on a shoestring budget. Rail count is minimal; setup is fastest.

But single-track demands passing sections (crossing points). Without them, two approaching trains deadlock instantly. The wiki's signal tutorial uses exactly this case: even two trains can deadlock. Single-track is only viable if you pre-build the passing infrastructure.

A single crossing section isn't "enough"; treat it as a start. As traffic grows, add more crossings or lengthen existing ones by subdividing internally with signals. I've seen single-track routes jump from 2-train capacity to 3-4 just by splitting a passing section into two blocks. Passing space acts like a stacker for single-track: let trains rest in designated zones, not on the main line.

The principle is identical: the full train must fit within the passing section, rear not touching the mainline outside it. Shorts passes are useless if trains still block transit.

When to Adopt One-Way Double-Track

Once traffic rises noticeably, the pivot to one-way double-track pays for itself immediately. Up: dedicated direction eliminates head-on deadlock entirely. Flow is intuitive; branches and merges follow standard patterns. Scaling is straightforward—add stations, extend branches, adjust intersections without foundational redesign.

This becomes the standard solution mid-game onward. Station additions, new supply routes, network reorganization all integrate cleanly. Maintenance is predictable; anyone adding to the network understands the structure.

I transition to double-track well before single-track starts bottlenecking, specifically to avoid retrofit costs. Converting later means reworking stations and branches—tedious. Building double-track from the start, though initially more expensive, saves engineering hours down the road.

When to Use Roundabouts and the "Entry Chain Strictness" Trick

Roundabouts offer compact multi-directional flow—four connections in tight footprint. They look good and attract heavy re-use via blueprint.

Success depends on strict chain-signal entry control. Loosely enforced roundabouts fill with traffic, stall inside, and jam all entries. I've built roundabouts expecting high throughput, only to find them clogged by their own previous traffic. The lesson: roundabouts profit from fewer, shorter stays inside, not more density.

For high-traffic mainline junctions, roundabouts usually disappoint. The moment traffic exceeds comfortable throughput, convert to a one-way double-track junction. Roundabouts shine on medium branches and secondary crossings, not trunk routes.

Choosing: Comparison Table

A simple framework:

Default choice: one-way double-track + station stackers. Single-track for truly isolated routes. Roundabouts for low-priority branches only.

Figure Caption Ideas: "Single-Track Passing-Section Subdivision," "Double-Track Merge with Chain Entry," "Roundabout Right-Sizing"

"Single-Track Passing-Section Subdivision": show a long passing section split internally by signals, allowing multiple trains to rest simultaneously.

"Double-Track Merge with Chain Entry": illustrate how the mainline stays clear while a branch trains queue in stacker, then feed into the line one at a time.

"Roundabout Right-Sizing": side-by-side of undersized (trains stuck inside, entries jammed) and properly sized (controlled entry, clear exits, queues forming outside).

Fast-Deployment Deadlock-Avoidance Checklist

Intersection Check

Use this to rapidly diagnose and fix intersection problems. The question is: are trains built to stop inside, or outside?

Look at three spots: entry signals, mid-intersection, exit zone.

Entry signals must be chain, not regular. Regular says "next block is clear, go"—trains push in and stop mid-crossing. Chain says "can the full path clear? Then go." Official wiki: chain in, rail out. I initially assumed more signals inside the intersection would help; they don't. It's entry discipline that matters.

Check for trains stopping mid-intersection. Watch where the train's tail rests. If it's inside the intersection, the design allows stopping inside—bad. Tail should rest well before entry.

Check exit zone duration. If the exit immediately meets another branch, you may need exit chain signals too, not just entry chains. A train exiting one intersection shouldn't have its rear on the intersection itself while its front enters the next hazard. In tight layouts, chain the exit as well.

Intersection fixes checklist:

• Are approach signals chain signals?
• Can trains stop mid-intersection in the current design?
• Is the exit zone short, requiring exit-side chain control?

Station Front Check

Can waiting trains stay clear of the mainline and branches? This is the only check that matters.

Watch what happens when the station fills: the overflowing train, where does it stop? On the mainline? On a branch? That's a design failure. It should stop entirely within the stacker zone.

Stackers must accommodate your longest-running composition. 1-4-0 trains need roughly 37 tiles (community-measured; not official). More importantly: verify by building and testing. A 1-4-0 waiting train should vanish into the stacker, absolutely no rear spillover.

Station-front checklist:

• Does the waiting queue overflow onto mainline or branches?
• Is each stacker block ≥ your longest composition?
• Is the stacker count adequate for simultaneous arrivals?

Single-Track Check

Single-track stability hinges on passing sections that actually hide trains.

Do passing sections exist? If not, two approaching trains deadlock. This is non-negotiable.

Are passing sections long enough? A train parked in a passing section with its rear on the mainline is useless. The whole composition must vanish.

Are passing sections internally signaled? Subdividing a long section lets multiple trains rest in one zone, multiplying effective capacity without expanding mainline footprint.

Single-track checklist:

• Are there dedicated passing sections?
• Does each section fully contain the longest train?
• Are long sections subdivided into multiple blocks?

Control and Management Check

Well-designed track can still deadlock if destination logic breaks down. Verify:

Do multiple trains target the same station without proportional stacker space? If station capacity is 2 trains but 5 trains route there, they queue indefinitely. Adjust train_limit or stacker count.

Are available station slots exceeding actual train population? Community practice: keep total receiving capacity > current trains. Some destination always accepts arrivals; no train is "lost."

What Changes in Vanilla v2.0 vs. Space Age?

Shared Principles

Rail deadlock prevention principles are identical in v2.0 and Space Age. Chain signals before intersections, regular after—this works in both. The Factorio Wiki signal tutorial applies equally. I tested a v2.0 world extended into Space Age and found the same truths holding: tight entrance control, proper stacker length, and no mid-intersection stops.

Space Age doesn't rewrite signal rules; it scales up the logistics. Larger factories, more production sites, longer routes—same design principles, but enforced more rigidly. Small signal mistakes that v2.0 lets slide become obvious failures under Space Age traffic.

Increased Importance of Preventing Jamups

With Space Age's expanded scale, preventing deadlock upfront becomes vastly more critical than unblocking after the fact.

Early-game small networks forgive some sloppiness; late-game / Space Age networks with interplanetary supply chains punish it immediately. A jam somewhere unseen takes far longer to diagnose; recovery is messier when multiple planets are involved.

The solution is the same, just more essential: clear design of where trains stop (station stackers, waiting spaces) before the jam forms. Reactive fixes work on small routes but fail on sprawling networks.

Space Age Context

Space Age released October 21, 2024. Its content brings multi-planetary logistics, new infrastructure, and vastly expanded transportation needs. But the deadlock principles here remain valid.

This article doesn't spoil Space Age specifics; it establishes principles that apply regardless. Once you understand "stop trains before the intersection, not inside it" and "give waiting trains designated space, not the mainline," Space Age just asks you to apply these rules at larger scale.

Three Common Failures and Quick Fixes

In-Intersection Waiting Fix

Trains stopping mid-crossing is a classic: one train's body spans the intersection, blocking perpendiculars, locking all traffic.

Fix: convert the intersection's entry signal from regular to chain. The official wiki calls this the foundation of intersection design: chain in, rail out. Immediately, trains stop before entering, not inside. One signal swap often breaks chronic intersection deadlock.

If the exit zone is short (another branch immediately after), also convert the exit signal to chain. The train must be fully clear, not just past the intersection threshold.

This fix is instantly visible: instead of constant red signals on all approaches, trains queue outside and flow resumes.

Station Overflow Blocking Mainline Fix

When station queues spill onto the main track or branch, extend the stacker. Ensure one full composition fits per block, rears nowhere near forks or mainlines.

If multiple trains arrive simultaneously, add more stacker blocks. Holding 3-4 trains waiting outside means the mainline and branch stay open.

Position matters too: move the stacker entrance farther from branch points so queued trains never overlap transit zones.

Result: station arrivals queue cleanly; main traffic flows past unimpeded.

Single-Track Head-On Fix

Single-track with insufficient passing sections deadlocks instantly when trains approach from opposite ends.

Add passing sections. Make them long enough to hide the full composition.

Subdivide long sections. Internal signals let one zone hold multiple resting trains, multiplying effective passing capacity.

Result: opposite traffic can alternate through without jamming.

Figure Caption Ideas: NG vs. OK Configurations

Contrast NG (trains stopping mid-crossing, queue overflowing, head-on collision) with OK (trains queuing outside, stackers full and sheltering overflow, passing sections holding alternating traffic).

Emphasize stop positions, not signal count. The difference is clarity of design intent.

Conclusion

Deadlock types reveal where to look. Intersection-middle stops → fix entry signals. Capacity shortfalls → expand intersection or stacker. Mainline queues → add stacker depth. Persistent single-track jams → pass-section overhaul or double-track conversion.

The underlying principle is simple: **know where trains should wait, and only let them wait there.**

Three rules capture most of the fix:

1. Chain signals at intersection entrances (prevents mid-crossing stops)
2. Adequate stacker length, measured by your longest composition (prevents mainline invasion)
3. Scale up to double-track when single-track requires constant expansion (prevents infrastructure debt)

Follow this checklist sequence: fix entry signals, then stacker layout, then passing sections, then convert to double-track if growth demands it. Small changes visible immediately; scaling happens

FAQ

Common deadlocks are usually a signal that one piece of your design principles has broken down, rather than isolated mistakes. When in doubt, holding to just three rules first prevents judgment from wobbling: don't stop trains inside intersections, don't make them wait on the main line at station approaches, and pre-build passing points on single-track sections.

In my experience, train networks stabilize not from signal knowledge alone but from deciding where trains are allowed to wait first. A route can look clean but still jam if waiting positions are ambiguous.

You don't need to jump into a major overhaul. Start by picking the single most congested intersection or station approach, then review just three things: entry signal placement, exit clearance, and stacker length. Even that alone will noticeably change the flow.