【Factorio】Three Principles of Chain Signal Placement

Chain signals—formally called chain rail signals—might look like they have a lot of rules to memorize, but the actual logic for placement is surprisingly straightforward. If you're building your first intersections in Factorio 2.0 vanilla or Space Age as a beginner to intermediate player, you can get really solid results with just three core rules: use chain signals at entrances, normal signals only where trains can safely stop beyond the junction, and keep using chain signals at consecutive tight intersections until you reach a proper waiting zone.

I spent my early days watching trains jam up inside a T-junction over and over, thinking "why does this keep deadlock?" But the moment I switched the entrance to chain signals and left enough space past the crossing for a full train length, traffic flowed smoothly. This article walks through those three rules with real examples, so you can see exactly where to place signals to avoid pile-ups.

【Factorio】Three Core Principles for Chain Signal Placement

The quickest way to remember it: chain signals are for preventing trains from entering a junction unless they can exit safely, and normal signals mark spots where it's okay for a train to stop once it's completely past the crossing. Since I started thinking about it that way, I hardly ever second-guess placement on T-junctions or crossroads anymore. Note: This article references the official "Chain Rail Signal" guide on the Factorio Wiki. Since wiki content updates, please verify the current page and URL before publishing: https://wiki.factorio.com/Rail_chain_signal

Principle 1: Chain Signals at Entrances

For entrances to branches, merges, and junctions, start with a chain signal. This is the most critical of the three rules. The reason is straightforward: instead of letting trains think "I'll figure it out once I'm in," make them decide "can I safely exit?" before they enter.

Put a normal signal at the entrance, and a train will enter if just the next block looks clear. That means it can push its nose in, get stuck mid-crossing because the exit is blocked, and jam up both follow-up traffic and trains from other directions. Honestly, this is the classic beginner mistake I used to make constantly. I'd place signals and still see gridlock, but switching entrance-only to chain signals cut junction-blocking stops noticeably.

Chain signals look ahead to the next signal's conditions before committing. If the path beyond the junction is blocked, they hold trains at the entrance. That's the whole point—don't use the junction itself as a waiting area. Whether it's a branch, merge, or intersection, the rule is the same: always make trains read ahead before entering where routes can collide.

If your junction layout allows internal signals, connecting the middle blocks with chain signals too is standard practice. This lets you break apart non-crossing paths further, which stabilises heavy traffic. You'll see the biggest difference on double-line crossroads or intersections with mixed left and right turns.

Principle 2: Normal Signals Only at Safe Stopping Points

Normal signals belong in one place: where a stopped train won't block the whole network. Think of normal signals as "stopping position markers."

The typical spot is beyond the junction, where there's enough straight track and the train's rear won't reach back into any intersecting routes. That's why people say "exits use normal signals"—more accurately, use normal signals only if there's real stopping space beyond the exit. Place a normal signal there, and trains roll fully clear before stopping, leaving the junction open.

The opposite problem is placing normal signals where trains shouldn't stop. The moment a normal signal is there, a train treats it as a valid waiting point. So even though the train looks like it cleared the junction, its rear is still occupying the crossing area, blocking follow-up traffic. Most deadlock sources are surprisingly basic: a normal signal placed somewhere trains needed to keep rolling. That one insight cuts placement mistakes significantly.

This principle matters more on busy main lines than single T-junctions. More trains mean stopping points become your throughput. A normal signal essentially says "okay to wait here"—once you think about it that way, misplacement drops sharply.

Principle 3: Keep Chain Signals for Tight Gaps and Consecutive Junctions

"Use normal at exits" is the baseline rule, but it's not always right. When exit space is tight or another junction/branch signal appears immediately after, use chain signals at the exit too.

Here's what goes wrong with a normal signal exit in tight spots: the train looks like it's left the junction and tries to proceed, but the gap's actually too short for the full train length. Part of it stays back in the original crossing. It looks like it's clear but isn't, making it a hidden bottleneck. This happens constantly around compact merges or T-junctions right before another split.

Tight consecutive T-junctions or a crossroad directly before a merge are classic trouble spots. I've built enough of these poorly to remember: put a normal signal at a short exit, and trains jam up mid-crossing because the next block fills before they finish clearing. Switching that exit to chain signals—letting them read further ahead—cleans it up.

Two situations call for chain-to-chain connections:

1. Short exit space that can't fit your longest train
2. Another decision point immediately after—another junction, branch, or signal

The first prevents overhang into the original crossing. The second lets you judge all the way to the next safe zone before committing. Simple as that.

Community examples treat "exit normal" as the baseline with regular exceptions for tight junctions or back-to-back intersections. Understanding the reason beats memorizing rules. Chain signals at entrance, inside tight bits, and short exits; normal signals only in long safe zones. Build that way, and even large networks hold together.

Background: Normal vs. Chain Signal Logic

Terminology: Blocks (Closures) and Reservation

Getting this clear first makes chain vs. normal signals click. This covers Factorio 2.0 vanilla, and the same logic applies in Space Age (released the same day, as noted in the Upcoming features announcement).

Rail signals divide tracks into blocks (also called closures)—sections between signals, or regions covering branches and crossings. A train already in a block generally bars other trains from entering it. When we talk about reservation, think of a train claiming the path it's about to take. Early on, I thought signals were just "red = stop, green = go," but I realised later that dense intersections depend entirely on how trains reserve routes.

Normal signals mainly check if the next block is free. Chain signals go further: they look at how far the route extends safely ahead before deciding whether entry is safe. The official tutorial on rail signals (Factorio Wiki) builds intersection management around chain signals for exactly this reason. In one sentence: normal signals ask "is the next block clear?", chain signals ask "can I complete my path through the next signal safely?"

Space Age

wiki.factorio.com

Why Normal Signals Fail at Junctions; Why Chains Solve It

Normal signals excel at "I can stop here" zones—straight sections where a waiting queue forms. The problem: at a junction entrance, that judgment's too short. If the crossing interior has any free space, a train charges in, then stops mid-crossing if the exit's blocked. This jam is the root of most early gridlock.

Chain signals do the opposite—they're cautious about entry. They don't just check the crossing interior; they verify the path stays clear all the way to the next signal. If not, they hold the train outside. That's the logic: make entrances ask "will this route stay open?" not "is the door ajar?"

This clicks when you see it happen. Replace entrance normal with chain, and the train switches from "head goes in immediately" to "wait at the entrance until the path is fully clear, then roll through completely." The difference is stark—chaos turns orderly in seconds. That's when it sinks in: the entrance decision controls whether trains stop inside or stay outside.

Another way to think about it: chain signals create single-unit reservations for the entire path. The train "reserves from entrance through exit safely" or doesn't enter. It prevents the "halfway stuck" scenario entirely.

Reading Signal Colours: Blue, Green, Red, and "Entrance Wait"

Colours aren't just "go/stop"—they reflect reservation depth. Normal signals are typically green (proceed) or red (stop). Chain signals add blue, which roughly means a path exists ahead with conditions, so proceed cautiously. At intersections, blue-lit chain signals often mean "reading ahead while proceeding."

More important than colour is the entrance wait concept. Don't let trains stop inside; make them wait outside. That's the game-changer:

Normal signal at entrance
→ Interior free? Enter.
→ But exit is blocked. Stop inside.

   [Normal]
----S------X****Junction****X---[Blocked]
             ↑
           Stops here (bad)

Chain signal at entrance
→ Check exit safety first.
→ Exit blocked? Wait here.

   [Chain]
----C------X****Junction****X---[Blocked]
      ↑
    Waits here (good)

This "wait outside" design, linked to full-path reservation, is what stops deadlock in intersections. The interior stays for transit, not waiting. Large multiplayer networks with this principle suffer way fewer pile-ups. Signal types are secondary; where trains actually stop matters most.

For basics, the official wiki tutorial and community examples like "Starting Factorio Railways (Chain Signals)" make this visual. Once you stop seeing a junction as "a passage" and start seeing it as "a place trains only enter when safe to clear," the choice between normal and chain becomes automatic.

Principle 1: Chain Signals at Branch, Merge, and Junction Entrances

This is the rule you'll apply most and rarely regret. Put chain signals before branches, merges, and junctions. Just lock this in and half your signal hesitation vanishes. The why: chain signals let you enforce "if I can't exit fully, I don't enter"—no trains waiting inside crossings.

Early on, I thought "if the entrance light's green, in we go?" Wrong. Entrance normal signals don't look far enough, so trains nose in and stop short if anything's blocked ahead. One jam inside a junction blocks adjacent traffic in a chain reaction across your whole network. Flip that entrance to chain, and instead of pushing in, trains wait (blue) outside, then surge through (green) once conditions clear. You see it immediately—traffic that seemed stuck suddenly flows. It's the signal swap that convinced me chain signals weren't optional.

As the Factorio Wiki explains, chain signals manage entrance conditions based on path feasibility. Think of it as "reserve this route or don't enter" logic. That mindset keeps you from placing them wrong.

T-Junction: Where to Put the Chain Signal Entrance

T-junctions make the principle crystal clear. You've got a main line and a side line, and every path entering the junction interior gets a chain signal before it. The goal: don't let trains enter the central crossing area without knowing they can exit.

T-junction baseline

        Side
         |
        [C]
         |
==***Junction***==
   [C]       [Exit side]
Main→

The logic: "before entering this junction cell, check if you can clear it." Chain signals do that; the train verifies it can exit before nose-ing in. Normal signals just check if the immediate next block is clear, so trains push in and jam.

The failure case is vivid on a T-junction. A main-line train enters with normal entrance, the side-line merges, the exit is blocked, and the main-line train stops mid-crossing. Now the side-line train can't go, and incoming traffic backs up both directions. I burned a lot of playtime watching this. Flip to chain entrances, the junction-internal jams disappear, and the whole flow smooths out.

Four-Way Crossroads: All Entrances Chain

This rule becomes critical at crossroads. A T-junction is simpler; a four-way has four competing routes. One normal entrance can wreck everything, so use chain at all four entrances.

Four-way baseline

        [C]
         |
==***Junction***==
[C]           [C]
         |
        [C]

Why all four? Because a four-way doesn't have "my direction alone matters." A train entering from the east with a normal signal sees a clear next block and barges in mid-crossing. It stops short of the exit; now north→south is blocked, northwest→southeast is blocked, and every other train piles up. One stuck train closes multiple routes at once.

Chain at all entrances makes trains treat four-ways as "enter only when I can fully exit" zones. You see trains line up neatly outside, and only when a route clears do they roll through in one motion. The traffic calm is immediate. It's a huge difference: normal entrances let trains muscle in; chain entrances keep them orderly outside.

The Factorio tutorial emphasises this entrance-focused control because it's the lever that prevents jams. A four-way is where it's most obvious.

Y-Splits and Y-Merges: Chain Before the Branch/Merge Point

Y-junctions look soft, so they're easy to miss, but they're intersections in disguise. Chain signals before the split point (branch) or before the merge point (where two lines become one).

Y-split

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

Y-merge

Input A ↘
        >[C]--- Main
Input B ↗

At a split, the chain signal prevents entry if the chosen exit is blocked. Normal here means trains can poke into the fork and stop, blocking the other exit's path too. Merges have the same logic: stop normal-signal half-merged trains that jam the opposite input. Y-junctions look gentler than crossroads, so it's tempting to think "a little jam won't matter." It will.

The same real-world example rule applies: branch entrance, merge entrance—chain signals. T-junctions, four-ways, Y-forks: same placement rule, same result. That consistency keeps you from guessing.

External references like "Starting Factorio Railways (Chain Signals)" show the entrance-chain / exit-normal baseline with real examples. Y-junctions are just differently-shaped intersections; the logic is identical.

Principle 2: Normal Signals Only Where Trains Can Safely Stop

Train-Length Thinking

"Exit = normal signal" doesn't mean "automatic." The real condition: the space past the junction must fit your longest train completely. Get this wrong, and chain entrances won't help.

Practically, measure from locomotive front to the last car's rear. Your longest train, not your average. If the 2-4 is normal but supply trains are longer, use the supply length. Exit space needs to hold that entire formation plus some room to avoid feeling cramped near signals.

Eyeballing is risky. I've misjudged lengths before and found the last car still overlapping the crossing—just a tiny bit, but enough to completely block it. That overlap turns a clear exit into a hidden bottleneck. Measure real trains in the world to feel the spacing.

External sources like "Starting Factorio Railways" emphasise that normal exits depend on space availability. Most beginners memorise "entrance chain, exit normal" without the condition. Think instead: **entrance chain, exit normal *only if safe stopping space exists***.

Checking If Normal Is Safe at an Exit

Only three checks:

1. Is there a waiting zone past the exit where trains can stop?
2. Does your longest train fit completely in it?
3. Does the rear stay clear of the junction interior?

If yes to all three, normal works. Otherwise, chain is safer.

The logic: a normal signal marks where it's okay to stop. If that stop point actually lets trains extend back into the crossing, you've defeated the purpose. Think of it as: does this spot deserve a "okay to stop" signal? If yes, normal. If the train would block the crossing while waiting, no.

This framing comes from the official chain-signal wiki and community examples. Rather than naming the signal, ask whether the block itself is a valid parking zone. Works for T, four-way, Y, and weird hybrid layouts.

Chain Rail Signal — Factorio Wiki

wiki.factorio.com

Tight Exits: When "Normal Exit" Fails

Tight exit space causes a classic problem: trains look like they cleared the junction but haven't. They don't fit entirely past the signal, so their rear hangs in the crossing. Looks clear but isn't, making it a hidden deadlock trap.

I've done this with back-to-back T-junctions countless times. Short exit, normal signal, and trains creep forward one block at a time. Each block brings the rear slightly further out of the crossing, but the root stop position is still inside. Downstream traffic gets blocked, the network bogs down. When I realised the exit distance was the culprit, not the entrance, I extended the waiting zone and added a stacker. Boom—stability returned.

The bad setup: short exit block with a normal signal cutting it immediately after the junction. This makes the tiny gap a "valid stop zone," which defeats the whole point.

The fix: either extend the exit zone or switch it to chain so trains don't stop in the gap. If the exit is short, chain prevents trains entering until they can clear through. Community examples on factorio@jp Wiki show that off-crossing junctions rely on enough clearance, not just the right signal colour. Most network slowness isn't at the crossing itself but at the exit—trains look clear but aren't.

Train Network / Layout Examples — factorio@jp Wiki*

factorio@jp Wiki*

wikiwiki.jp

Principle 3: Keep Using Chain for Tight Gaps and Back-to-Back Junctions

Consecutive Junctions: Chain at the First Exit Too

The trickiest case: a second junction or signal appears right after the first's exit. Sticking purely to "exit normal" here invites pile-ups that look invisible.

Why? A normal exit signal says "okay to stop here." But "here" is actually the entrance zone of the next junction. Train enters, hits the second junction's backed-up traffic, and stops mid-gap. The first junction stays occupied, the network clogs, and you've turned two separate crossings into one big slow zone.

I've built parallel tight T-junctions where the first exit led directly into the second entrance, and putting normal at the first exit made everything grind. Trains would nudge a block forward, hit the next jam, and stop in between. Looking at the map, it seemed logical, but operationally, both junctions were locked solid. Switching the first exit to chain—so it waited for the whole path through the second crossing to clear—broke the gridlock immediately.

The principle: don't just exit the first junction; exit all the way to a truly safe waiting zone. If the next crossing is too close, chain the first exit too.

This applies to rapid-fire splits, merges, and crossroads. Community examples treat "exit normal" as a starting point; when junctions bunch up, switching to chain through the tight section is standard.

On an advanced note: internal block splitting in 2.0 environments can help. Rather than one giant junction block, you can divide it so non-crossing routes run separately. Community examples show this working post-2.0, but verify against official patch notes before relying on it.

The idea:

No division
[Entrance chain] → [Junction = one block] → [Exit]

With division
[Entrance chain] → [Internal block A] → [Internal block B] → [Exit]
                    \__Non-crossing routes use separate blocks__/

Splitting lets non-interfering paths run in parallel. Where one big junction would deadlock everything, split internals let "directions that don't collide" pass simultaneously. Early on, I fixed a tight crossing by internally sectioning it—suddenly the empty route would flow while other trains waited, instead of all stopping together.

Splits only help where the divided blocks represent truly independent routes. If all paths eventually converge at one point, extra blocks just complicate things. Think of splitting not as "make more signals" but as "separate non-colliding routes into independent zones."

Practical design:

1. Identify which routes actually cross vs. which don't
2. Leave signal-placement room after branches/merges diverge
3. Divide only where there's a natural split to separate

This builds understanding better than recipes. See factorio@jp Wiki examples to visualise how internal sectioning fixes tight areas.

Non-Intersecting Routes Stalling Together: The Fix

Dense junctions sometimes seem safe but still gridlock. The cause: internal blocks are too large. Routes that never collide still wait for each other because they share the same signal zone.

Example: a four-way where northeast→southwest never collides with northwest→southeast, but both are in one massive block. One route occupies it, the other waits. Splitting into smaller blocks so non-colliding routes are independent breaks this.

Design around non-overlapping routes:

Bad: One huge block
A route ──┐
          ├─[Big block]
B route ──┘
→ B waits even though it never crosses A

Good: Divided blocks
A route ──[Block 1]──┐
                     ├─[Block 2]
B route ──────────┘
→ B can run through Block 2 while A uses Block 1

This is especially useful in 2.0. The payoff is smooth parallel flow instead of stop-and-go gridlock. I've watched network throughput jump from "everyone waits" to "safe routes roll through"—same intersection, just internal separation.

But don't over-segment. The point is clarity and necessary independence, not maximum block count. Multiplayer networks benefit from readable junction logic.

Layout Examples: T-Junctions, Crossroads, and Tight Series

T-Junction: The Textbook Chain Entrance / Normal Exit

T-junctions are ideal for learning because the principle is plainly visible. Normal entrances feel efficient but stall trains in the crossing. Chain entrances let the whole picture unfold.

Bad example: normal entrances everywhere.

Bad
      S
      |
---- S+---- S
      |
      S

Train at T-center blocked? Whole junction frozen.

Improve by chaining just the entrances:

Good
      C
      |
---- C+---- S
      |
      S

Trains wait at entrances, roll through when clear.

But T-junctions have an exception: if the exit zone is short (second junction nearby), chain that exit too.

Exception: tight exit
      C
      |
---- C+---- C -- C+--
      |
      S

Second junction right after; exit normal would jam.

Here, the exit chains to the next safe zone, preventing trapped trains.

Four-Way: All Chain Entrances, Internal Splits Help

A four-way with normal entrances is a bottleneck. Chain at all four solves immediate safety.

Bad
        S
        |
----S+S----S
        |
        S

Any entry jams everything.

Good
        C
        |
----C+C----C
        |
        C

But safety alone doesn't max throughput. If northeast→southwest and northwest→southeast never collide, splitting internals lets both run together:

Better: split non-crossing routes
          C
          |
------[A]---[B]------
          |
          C

Now parallel routes don't wait for unrelated crossings.

Consecutive Junctions: Chain the Exit Forward

Back-to-back T-junctions show the principle starkly. Normal exits fail here; chain through fixes it.

Bad: normal exit blocks next entrance
---- C + A + S ---- C + B + S ----

Train exits A into short gap, hits B's queue, stops in A's exit.

Good: chain exit forward
---- C + A + C ---- C + B + S ----

Exit chains to B's next signal, so only enters A when B's path is clear.

The gain is a smooth flow: trains line up outside A, roll through to B, and stop only at a safe zone downstream.

Common Failures and Fixes

Trains Stuck Inside Junctions: Normal Entrance or Short Exit

Two causes: normal entrance or exit space too short. Visual clues look fine, but the train occupies the crossing while waiting.

Fix 1: chain the entrance. This prevents entry unless the full path clears.

Fix 2: extend exit space to hold the longest train completely. Measure carefully; a car-length short and you've lost the benefit.

The mindset: if a stopped train extends back into the crossing, that spot isn't a valid waiting zone. Expand the zone or chain upstream.

Safe-Looking Routes That Still Deadlock: Internal Blocks Too Large

A four-way or large split looks fine but multiple routes wait together. The culprit: internals are one huge block instead of divided.

Solution: segment interior blocks so non-crossing routes are independent. "We never collide but still wait" means your block definitions are too broad.

This is invisible until you split and see routes flow in parallel. Test by temporarily removing internal signals—if unrelated routes pile up, splitting is the fix.

Bidirectional Lines Deadlock: Prioritise Single-Direction Complexity

Bidirectional single tracks seem efficient but deadlock when trains meet in merge/split zones. Two trains approach the junction from opposite sides and jam each other.

The practical fix: use one-direction dual track. Removes head-on contention entirely. Entrances, splits, and merges all simplify because direction is fixed.

If forced to keep bidirectional, isolate waits outside junctions with chain signals and proper staging, but this adds overhead. Single-direction is cleaner and scales better.

Exit Blocks Too Short: Measure Your Longest Train

Exits must clear your longest formation, not your average. One long supply train among short ones, and that one stops mid-crossing.

Count locomotive + cars, measure in-world, and confirm the exit zone fits it fully plus breathing room. If you can't fit it, stage trains in stackers outside the junction.

Advanced: Block Splitting in 2.0+ and Further Reading

Internal Block Division Strategy

Post-2.0, dividing junction interiors to isolate non-crossing routes is practically useful. A junction that's "safe but slow" often gets faster when you split internals so parallel paths don't share blocks.

The goal isn't tiny signal spacing—it's separating routes that never collide. Overhead-complex splits barely help; clean layouts with natural path separation gain a lot.

Design order:

1. Map which routes cross and which don't
2. Leave room for signals where paths diverge
3. Chain where separation happens

Readability matters in multiplayer. Over-complex splits confuse other players. Keep division purposeful.

Single-Direction Dual-Track Benefits and Rollout

Switching a network to single-direction dual-track smooths junction logic dramatically. Heading direction becomes fixed, so intersection types standardise.

Gains:

• Simpler route combinations (no head-on waits)
• Easier signal placement (fewer junction types)
• Better scaling (large networks stay stable)

If expanding existing bidirectional networks, phase the conversion gradually—upgrade bottleneck sections first.

Circuit Network Integration (Lookhead)

Beyond manual signal placement, circuit networks can control station entry. This article doesn't cover that, but large networks eventually benefit from signals tied to station-load logic.

Circuit Network Integration (Preview) (Editor note) No in-site articles on this topic yet. When "Full-Scale Network Design" or "Intersection Blueprints" articles are created, insert 2+ internal links here. External reference: official Wiki (Circuit network) and community layout compilations. https://wiki.factorio.com/Circuit_network

Summary and Next Actions

The three rules—chain at entrance, normal at safe exit, chain for tight gaps—handle most designs solidly. Not the only way, but a rock-solid baseline. I started overthinking exceptions and got lost; fixing the baseline made bottleneck sources obvious. And when I've rebuilt intersections by these rules, clearing backlogs took minutes.

Checklist: Apply Entrance Chain / Exit Normal

• Chain signals before every entrance to splits, merges, junctions?
• Normal signals at exits only if safe stopping room exists past the junction?
• Tight exit or next junction nearby? Chain the exit onward too?

Start with One T-Junction → Crossroads → Tight Series

Rebuild one T-junction by the rules first. Confirm train behaviour, then expand to crossroads and tight areas. Learning one layout prevents network-wide mistakes.

Still Congested? Consider Single-Direction Dual Track

If gridlock persists despite correct signalling, upgrade to single-direction dual tracks. Network-wide simplification beats fine-tuning individual intersections. Entrances, splits, and merges all use the same pattern, and deadlock drops dramatically.