【Factorio】Chain Signal Placement: 3 Essential Principles

Chain train signals might seem like they require memorizing lots of rules, but their placement logic is actually quite simple. If you're a beginner to intermediate player building your first intersections in Factorio 2.0 vanilla or Space Age, just remember these 3 core principles: use chain signals at entries, regular signals only where it's safe for trains to stop, and chain signals for short consecutive intersections—and you'll avoid most pitfalls.

When I first built a T-junction, trains kept stopping inside the intersection, and I thought "why is this jammed?" But switching the entry to a chain signal and creating enough space beyond the intersection for a full train length made everything flow smoothly. This article walks through those 3 principles with real examples, so you can predict where congestion will happen.

【Factorio】3 Core Principles of Chain Signal Placement

The practical way to remember this: chain signals belong at intersection entries (where you judge whether to enter), and regular signals belong only where it's safe to stop (after leaving the intersection). Once I settled into this framework, I rarely second-guessed my placement, even on T-junctions or 4-way crossings.

Reference: This article uses the official "Chain Train Signal" explanation from Factorio Wiki, but that page does update, so confirm the current content and URL before publishing: https://wiki.factorio.com/Rail_chain_signal/

Principle 1: Entry points use chain signals

At the entry to branches, merges, and intersections, place a chain signal first. This is the most critical of the three principles. The reason is simple: you want to tell the train "decide whether you can exit completely before entering," not "enter first, figure it out later."

If you put a regular signal at the entry, the train only checks if the next block is clear. It'll squeeze in even if the exit is blocked, then stop inside the intersection. Then other trains get stuck too, and suddenly your whole junction jams. I spent a lot of time on this early on—"I put signals everywhere, why is it still congested?"—until I swapped the entry to a chain signal. The frequency of mid-intersection stops dropped dramatically.

Chain signals look ahead to the next signal's conditions before allowing entry. If the exit is blocked, they hold the train at the entry. That's their whole purpose: prevent the intersection from becoming a parking lot. The same logic applies to branches and merges—before any point where routes conflict, make trains look ahead. If you can fit signals inside the intersection, chain them all together internally; it lets non-conflicting routes flow more smoothly during congestion.

Principle 2: Regular signals only where trains can safely stop

The trick to placing regular signals is simple: put them only where a stopped train won't block your whole network. Another way to say it: regular signals define where trains are allowed to stop.

The textbook case is a long straight section after the intersection, far enough that no part of the train overlaps with the conflicting area. Place a regular signal there, and trains exit the intersection fully before stopping. This is why people say "use regular signals at exits"—though more precisely, it's "use regular signals at exits when there's enough clearance for a full train."

The opposite problem is putting a regular signal where trains shouldn't stop. Then that signal becomes the official stopping point, trains halt there despite partially overlapping the intersection, and later trains get blocked. Deadlock usually isn't complicated—it's often just a regular signal placed where trains should never stop. Understanding this mindset cuts mis-placements dramatically.

This principle matters more as traffic grows. More trains means how and where you let them wait becomes your bottleneck. A regular signal is a statement: "trains can stop here." Once you think of it that way, bad placements jump out.

Principle 3: Consecutive intersections and short blocks use chain signals throughout

"Use regular signals at exits" is the base rule, but not always the full answer. If the space after an exit is too short or another intersection/branch/signal is immediately ahead, connect that exit with chain signals too for stability.

The problem is that placing a regular signal makes the train think "I've exited the intersection," but if the next block is short and the train can't fit entirely, part of it still occupies the previous intersection. It looks exited but isn't—that's your hidden congestion source. I've built this mistake several times, especially on dense layouts: a train at a regular signal seems fine, but its rear is still blocking earlier intersections, crippling throughput.

On consecutive T-junctions or a 4-way immediately followed by a merge, this happens constantly. The fix: make the exit a chain signal too, so the train only enters once it can reach the next safe stopping point unbroken. You're not preventing movement; you're preventing trains from jamming at intermediate positions.

There are two cases where chain signals through exits make sense: when the next block isn't long enough to hold a full train, and when another control point is immediately ahead. The first prevents overhang; the second consolidates control across multiple intersections. Community examples treat "use regular at exits" as a default, not a law, especially for consecutive configurations. Mastering this situational logic beats memorizing rules.

Prerequisite Knowledge: Regular vs. Chain Signals

Terminology: Blocks and Reservation Logic

Clearing this up first makes the difference between signal types much clearer. This assumes Factorio 2.0 vanilla; the same logic applies in Space Age, which launched alongside 2.0 as detailed in the Factorio Wiki roadmap. The signal mechanics discussed here fall within that scope.

Train signals divide rail into blocks—zones between signals or around branches/intersections. Once a train occupies a block, other trains can't enter it. Reservation is the train claiming the path it's about to take. I started with "red stops, green goes, yellow caution," but that missed the bigger picture. Most intersection jams happened because I misunderstood the reservation system.

A regular signal mainly checks if the next block is free. A chain signal looks much further: through the next conflicting area to the next chain signal's conditions. The official tutorial emphasizes chain signals for intersection management. In one sentence: regular signals ask "is the next block clear?"; chain signals ask "can the full route to the next signal stay clear while I pass?"

Space Age

Factorio Wiki

wiki.factorio.com

Decision Logic: Regular vs. Chain

Regular signals work best at the entry to areas where it's fine to stop. They let trains through if the next block is empty, ideal for straights and station queues. But at intersection entries, that's too narrow a view. If there's any gap inside, the train enters; if the far side is blocked, it stops mid-intersection. This is the root cause of entry-level congestion.

Chain signals do the opposite: they're conservative about intersection entry. They check whether the route holds clear all the way to the next signal, not just the immediate block. If the route fails that test, they hold the train outside. That's their whole design: keep the intersection from becoming a waiting area.

This explains the baseline rule: entries use chain (advance judgment), exits use regular (parking position). It's a role split.

A visceral example: when you swap an intersection entry from regular to chain, that train suddenly goes blue (conditional) and waits outside instead of creeping in and getting stuck mid-crossing. The shift is dramatic, and once you see it, the logic clicks.

Intersection design uses unified reservation: chain signals treat the intersection as "enter only if I can occupy the whole path from here through the exit and into the safe stopping zone." That's why trains don't jam mid-intersection. But if the exit space is short, a regular signal there tells the train "stop here"—prematurely claiming that short zone as safe. For consecutive intersections, extending chains forward preserves that unified judgment and moves the safe stop point further out.

Color Codes (Blue/Red/Green) and Waiting Before the Intersection

Signal colors aren't just "go/stop"; they show how far a reservation extends. Regular signals are mostly green (proceed) or red (stop). Chain signals introduce blue: "there's a path ahead, but only under conditions; proceed cautiously." When you see blue around an intersection, read it as "the train is looking ahead and moving conditionally."

The bigger concept is **waiting before the intersection.** Don't park trains inside; keep them outside. Simple change, huge impact on network stability. The pattern looks like this:

Regular signal at entry (bad)
→ next block has room, train enters
→ but exit is blocked; stops mid-intersection

   [Regular]
----S------X****intersection****X---[blocked]
             ↑
          stops here

Chain signal at entry (good)
→ checks exit conditions first
→ if blocked, train waits outside

   [Chain]
----C------X****intersection****X---[blocked]
      ↑
   waits here

This "wait outside" design plus unified reservation is the foundation. Intersections are for passing through, waiting happens outside. In group play, this principle alone cuts accidents dramatically. It looks simple, but breaking it degrades even well-built intersections.

Signal basics are explained in the official tutorial; for image-based examples, resources like "Factorio railway construction from zero (chain signals)" or factorio@jp Wiki's layout examples help a lot. Once you see intersections as "places you enter only when conditions align to pass through entirely" rather than "places you enter and hope," regular vs. chain usage becomes intuitive.

Principle 1: Entries to Branches, Merges, and Intersections Use Chain Signals

This principle is the hardest to get wrong. Place chain signals at entries to branches, merges, and intersections. It's your most stable default. The reason: chain signals let trains think "even if the entry is clear, if the exit is blocked, I wait outside." Another way to phrase it: don't use the intersection as a waiting area.

Honestly, my first instinct was "if the entry is green, shouldn't the train go?" But a regular entry signal is too short-sighted. Trains squeeze in, block the far side, and you get cascade jams. Swap the entry to chain: the signal shows blue (conditional) while waiting, then green (full clear) when conditions allow. When you see that in real-time, the difference is striking.

Train signals guide traffic through a chain of conditions. At intersections, think of it as "only enter if you can reserve through to the safe exit." This makes sense at any entry point.

T-Junction: Placement of Entry Chain Signals

T-junctions make this principle very clear. Place chain signals at every entry to the conflicted zone—one from the main line toward the intersection, one from the branch toward the intersection. The goal: no mid-intersection parking. Simple layout, simple rule.

T-junction template

        branch
         |
        [C]
         |
==****junction****==
   [C]          [exit]
main→

Think of it as "judge before entering the junction square." The chain signal makes the train check whether the path beyond the junction stays clear, not just the junction entry. If the exit is clogged, the train waits at the entry. If it were regular, the junction's first block might be empty, and the train enters despite the exit being blocked—mid-junction stop, and now lateral traffic can't move either.

A vivid failure: main-line train enters via regular signal, hits the junction, can't exit (blocked on the other side), stops mid-junction. Now the branch trying to merge can't proceed either. Both lines stall. I've spent hours on this exact scenario. The fix: chain at entry, and the behavior flips entirely—entry waits until the path is fully clear.

4-Way Intersection: All Entries Use Chain Signals

On a 4-way, this principle is even more critical. All entries should be chain signals because the number of conflicting paths is much higher. If even one entry is regular, mid-intersection stops happen much more often.

4-way template

        [C]
         |
==****junction****==
[C]              [C]
         |
        [C]

Why all four? A 4-way isn't "take my route if it's clear." The same junction handles north-south, east-west, and all turns simultaneously. A single mid-junction stop steals multiple paths at once. That 1-train stop cascades to all directions.

Chain signals at all four entries treat the 4-way as "enter only when your full path through and past the junction is clear." In practice, trains line up outside, and only when their path is open do they flow through. The visual is calming: trains wait orderly at entries and zip through when green. With regular entries, they'd try to squeeze in, jam mid-crossing, and create nightmare congestion.

The official tutorial favors chain management of intersection entry. A 4-way is the textbook case for that approach.

Y-Split/Merge: Chain Signals at the Split/Merge Point

Y-splits look gentler and are often overlooked, but they work the same way. **Place chain signals before the split (where the path diverges) and before the merge** (where paths combine).

Y-split

      ↗ exit A
---[C]<
      ↘ exit B

Y-merge

entry A ↘
        >[C]--- output
entry B ↗

Why a chain before the split? If you picked the right exit but it's blocked, a chain signal keeps you from entering the split at all. A regular signal lets you enter the split point and then stop—blocking the other exit path too. Y-splits don't look like big intersections, so it's tempting to put regular signals, but that's when people complain "my split has one train blocking both paths." Chain before a split prevents that.

Same for merges: if you let one path enter the merge while the output is full, that train jams the merge, and the other input can't proceed. On a main-line merge especially, one side's 1-train stall drops main-line speed. Chain at the merge entry fixes it—trains only enter once the merge-to-output path is clear.

Blogs like "Factorio Railway from Zero (Chain Signals)" walk through this with examples. A Y is an intersection by another name, and entry-chain logic solves it the same way.

Principle 2: Regular Signals Only Where Trains Can Safely Stop

Train Length and Stopping Space

When I say "the exit can use a regular signal," I don't mean "exits = regular, always." The condition is **one thing: there's enough space beyond the intersection for your longest train to fit completely.** Overlook this, and even chain entries won't prevent mid-intersection stops.

Train length is simple: measure from the front of the engine to the rear of the last car. Use the longest train your network runs. If you run 2-4 mixed, base it on the longest composition. A supply train longer than others? Base it on that. The space after the exit needs to fit that longest train entirely, with breathing room around signals.

Measure on an actual train in-game; don't eyeball it. Looking at a parked train and counting tile-lengths is more reliable than guessing. I learned this the hard way: "looks like it fits" often meant the rear slightly overlaps the intersection, which blocks it 100% despite looking marginal.

Blogs like "Factorio Railway from Zero (Chain Signals)" frame it precisely: regular signals at exits require sufficient post-intersection space. The mnemonic "chain at entry, regular at exit" is shorthand; the precise rule is **"chain at entry, regular at exit only if there's clearing space for a full train."** This conditional phrasing helps you judge odd layouts.

Checklist: Safe Conditions for Regular Signals at Exits

Ask yourself this one thing: can a train stopped at this signal stay outside the intersection completely? If yes, regular signals work. If no, stay with chain logic.

Decision sequence:

1. Is there a stopping zone after the intersection exit?
2. Does your longest train fit completely in that zone?
3. Does the train fit without its rear overlapping the intersection?

If all three check out, regular signals are fine. Otherwise, the regular signal becomes "stop inside the intersection," and your later trains get blocked.

This view is consistent with the official Wiki and community practice. Forget the signal's name; judge whether it's a valid stopping zone. Exits that look "forward-facing" might still be too short, in which case they're not stopping zones.

Chain Train Signal - Factorio Wiki

wiki.factorio.com

Short Exits and the Problem They Create

Short exits cause trains to not fully clear the intersection before stopping. This jams the train itself and everyone behind it, plus anyone else needing that intersection. On a 4-way, multiple directions suffer. On a T, both main and branch jam.

I hit this phase when running 2-4 trains: I treated "exit = regular" as law, but the exit space was too short. Trains would partially exit and stop, leaving their rear overlapping. It looked fine at a glance, but operationally it was a full block. Swapped the exit signal to chain, added external stacker space, and suddenly smooth flow. The issue wasn't the entry placement—it was the exit space.

Short exits + regular signals = you've accidentally made the intersection part of your waiting area. Bad combo. Solutions: extend the post-exit clearing zone or change the exit to chain logic and move the real parking area further out. Community examples (factorio@jp Wiki) show that intersection throughput depends heavily on pre/post clearing space, not just the junction itself.

Principle 3: Consecutive Intersections and Short Blocks Use Chain Signals Throughout

Consecutive Intersections: When to Extend Chain Logic to Exits

The biggest confusion point is when the exit of one intersection is immediately followed by the entry of another, with a short gap. Naively applying Principle 2 says "that exit = regular," but short gaps cause trains to jam at intermediate positions.

Reason: a train exits the first intersection but can't move far (short block), so it stops there. Now that short block is occupied, the next intersection is functionally blocked, and the train reservations fall apart. The train moved out of one intersection but into the next intersection's airspace. It looks like progress but creates gridlock.

I've built consecutive junctions where one side is visibly empty but all trains stop. Swap the first exit to chain logic, and suddenly traffic flows because the train won't enter the first intersection unless it can clear through the second. Extend chain signals past the exit when the space doesn't support full trains.

The principle: don't judge "exit" in isolation; judge "exit to the next safe stopping point" together.

This shows up in older guides as an exception, but modern practice (2.0+) applies it routinely. One additional nuance: internal intersection block division has become viable in 2.0. Community practice reports benefits from internal chain splits, but always verify the current patch notes and wiki before using techniques you haven't confirmed.

The concept is:

No split
[entry chain] → [intersection as one block] → [exit]

With split
[entry chain] → [internal block A] → [internal block B] → [exit]
                 \____non-conflicting routes can use separately____/

When splits work, previously "one train = all stop" intersections become "non-conflicting routes flow together." I used this on a congested consecutive junction: one side was open, but everything was gridlocked. Splitting the internal blocks with chains fixed it—paths that don't cross now run in parallel. The visual change is subtle, but throughput jumps.

Key caveat: splits only help when the divided areas have independent routes. Splitting pointlessly, where every path hits the same spot anyway, just adds complexity.

Internal block division is "isolate non-crossing routes," not "cut up intersections for fun." Once that distinction is clear, the technique makes sense.

Check community layouts (factorio@jp Wiki) for intersection patterns and real examples. The fundamentals stay the same; the splits are a refinement.

Non-Conflicting Routes All Stopping: Fix via Internal Division and Chain Logic

When you see "these paths don't cross, but both stop," the cause is usually one giant intersection block where all trains must wait. Signals are right, layout is fine, but throughput is capped because unrelated trains can't move simultaneously.

Ten-way junctions are the classic case: all entries are chain (good), but the interior is undivided (bad). A northbound train occupies the whole interior, even though an eastbound path never touches it. Fix: divide the interior with chain signals so independent routes become separate blocks. Suddenly, northbound and eastbound can flow together if their paths don't cross.

Train Network / Layout Examples - factorio@jp Wiki*

factorio@jp Wiki*

wikiwiki.jp

Real-World Failures and Fixes

Mid-Intersection Stops: Entry Regular or Exit Too Short

When trains stop mid-intersection, there are two culprits: entry regular signal or exit space too short. Both are bad; the second is sneakier.

If the entry is regular, trains don't look far enough ahead and jam inside. Swap it to chain. That's the primary fix. The train will then evaluate whether it can fully traverse before entering.

If the exit is short, trains partially exit and stop, occupying the intersection despite seeming to be outside. Extend the exit clearing zone or chain-connect to the next safe point.

Non-Crossing Routes All Stalled: Suspect Internal Block Division

If two independent paths jam simultaneously without crossing, the root is usually one big interior block. Chain signals are placed correctly, but interior granularity is missing.

Test: remove all interior signals, make it one giant block, and confirm the jam worsens. If so, internal division helps. Revert and add interior chain signals where non-crossing routes can diverge. The improvement should be obvious.

Bidirectional Single-Track Deadlock: Switch to One-Way Double-Track

Bidirectional single-track is convenient at first, but scaling it is brutal. Trains face each other and both stop, locking the line. Multiplay makes this worse: someone adds a station, and stable bidirectional suddenly deadlocks.

Real solution: go one-way, two-track. This eliminates head-on waits entirely. Entry logic simplifies because you're just routing same-direction trains, not solving confrontations. Signals become more standard, and deadlock types drop. It's more track but so much simpler.

If you must keep bidirectional, isolate sidings outside the conflict zone, use chain entries strictly, and never let trains sit head-to-head. But honestly, one-way is the antidote.

Short Exit Blocks: Ensure Your Longest Train Fits

Short exit blocks mean trains can't fully park outside the intersection. Result: part of the train stays inside, blocking later traffic.

Especially bad: exit signal, short block, then another signal. That short block becomes "stop here" officially, but it overlaps the original intersection.

Fix: extend the stop space or shift parking to a dedicated external stacker. Pre-clear and post-clear zones are non-negotiable.

Next Steps: 2.0+ Block Division and Further Reading

Internal Block Division Mechanics

Post-2.0, dividing intersection interiors to separate non-crossing routes is practical and often unlocks better throughput. This bridges the gap between "by-the-book correct" and "actually efficient." When trains move fine but feel slow, interior division sometimes adds the capacity you're missing.

Start by mapping which routes truly cross and which don't. Separate the non-crossing paths with chain signals. The point isn't more signals; it's isolated passages for independent flows. Don't over-subdivide; complexity becomes maintenance liability, especially in group play. Aim for clarity.

One caveat: this works best on layouts with good geometry. Tight curves or complex merges don't divide well—sometimes redesigning the intersection beats adding signals.

One-Way Double-Track as the Scaling Solution

When a single-track bottleneck kills your network, switching to one-way doubles does more good than fine-tuning signal placement. Design becomes standard, routes are predictable, and signals follow the same templates everywhere.

This is the next leap after mastering the 3 principles. Start with one critical route, convert it to one-way double-track, and compare. The planning burden drops, and capacity rises. Once you're comfortable, expand.

Checklist and Action Plan

Quick-Check: Chain at Entry, Regular at (Safe) Exit

• Entry to branches/merges/intersections → chain signals? ✓
• Exit space sufficient for longest train? ✓
• Short exit or immediate next intersection → chain, not regular? ✓

Getting Started: Pick One T-Junction

Start by re-signaling a single T-junction correctly. See the change in train behavior. Then apply the same logic to a 4-way, then consecutive intersections. Small wins build confidence.

Scaling: Consider One-Way Double-Track Early

Once you're comfortable with the 3 principles, evaluate whether your main corridor needs one-way doubles. It simplifies design and future expansion. Small networks can stay hybrid; large networks benefit enormously from the switch.