【Factorio】Chain signal placement: 3 core principles

The chain signal might look like it has a lot to remember, but the logic for placing it is actually pretty straightforward. If you're a beginner or intermediate player setting up intersections in Factorio 2.0 vanilla or Space Age, you can get most of the way there with just three principles: chain at entrances, regular signals only where trains can safely park, and chain again if exits are short or connect to another intersection. Stick to these and you'll avoid most problems.

I got stuck hard on my first T-junction—trains would jam inside the intersection constantly, and I had no idea why. Then I switched the entrance to a chain signal, made sure there was room for a full train length after the intersection, and suddenly everything flowed smoothly. It was like flipping a switch.

This guide walks through those three principles with real layout examples, so you can see exactly where to place what and why trains stop jamming up.

The 3 core principles of chain signal placement in Factorio

The bottom line: chain signals are for "before you enter an intersection," and regular signals are for "after you've cleared it, if you can safely stop there." Once that clicks, you'll spend way less time second-guessing your placements. After I internalized this split, I stopped overthinking T-junctions and crossroads entirely.

The official "Chain signal" guide (Factorio Wiki) is what I reference here, but pages get updated, so check the current content and URL before publishing: https://wiki.factorio.com/Rail_chain_signal/

Principle 1: Chain at entrances

Put a chain signal at the entrance to every split, merge, and intersection. This is the single most important rule of the three. The reason is dead simple: instead of letting trains think "I'll enter first and figure it out later," chain signals make them decide "can I clear the whole thing?" before they commit.

If you use a regular signal at the entrance, trains will move forward as soon as the next block looks empty. That means they'll stick their nose into the intersection, get stuck partway through a turn, and jam up everything behind them—and anything coming from another direction. Honestly, this is probably the first big mistake every new player makes. I spent ages staring at "I have signals but still gridlock," until I swapped the entrance to chain and watched the stopping inside intersections just... disappear.

Chain signals look ahead to the next signal condition and decide whether to enter based on whether the full path is clear. If the exit is blocked, they make the train wait outside the intersection instead of inside it. It's a signal whose whole job is "don't use the intersection as a waiting room." The same logic applies to splits and merges: whenever routes can collide, always look ahead before entering.

If you can split up the inside of an intersection with multiple signals, chain them together through the interior too. That's the standard move. It lets you separate non-crossing routes and handle congestion way more smoothly, especially on dual lines crossing perpendicular, or intersections with mixed turns.

Principle 2: Regular signals only where trains can safely stop

Use a regular signal only where it's true that "if a train stops here, it won't block the whole network." In other words, regular signals define where trains are allowed to wait.

A textbook example: the intersection clears into a nice long straightaway, long enough that a train can pull in fully without its tail hanging back into the intersection. Put a regular signal there, and the train will clear the intersection completely before it stops. That's why people say "exit is regular"—but the precise version is "exit is regular if there's enough clear space beyond it."

Flip that around: put a regular signal somewhere trains shouldn't stop, and that signal becomes their official waiting point. Now their rear end is still hanging over the intersection, blocking whatever comes next. Deadlocks often come down to "I put a regular signal where trains were supposed to be forbidden from stopping." The more trains you run, the more this design choice directly controls your throughput.

This rule gets a lot more teeth once traffic picks up. Throwing down one more train changes waiting patterns completely.

Principle 3: Chain signals again for short exits and consecutive intersections

"Exits are regular" is baseline, but it's not always the whole story. If the space after an intersection is really short, or if another intersection/signal is right on top of it, chain the exit too.

Here's what goes wrong: you put a regular signal on the exit, so the train thinks it's cleared the intersection. But the space is actually too short for the full train length, so part of it is still hanging back into the previous intersection. It looks cleared but isn't—and that becomes the chokepoint.

Consecutive T-junctions or a crossroad immediately before a merge? This is exactly where that problem shows up. I've built plenty of station approaches by squishing them down, and I've watched trains stop in the worst spots because the exit signal was regular in a space that was way too tight. When you chain the exit too, you're basically saying "don't enter this first intersection unless the path all the way through to the next safe stop is clear."

So chain signals belong in two situations: when the outside world can't fit a full train in the exit block, or when there's another decision point right ahead. The first prevents trains poking out of intersections; the second keeps multi-intersection scenarios under control together.

Community practice treats "exceptions to the exit-is-regular rule" as pretty standard—cutting it based on layout makes way more sense than rote memorization. Chain the entrance, chain the middle if you're dividing it, and only flip to regular when you've got genuine safe waiting space. Build that way and even big rail networks stay stable.

Background: Regular signals vs. chain signals

The core idea: blocks, reservations, and lookahead

Getting this straight makes the whole "when to use which" thing fall into place. I'm talking about vanilla Factorio 2.0 (and Space Age works the same way). Early on I was operating on "red = stop, green = go," but that misses the whole point about reservations—the idea that a train books a path in advance.

Train signals divide track into blocks (sections between signals, or around branches and crossings). A train in a block basically owns it; normally another train can't enter while the first is there. Reservation means a train's claiming the path it's about to take. At first I thought intersection jams were just about "is the next bit clear," but really the bug was that I wasn't thinking about path reservation at all.

A regular signal mainly checks "is the next single block open?" A chain signal checks "will this entire path stay clear from here all the way to the next signal?" The Factorio Wiki tutorials (especially the one on rail signals) make it clear that chain signals are for managing intersection entry, and it's the same logic throughout. Quick version: regular signals ask "can I enter the next block?"; chain signals ask "can I follow my whole path and exit cleanly?"

Space Age/ja

wiki.factorio.com

Logic difference: why exits matter

Regular signals are good at the mouth of a section where it's fine to wait—straight track, holding yards, that kind of thing. But they're terrible at intersection entrances because the decision horizon is too short. A train will creep in on the basis of the intersection's first block being free, then get stuck halfway through when the exit backs up. That's the root cause of "signals but still jammed."

Chain signals do the opposite—they're fussy about entry. They look past the next block, all the way to whether the path all the way to the next signal-controlled point is clear, and if not, they hold the line. That's your "don't use the intersection as a parking lot" signal. Once you see it that way, the "chain on entrance, regular on exit" pattern clicks into place: entrance manages go/no-go, exit marks where stopping is allowed.

Easy failure mode: entrance is regular, train's nose slides in, path to exit is blocked, train stops inside intersection. Now the next train can't use it, trains from another direction can't proceed, and you've got a cascade. I definitely did this, got very confused, and only figured it out when I swapped the entrance and watched trains behave differently—suddenly waiting outside instead of jamming inside.

Think of an intersection as a single bulk reservation: chain means "I'm booking entrance, middle, and exit as one package—all the way to a safe stopping point or not at all." That's why you don't get trains halfway through. On the flip side, if the exit is really short, slapping a regular signal there basically says "oh, this little scrap of track is a valid parking lot," and trains will use it—even though they're not really clear of the intersection. That's the trap with short exits: the signal creates a parking lot where there shouldn't be one.

Color codes (blue/yellow/red) and "holding at entrance"

The colors are easier to read if you think of them as results of reservation logic, not just state. Regular signals are pretty straightforward: green = go, red = stop. Chains add yellow/blue, which usually means "there's a path ahead, but conditions ahead might change—proceed with care." It's the chain signal being cautiously optimistic. Yellow at an intersection means the train is being allowed to proceed while staying aware of upcoming conditions.

What matters more for intersection design is the idea of holding trains at the entrance instead of inside. Don't park them in the middle—make them wait before they enter. That one idea transforms stability. The simple picture:

Regular signal at entrance
→ Next block of intersection is empty, so enter
→ But exit is jammed, so stop inside

   [regular]
----R------X****intersection****X---[clogged]
             ↑
           stops here (bad)

Chain signal at entrance
→ Check all the way through before entering
→ If exit is blocked, wait outside

   [chain]
----C------X****intersection****X---[clogged]
      ↑
   waits here (good)

The "wait outside" rule paired with bulk reservation is what makes stable intersections. The inside is for passing through, not waiting. Once you lock that in, a shared network gets way fewer accidents. Sounds boring but it's transformative—a lot of "why is my 'correct' intersection still slow?" comes from ignoring this.

For signal basics, the official Factorio Wiki tutorials are solid, and community resources like "Getting Started With Factorio Railways (Chain Signals)" or the factorio.jp Wiki have concrete examples that really make the logic stick. The moment you start seeing an intersection not as a single passage but as "a place you enter when conditions line up, not before," regular vs. chain signals just naturally sort themselves.

Principle 1: Chain signals at the entrance to splits, merges, and intersections

This is the hardest rule to mess up. Put a chain signal where anything enters a split, merge, or crossing. Lock that in and you'll stop second-guessing yourself constantly. The reason: chain signals enforce "the junction ahead doesn't even open unless the exit is genuinely clear," so the intersection itself never becomes a waiting room. That's your whole win.

At first I thought "if the signal in front is green, why not go?" But when you use regular signals at the entrance, trains don't look ahead—they just see the intersection mouth is open and charge in, then stop halfway through the turn. Now one train is stuck, everything behind it is stuck, trains from another direction can't move, and a single junction locks up the whole area. Or you swap that entrance to chain and suddenly the flow smooths out: the train sits outside in yellow, then the second the path clears, it shoots through in green. I've seen the before-and-after live, and the difference is very visible.

From the Factorio Wiki: chain signals manage entry based on the whole path ahead. At intersections, the logic is "book the full route, or don't enter." Get that, and placement stops being guesswork.

T-junctions: placement and the entrance principle

On a T-junction, this principle is really intuitive. You've got a main line straight through and a side branch cutting in, and you put chain signals on every entrance that could enter the intersection zone—main line approach, side branch approach. The goal is to kill off the possibility of a train getting far enough in to get stranded.

T-junction template

        side branch
         |
        [C]
         |
==**** intersection ****==
   [C]
main→

The way to think about it: "before your train enters the T-junction cell, decide if it can clear and exit safely." Chain signals let trains book the exit and beyond as part of one decision. If the far side is clogged, they wait outside. Regular signal? The intersection's first cell looks free, so in they go—but they can't finish the turn, and now the side branch can't proceed either.

Concrete bad example: main line comes in regular, side branch waits, intersection has a jam. Main train creeps in, can't complete the turn because the exit is blocked, stalls inside. Now the side line—which would ordinarily have the right-of-way if it arrived—can't go anywhere. Both the main and side routes lock up from one T-junction. I spent serious time on this exact failure, but flipping to chain at both entrances just eliminated "trains stuck in the middle" entirely.

Crossroads: why all entrances must be chain

The principle gets harder to ignore at a 4-way. A crossroad is where all four entrances interfere with each other, so put chain at every entrance. This is non-negotiable.

Crossroad template

        [C]
         |
==****intersection****==
[C]                 [C]
         |
        [C]

Why all? Because a crossroad isn't "if my own route is clear, I'm good." East-to-west traffic enters on a regular, stops inside because the exit is jammed, and now north-south traffic AND any turns are all clogged at once. One train with the wrong signal type claims multiple directions' capacity. And it cascades from there.

Chain at all four entrances reframes the whole thing: trains become things that either clear the full crossing or don't enter at all, not things that squeeze in hopefully. When you watch it happen in real time, they stack up neatly at each entrance and only proceed when their full path is clear. The regular-entrance version feels like trains are forcing their way in; the chain version feels like they're taking turns properly. And the difference in throughput is striking.

The Factorio Wiki's intersection tutorial uses chain signals in exactly this way for managing entry. Once you see a crossroad as a place where you must manage entrance permission tightly, it becomes the natural place to apply the principle.

Y-junctions: chain before split/merge points

Y-shapes look gentler, so it's easy to under-estimate them, but they're intersections too. Put chain before the branch point (split) or before the merge.

Y-split

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

Y-merge

input A ↘
         >[C]--- merged
input B ↗

The split-side chain makes sure: "don't enter the fork if the branch you want is blocked." Entry to a Y-split on regular is the same trap as the T: train enters the fork, can't complete the branch it needed, jams up and blocks the other branch from ever using it. Y-junctions might look less dramatic than 4-ways, but they're just as bad at jamming.

Merge works the same: merge point jammed? Regular signal lets the train squeeze its nose in anyway, it gets stuck blocking the opposite merge arm. This particularly hurts on main→side merges because the side's single stalled train slows down the whole main line. I've absolutely built this—the chain fix means that "just a little bit in and everyone loses" behavior just... stops.

The "Getting Started With Factorio Railways (Chain Signals)" guide mentions this same entrance-chain / exit-regular foundation with examples. A Y-junction is an intersection that just doesn't look like one. Chain at entry. Same rule, same result.

Principle 2: Regular signals only where trains can safely park

Train length and safe stopping space

"I can put regular at the exit" doesn't mean "put regular everywhere past the intersection." The rule is singular: the exit can be regular only if a full train—your longest train—can fit completely past the intersection without its tail poking back into the intersection.

The measurement is straightforward: from the front of the loco to the rear of the last car. Not the trains you usually run—the longest train in your network. If you run 2-4 everywhere but one supply train is 3-6, that 3-6 is your benchmark. The exit block needs enough length to hold the whole thing plus a bit of breathing room, or the signal's setting a trap.

Better to measure on your actual trains than guess. Park a train in a straight section and eyeball the tile length from front to rear; that number matters for intersection layouts. I've cut these margins too tight and paid for it. Even if the tail sticks out just a bit, that intersection is effectively blocked. Worst case: you think your exit is clear, run the network, and find out your longest train doesn't fit.

The community resources repeat the same note: exit regular is only good if sufficient exit space exists. Beginners memorize "entrance chain, exit regular" and stop thinking; **the true rule is "entrance chain, exit regular only if there's real safe stopping room."** Once you get that conditional, you can place a non-standard split without guessing.

Checklist: when is exit-regular valid?

Stuck on whether to use regular at an exit? Check one thing: does a train stopped here block the intersection?

Decision order:

1. Is there a waiting zone after the intersection exit?
2. Does your longest train fit in that zone completely?
3. With the tail safely inside the zone, nothing still touching the intersection?

All three: yes to regular. Any no: stay chain or add a link. Regular signals define where it's OK to park. Put one down, and you're saying "trains may stop here." If that "here" is actually halfway across an intersection, you've created a bomb.

This view is consistent across Wiki docs and community practice. Judge by whether the block is actually a safe waiting zone, not by whether it's called an "exit." A short exit is not a safe zone, no matter which direction it points.

Chain signal - Factorio Wiki

wiki.factorio.com

What happens at short exits and how to fix it

The worst failure mode is a train clearing the intersection visually but not mechanically, then stopping and jamming everything. Its tail is still over the intersection, so the next intersection downstream can't function—and the one before it can't either because this train is in the way. T-junctions hit this; crossroads get even worse.

I ran 2-4 trains and got bitten by this. I'd marked an exit as "regular because it's the exit," but the waiting block after was short. Trains would clear the intersection in appearance but leave their tails hanging. Stalled and creating chaos. Behind them jammed up; everything else jammed up; looked like the entrance signal was the problem. Nope—the exit space was too small. Switch that regular to chain, grow the waiting zone, and suddenly stable again.

The trap: a very short block marked with a regular signal. Trains use it as a waiting room and block the intersection anyway. The fix: make the exit a real safe zone or don't cut a regular signal there. Add a holding bay away from the intersection, or keep the exit chained and extend the lookahead to the next real safety point. Network processing is about entrance logic AND exit design in tandem. When one intersection flows fine in isolation but slow overall, bet the exit spacing is the culprit.

Principle 3: Chain again for consecutive intersections and short blocks

Consecutive intersections: when to chain the exit

This is where beginners get the most confused. When the exit of one intersection feeds right into another intersection or signal very close by, the simple rule "exits are regular" doesn't hold. You end up with trains that look cleared but actually aren't, and the whole area gets bottlenecked.

The logic: trains clear junction A, a regular signal marks "you've exited," but junction B is right there. The train gets as far as junction B's entrance and stops. Now it's not really clear of A—its rear is still tangled up in the space between them. Looks like progress but it's a chokepoint.

I built exactly this at a station approach where I tried to squeeze everything. Got a regular exit from the first junction, trains moved forward partway, hit the next intersection's constraints, and congestion spread backward. The network got slower, not faster. The exit is a short block, so occupying it blocks upstream. Swapping that exit to chain—"don't even enter the first junction unless you can clear past the second too"—flips the behavior. Now trains wait earlier, actually clear the second junction when they move, and nothing pools up in between.

The judgment call: is the exit block too short to be a safe waiting zone, or is the next decision point too close? If either is true, chain the exit. It's not about bottlenecking; it's about not creating false "cleared" states.

Now, one other piece that might seem off-topic: interior block subdivision. Post-2.0, breaking up the intersection insides can help—but it's something to read about in patch notes or the Wiki before applying. The idea: instead of one big reservation holding the whole intersection, you can divide non-crossing paths so they don't block each other.

Quick sketch:

No subdivision
[entrance chain] → [entire intersection, 1 block] → [exit]

Subdivided
[entrance chain] → [interior block A] → [interior block B] → [exit]
                    (if A and B don't overlap, B can move while A's in use)

This worked great for me on a busy corner: one direction had to wait before, but now non-crossing routes can flow in parallel. Not dramatic-looking but very effective. The rule: only subdivide if there are genuinely separate paths that can use the blocks without colliding. Overcomplicating doesn't help. Factorio.jp Wiki has configuration examples showing this in action; the principle is "separate what doesn't interfere," not "cut everything into slivers."

Proper design means **leaving space to place the interior chain signals in the first place.** Squish the layout to save tiles and you'll have nowhere to put those signals later. Think interior subdivision into your initial grid.

Non-crossing paths moving together: the point of interior chains

The reason to chain the interior is to let non-interfering traffic flow at the same time. This only works if you've built space to put signals and routed things so separate paths actually exist.

Here's the nuance: it's not just "add more signals." It's "place signals at the boundaries where non-crossing paths separate, so those paths can book independently." If everything still shares the same footprint in the end, extra signals just make the logic harder without gaining anything. That's why interior chains are really a technique for separating independent flow, not "micro-cutting the intersection."

Design process:

1. Figure out which pairs of paths actually don't cross.
2. After they diverge, mark that as a new block boundary.
3. Only that much gets subdivided.

This keeps the layout readable—other people looking at your intersection can see why the interior chain is there, not just wonder "why so many signals?" On multiplayer this matters tons. Un-obvious design breaks when the next person edits it.

For the concrete setup, the Factorio.jp Wiki (train network section) has layouts showing exactly where interior chains fit. Combined with reading how chain lookahead logic works from the official guides, it gets much clearer. You're not dividing for division's sake; you're separating reservation zones so independent flows don't wait on each other.

Real-world examples: T-junctions, crossroads, consecutive intersections

T-junctions: basic chain entrance / regular exit setup

A T-junction is almost a teaching tool for this stuff. You see entrance chain / exit regular working correctly in miniature. I stopped getting confused about chain signals the moment I set up a T correctly, watched the trains behave, and realized the signal was about **stopping the decision-making before entry**, not about entry itself.

Here's the common failure:

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

(regular signals at all positions)

Trains enter the junction because the immediate next block is free, get stuck mid-turn or mid-merge, and jam up. One or two stalled trains block all directions at a T because they've seized the middle. I've absolutely experienced this—"why are signals making this worse?"—and it's because I put regular where the lookahead needs to happen.

Fix: chain at entrances.

Better version
      C
      |
---- C+---- S
      |
      S

(chain signals at entrances, regular at exits)

Now before entering, trains check if they can actually complete the maneuver. T-junctions stabilize almost immediately. Trains stop outside, move through cleanly. The difference is visceral.

The exception: if that right-side exit blocks immediately into another intersection, a regular signal there becomes a trap too. Short output blocks are dangerous.

Bad: output leads right into another junction
      C
      |
---- C+---- S -- C+--
      |
      S

Short S-block stalls the train, which is still occupying the first junction.

Chain that exit to check further ahead:

Better: chaining the exit too
      C
      |
---- C+---- C -- C+-- S
      |
      S

Now trains don't enter the first T unless they can clear the second junction.

This is the exception that proves the principle: even though it's an "exit," it becomes a chain when downstream is tight.

Crossroads: interior chains for simultaneous non-crossing flow

A 4-way intersection has way more possible paths, so bottlenecks get worse. You can have all four entrances as chain (correct), but if the interior is one giant block, trains are safe but slow—non-crossing traffic still waits.

Problem case:

Bad: interior is one block
        C
        |
--------[   whole crossing   ]--------
        |
        C
     (exits are regular)

(Any train using it blocks non-crossing directions from using it simultaneously.)

One north→south train enters, and east→west traffic waits, even though they don't actually collide. This feels slow for no reason.

Solution: subdivide so non-crossing paths have separate reservations.

Better: interior split
          C
          |
------[A]---[B]------
          |
          C
     (exits regular)

[A] and [B] are separate blocks.

The mental model:

        North
        C
        |
West C-[A]-[B]- C East
        |
        C
        South

N↔S crosses E↔W.
But N→E doesn't cross S→W.
With interior blocks, non-crossing pairs can move simultaneously.

The real test: run the bad version and watch all traffic jam up when one train uses it. Run the better version and see non-crossing flows proceed in parallel. The difference is very real. And it's not about adding signals—it's about letting non-interfering paths book separately.

Design rule: subdivide where non-crossing paths naturally separate. If you can't separate them (too much overlap), adding interior signals won't help.

Consecutive intersections: exit must be chain if next junction is close

This setup is where "exit regular" breaks hardest. Two junctions spaced close.

Bad:

Bad: exit from first junction is too short
---- C + A + S ---- C + B + S ----

A's exit marked "regular," but it's short.
A train exits A, stops in the short zone, rear still on A.
B can't use its entrance freely because A's trains are tangled in the space.

The symptom: A seems clear, but traffic through B is slow. Really the issue is trains aren't actually clearing A; they're just moving partway and stopping, still occupying the space between.

Good:

Good: A's exit is also chained
---- C + A + C ---- C + B + S ----

Now trains don't exit A unless they can fully clear and proceed toward B's safe zone.
Trains actually vacate A before B encounters them.

And if you can subdivide the space between them:

Even better: subdivide the middle zone
---- C + A + [middle1] C [middle2] + B + S ----

Now independent paths can use [middle1] and [middle2] separately, rather than being lumped together.

For consecutive 3-way junctions or heavily stacked approach routes, chaining the exit (or even subdividing between junctions) is often what makes things stop feeling slow. It's not a minor tweak—it's the difference between "correct but sluggish" and "actually flows."

Common failures and fixes

Inside-intersection stalls: culprits are entrance-regular or short output

When trains stop inside an intersection, it's almost always one of two things: entrance was regular or output waiting zone is too short. Even if it looks like the tail barely sticks out, "barely" still blocks the whole crossing.

If entrance is regular: swap it to chain. Trains now check ahead before entering. The stalls stop.

If output is short: make sure your longest train fits with room to spare, or keep the signal chain (don't mark it regular), or use a bigger waiting area away from the intersection.

The combo of "entrance chain + good output space" is what kills interior stalls. Tune that and the rest usually follows.

Non-crossing traffic still jams: interior subdivision missing

Sometimes all your chain signals look right but the flow is sluggish anyway. Usually the interior is one big block.

Check: do non-crossing paths physically separate anywhere? If yes, put a chain signal where they diverge. This lets them book independently.

If not, the interior is genuinely shared and you can't subdivide. In that case, increasing interior chain density won't help; you need bigger intersections or simpler designs.

Two-way lines deadlock: one-way dual is the fix

Two-way single-track is convenient until trains start backing each other up. It's a deadlock minefield and super fragile as soon as a third station appears.

Real remedy: convert to one-way dual lines. Suddenly direction is fixed, signal logic is way simpler, and "trains meeting head-on and one has to back up" just stops happening. Designing intersections becomes obvious instead of puzzle-like.

If you must keep two-way, be strict about entrance chains and don't let trains get stuck mid-zone, but honestly it's not worth the complexity once you have more than a handful of stations.

Exit block too short: longest-train space rule

Short exit blocks are subtle killers. Trains look like they've left the intersection but haven't. Just a couple tiles short is enough to cause problems.

Rule: **the exit block must hold your longest train plus clearance.** Measure it before placing the signal. If you can't make it that long, don't use a regular signal there; chain it and let it extend the lookahead, or expand the waiting zone elsewhere.

This is especially brutal at station approaches or consecutive junctions where every tile feels precious. But that one short block is where the whole network can seize up.

Advanced: interior block splitting and where to go next

How interior block subdivision works

Post-2.0, dividing an intersection's interior to let non-crossing paths move independently is really practical. Before, if a T or crossing was slow despite all looking correct, the interior was usually one big block, so traffic was unnecessarily synchronized. Splitting fixes it.

The