Factorio train signals basics | Normal/Chain and blocks

In Factorio, railway signals work differently: a normal signal only checks the next block ahead, while a chain signal looks further down the track to prevent trains stopping inside intersections. Once you grasp this distinction, intersections, junctions, and single-track layouts all follow a simple formula: chain at entrance, normal at exit. I myself got stuck at a four-way intersection for three hours, hitting dead ends, trains blocking inside intersections, and single-track standoffs one after another—but separating the signal roles and repositioning them fixed everything. This guide is aimed at anyone in Factorio who wants to diagnose why bottlenecks happen, and walks through basic rules and intersection design with practical examples.

Target version and prerequisites

Target version note

This article is primarily written for vanilla Factorio 2.0. If you're using Space Age (an expansion available as DLC or through community large-scale mods), check compatibility on a case-by-case basis. The signal fundamentals—dividing track into blocks where only one train per block is allowed—remain shared with version 1.x; this guide mainly follows 2.0 interface and workflow conventions.

Assumed skill level

The target audience is someone who's completed the tutorial and understands basic train scheduling. You've placed stations, set train stops, and got them running. If you're at that stage, you're ready. Conversely, if you haven't moved a train yet, you may struggle with station naming and schedule mechanics before you get to signals, making the intent harder to grasp.

Just as important: you know the length of your longest train composition. Intersections and passing sidings jam up far more often because "the train wasn't fully clear before the next signal" than because of signal type mistakes. I always check the longest composition before touching someone else's rail in multiplayer. This detail seems minor, but it matters enormously in practice.

The following sections build understanding step by step rather than assuming you already know the difference between normal and chain signals. However, we skip over train UI basics, station naming, and schedule mechanics themselves.

Topics not covered here

This section focuses on correct signal reading in vanilla, and baseline design to avoid breaking intersections, junctions, and single-track. Broader topics become separate themes and are omitted.

Specifically, integrating the circuit network with train control is out of scope. Station enabling, reading signals, dynamic control via circuit conditions—it's fascinating, but getting signals to safely flow trains comes first. Wrapping problems that chain signals should solve in circuit logic makes root cause analysis harder.

Detailed stacker design is also a separate topic. Stackers are like the capstone of signal understanding, tying together entrance jams, per-lane storage length, and exit merging. Here, we cover only the foundation: "how to cut blocks" and "keeping trains out of intersections."

UPS optimization isn't addressed. Whether to partition intersections finely, when to use single vs. double-track, how many stations to parallel—those ultimately tie to UPS concerns, but that's a large-factory perspective distinct from learning signal mechanics. Focusing first on preventing jams and deadlocks keeps design decisions on track.

Signals: only two types matter | Normal vs. chain signal

Normal train signal role

A normal train signal is quite simple: it looks only at the next block. If the block ahead is free, the train proceeds; if occupied, it stops. This understanding is sufficient to start.

Factorio's signals divide track into blocks, enforcing the rule that only one train per block at a time to prevent collisions. The normal signal is the basic building block for this division, making it ideal for straightaways and exit sides after intersections. Placing it as the traffic-release point after an intersection keeps behavior intuitive.

Signal colors map cleanly: green means proceed, yellow means the next block is reserved or soon turning red, red means no passage. Yellow looks like a "caution" cue, but it often appears when trains can't physically stop in time. On high-speed main lines, I've seen yellow proliferate when signal spacing is too tight, causing constant braking and re-acceleration. The ideal isn't to pack normal signals as densely as possible.

The flip side: placing a normal signal at an intersection entrance easily causes "the next block is clear so I enter, but then I stop inside because the exit is jammed"—a classic beginner jam. The signal isn't wrong; it's just the wrong tool. Normal signals excel at releasing cleared trains, not at preventing intersection blocking. Splitting by purpose makes this stick.

Chain signal (linked) role

With Factorio 2.0 and beyond, community practice increasingly shows that dividing intersection insides with chain signals in detail works fine in many scenarios. I use this heavily in 2.0—partitioning four-way intersections by path—and the "this setup is ruined by over-partitioning" feeling is weaker than before. Parallel multi-directional flow often works better with internal division.

However, this isn't a silver bullet. Under special conditions or high-density traffic, insufficient exit parking alone will cause jams. Chain-divided interior doesn't matter if the train doesn't fully clear the exit into waiting space; it will stop mid-tail in the intersection and deadlock from there. In short, 2.0 doesn't excuse sloppy internal chain division; rather, the "don't stop in intersections" principle becomes easier to apply effectively.

Looking at the "Zero to Hero Factorio Railway (Chain Signal Edition)" example of insufficient exit length clarifies this well. When I debug jam, I ask "once this train fully exits, is there space for it to sit?" before worrying about signal type. Frankly, that decides most problems.

One-liner distinction and right-hand rule

My clearest phrasing: "Normal signal sees only the next block; chain signal sees the path beyond and makes trains wait before entering." In one sentence, that splits them.

In practice, don't stop inside → chain at entrance; clear the exit → normal after cuts accidents sharply. Remembering by name alone confuses; remembering by "where do trains wait" is instant clarity. I initially flipped them reading names, but once I thought in terms of parking, the confusion vanished.

Easy to miss: the right-hand rule. Trains read only signals on the right as they face forward. Miss this and signals exist visually but don't apply to that direction—it becomes one-way. The official "Tutorial: Train signals" page lists this as foundational, and it truly is.

This rule is deceptively critical. My worst "no route found" incident traced back to placing signals on only one side. Double-track that looks right can fail if signals face only one direction; the reverse direction sees no readable signals. Adding the corresponding side signal on the other track often solves route-finding on the spot.

So the section takeaway is simple: Normal looks ahead one block; chain looks further; trains read the right side. Once these three ideas stick, "why did the train stop?" becomes diagnosable in any layout.

Tutorial:Train signals

wiki.factorio.com

Block (closure) mechanics: one block, one train

Signals create blocks

Factorio signals aren't just "go/stop" signs. They're boundary lines dividing track into blocks (closures). The span between signals—or one signal-delimited section—is one block, and only one train per block, always. Grasping this explains "why is the train waiting ahead?" or "the route looks clear but nothing moves?"

This mechanism is covered as foundational in the official "Tutorial: Train signals" page. Signals don't steer trains directly; they manage track occupancy on a per-block basis. Intersections, single-track, or station approach—collisions don't happen because of this rule.

I stumbled here initially. I thought more signals meant faster flow, but how you cut blocks matters far more. Long blocks let one train hog a wide section, jamming followers. Smart block-cutting at intersection entries, exits, and station approaches lets trains creep forward incrementally, easing congestion noticeably.

That said, fine-cutting everywhere isn't the answer. Exit-side waiting blocks especially must be long enough for the whole composition to fit. Too short, and the tail stays in the intersection, blocking the junction. I once over-partitioned exits for congestion relief and made it worse. Partitioning helps, but the block must function as actual waiting room.

Signal colors (red, yellow, green) and reservation behavior

A normal train signal basically checks if the next block is empty. Empty → green, occupied → red, and yellow in between. This color change isn't just display; it ties directly to train entry reservations.

Visually, even an empty block turning yellow means the next train to use it is already claimed and reserves it. Normal signals show green when the next block is free, shift to yellow as reservation nears, and red when the train is almost there—this flow clarifies how it works. You've seen yellow appear when no train is there yet; that's the reservation logic running ahead.

Yellow matters especially at high speed. Trains can't stop on a dime, so entering red-turning-to-red mid-yellow stops the train anyway; it coasts through. Ideal single-locomotive stopping distance, calculated from speed and acceleration stats, can reach several hundred tiles—potentially about 280 tiles. So cramming normal signals densely on a long main line produces lots of yellow-crawling, not free flow. This is normal operation, not broken signals.

Chain signals extend this judgment further. Instead of checking only the next block, they **look through to the exit signal of the chosen path, turning red or yellow if anything downstream blocks**. So a chain at an intersection entrance prevents "I can enter but can't exit" jams at the door. Normal signals ask "can I enter?"; chain asks "will I fully clear?"

Right-side signals and "no route found" diagnosis

"No route found" when track is connected is a common post-signal-tutorial jam. A classic cause: signals are only on the left, not the right. Trains read only right-side signals, so a visual signal can be invisible if facing wrong or left-only, turning the path into one-way.

So you think "I built a bidirectional single-track," but in-game it's one direction with signals, one without. Single-track amplifies this; a signal direction mistake breaks bidirectional intent instantly. I messed this up building single-track bypass lines—signals on one side meant the return couldn't find its station. A small oversight, huge visual invisibility.

Another common jam: one-way design mixed partway through. Your double-track main uses one direction per track, but the station or junction tries to be bidirectional; if signal alignment breaks, the route is legally null even if physically connected.

Even with correct signal directions, blocks physically blocking stations and tracks—especially short exit-side blocks that can't fit full compositions—lock trains behind, filling whole blocks and leaving downstream with "no legal route" situations. This is a design fault, not a signal one.

Debugging "signals look right but trains are dumb": actually check block-cutting, signal-side placement, and exit length. I usually solve most issues just looking at those three. Root cause sits in "which blocks does the train reserve, and where can it fully stop?" more than signal type.

Baseline: intersections follow | chain entrance, normal exit

Why chain signals at intersection entrances

The fixed form for intersections: chain signals inside and at entrance, normal at exit. This works for T-junctions and four-ways. Role-wise: chain keeps trains out of the intersection by making them wait at the entrance, and normal releases exiting trains cleanly to the next block.

Chain at the entrance suits intersection design because it checks not just if the next section is free but whether the path clears fully. If the exit is jammed, the entrance turns red and the train waits outside. Normal signals let trains assume "next block open" and enter easily, stopping inside the intersection and blocking other routes. That was my first four-way disaster.

The official "Tutorial: Train signals" lists this as the base pattern: chain at entrance, normal at exit. It's not advanced—just stricter entry judgment, straightforward exit release. This is the ironclad rule to memorize.

Partitioning intersections and caveats

Intersection insides also typically use chain signals, since dividing by path lets multiple trains move in parallel if routes don't conflict. A four-way has right-turn, straight, left-turn paths that don't fully overlap, so one big block stops trains that could coexist; interior chain-cuts let each flow.

Procedurally, locking the exit first makes entrance/interior placement natural:

1. Place normal signal past the intersection exit
2. Leave waiting space up to that normal signal (enough for a train)
3. Place chain signal just before intersection entrance
4. Optionally partition the interior with chain signals per path
5. Run multiple trains and check for interior stops

Interior chain-partitioning helps under congestion, but more partitions ≠ guaranteed correctness. Blocks must be places trains can actually wait, so tiny interior slivers don't help. Stuck intersections often suffer exit-space starvation more than interior division issues; I've seen "I added more interior signals" fail while "I extended the exit" solved it.

Community wiki examples ("Train Network / Layouts") balance "entrance chain, exit normal" with "partition interior per path conflict." Design's physical space—where trains park, what routes stay clear—matters more than signal density.

Train Network / Layouts - factorio@jp Wiki*

factorio@jp Wiki*

wikiwiki.jp

Exit normal signals + guaranteed waiting space

Placing normal at the exit releases exiting trains to the next block straightforwardly. Once clear of the intersection, "can I enter the next closure?" replaces "don't block interior," so normal fits the role. Entry chain + exit normal is a matched pair.

The real critical part: the exit block must fit your longest composition in its entirety. If only the head reaches exit-block space and the tail hangs in the intersection, it blocks the crossing. Visually clean but functionally broken; you'll see "chain signals but still jammed."

I added longest-composition-length plus a few-tile margin to exit blocks and saw backups shrink noticeably. It's an unglamorous fix with huge payoff. One block can hold one train, so undersized exits mean undersized throughput, period.

This applies equally to T-junctions and four-ways. Place the exit normal first, confirm there's train-length waiting space behind it, then position entrance and interior signals. Sizing the intersection around exit capacity—not the reverse—prevents structural jam.

Single-track, junctions, and double-track intersections

Bidirectional single-track

Single-track halves rail cost, hugely appealing in early game or far outposts. The appeal is real, and I love the railway aesthetic.

Operationally, it's far harder. Single-track runs both directions on one rail, so passing coordination becomes the whole game. One block = one train, so no-passing single-track forces "one direction at a time until clear," tanking throughput. For beginners, it's genuinely low-friendly.

Key unlock: passing sidings—brief two-track sections in the middle. community layouts use these heavily; adding one passing section boosts usable trains by 1–2 compositions compared to single-track alone. It's lighter than full double-track and the payoff is obvious. I once tied a single-track feeder to the main without a siding and hit standoff before the merge; adding ~50 tiles of passing track upstream halved the main-line backup.

The lesson: don't make trains wait at junctions or main approaches on single-track. Jams come from "trains wait in the wrong place" far more than signal type; proper passing sections are prerequisites. jias.jp single-track guides and factorio@jp wiki examples both hinge on siding location and length. It works, but under strict conditions. Romance vs. difficulty: single-track splits them starkly.

Signals at junctions

Junctions look simple but signal placement errors jam them hard. Logic mirrors intersections: chain right before the split, normal at each branch exit.

Why: chain checks not just "is the next block clear?" but "is my chosen path open all the way to the exit?" So if the right branch is full, rightbound trains wait at the split. Normal signals let "I can enter the split" thinking, so trains push in even if the branch clogs, tying up the split. I've done this on T-feeder junctions—one branch backs up and suddenly the main line is blocked too. Junctions are smaller than intersections, so negligence bites faster.

Clean rule: entrance chain (holds waiting position upstream), branch exits normal (straightforward release). Simpler than trying to logic out when trains should split; "wait upstream" is automatic.

One-way double-track intersections

Operationally, one-way double-track is the most stable. Splitting directions across tracks and using right-hand rule keeps signal directionality sane and paths intuitive. Design clarity is high, throughput scalable, so beginners find this the natural starting point.

On this layout, the entrance chain, exit normal principle shines directly. Partition by path with chain on each approach, stack normal exits, cut interiors as needed. Right/straight/left flows are easier to keep clear, and right-hand separation prevents headons. Double-track costs more rail but buys cleaner design and team-friendliness. In multiplayer, this clarity pays dividends. I default to one-way double for major networks.

High-speed sections hit stopping-distance hard: ideal single-locomotive stopping distances, based on speed and acceleration values, can mathematically reach hundreds of tiles—roughly 280 as an example. This is purely calculated. Real runs vary with train weight, multiple engines, and tech levels, so short blocks don't universally solve high-speed jams.

Common failures and diagnostic flow

Symptom: "no route found" diagnostics

Train gets "no route found" despite connected track traces back to signal reading not working, not track. The causes concentrate on a few spots I always check.

First: is there a right-side signal? Trains read right-side signals only. Left-only, reversed direction, or wrong sides = that path is invisible even if track exists. Symmetrical intersection or two-way single-track with one-side signals becomes unidirectional without looking it. I mixed up signal direction on opposite sides of two-track and got a "one-way only" result. Visually invisible.

Dual-direction single-track without paired signals (one facing each way) silently becomes one-way. Missing even one signal-pair in the set breaks bidirectional intent. Double-track touching before pairing signals can hit this; just adding one missing side often fixes route-finding instantly.

Station also matters. Disabled stations or name mismatches mean trains never find the goal, appearing as signal trouble. Duplicated stations with slight name differences, or circuit-disabled and forgotten, mirror signal bugs. I wasted 30 minutes re-signaling before realizing it was a typo. Demoralizing.

Diagnostic order: right-side signal presence and direction, then dual-direction signal pairing on single-track, then station state and naming. Official wiki puts right-hand and block mechanics as foundational; route-finding failure points back to "how does a train read this path?" fundamentally.

Symptom: trains stopping inside intersections

The trickiest intersection jam: train enters then stops mid-intersection. Looking at signal colors alone confuses; root causes narrow down.

Most common: exit block too short—train head exits but tail stays in intersection. Call it "tail hanging in the intersection"; it blocks crossing paths and cascades. I hit this with longer compositions, didn't extend the exit, and froze a four-way. Visually slight overhang; operationally fatal. jias.jp has explicit examples.

Next: exit-side already congested. Intersection should chain-signal the entrance to red if exit is jammed, but normal signals at the entrance let "next block is free" thinking, forcing entry then mid-intersection stop. Intersection looks bad when upstream jams are the real culprit. I see this all the time.

Check if the stopped train has waiting space past its stop position. No space = structural jam. Cut off mid-intersection instead of hand-waving signals, extend the exit or clear the exit-side backup. Intersection often isn't the problem; the outside is.

Visually, where does it stop—in the intersection or just before? Interior stop = signal type wrong, exit too short, or exit-side jammed. Pre-intersection wait = chain's working. Stuck intersections often trace outside, not in; I prioritize exit space over signal tweaking.

Symptom: single-track standoffs

Single-track two-train face-off isn't just one jam; it deadlocks the whole network, pinning followers. The causes split clearly.

First suspect: passing siding shortage. Insufficient wait-space single-track jams instantly. Adding one siding boosts capacity 1–2 trains; if you have sidings, placement and position matter—trains must reach them naturally or deadlock at the junction instead. Placing a siding mid-line helps; placing it so trains can't reach it before meeting head-on doesn't.

Next: single-track entrance without chain signals. This pushes trains into single-track without checking if the path is clear downstream, letting them pile in and stop mid-track. Single-track needs interior-checking worse than intersections; normal signals don't fit. Entrance chain + siding placement is the setup.

Standoff patterns tell you: meeting just before the passing siding, every time? Entrance and siding positions need rework—simultaneous entry to the single section happens. Standoff even with sidings? Siding too short or configured wrong; trains don't fit.

Single-track trouble usually isn't signal logic; it's track design and passing-place positioning. jias.jp and factorio@jp wiki examples both lean on siding setup as the core. Signals clarify, but design decides.

Deadlock release and re-prevention steps

When jammed, I cut analysis before full rebuild. My usual 4-stage flow:

1. Check right-side signals exist and face right

Route-finding and one-way symptoms often resolve here. Intersection opposite-sides and single-track returns hide direction mismatches.

1. Check exit block length and downstream jams

Interior-stopping usually stems from short exits or exit-side congestion. Intersections rarely self-cure; upstream clears them.

1. Verify intersection entrance is chain

Normal at the entrance forces mid-intersection stops. Quick win if the entrance signal is wrong type.

1. For single-track, verify siding count and placement

Standoffs = siding shortage, poor placement, or entrance forcing internal parking. Check one by one.

Active deadlock: temporarily clear one block. Move one train out by hand, or toggle a signal briefly to let a train pass. Unstick the core train first; cascading release often follows. Touching many trains re-jams elsewhere.

Then: fix root cause and re-signal. Direction error → fix direction. Single-track signal-pair missing → add it. Intersection interior stops → extend exit or unclog exit-side. Siding issues → relocate. This order means "actually fixed," not "randomly working."

After un-jamming, verify outside conditions and re-place signals correctly. It's the practical path from "stuck forever" to "stable for real."

Official wiki's signal tutorial is strong on right-hand rules and block basics; jias.jp is excellent on exit-length jams. Diagnosing symptoms one layer at a time makes signals click. I went from "all red looks the same" to "this jam has a clear fix" once I tracked "where do trains actually sit?" It's the right mental shift.

Factorio 2.0 and beyond: what's new

Partitioning intersections with chains: is it okay?

Factorio 2.0 onward, I've felt dividing intersections deeply with chain signals works fine in many cases. Complex four-ways or merge-splits inside partitioned by path, and earlier hesitation ("will this break?") is gone. Community consensus increasingly leans very-special cases aside, generally stable.

Crucial distinction: "okay to partition interiors" ≠ "unbreakable no matter what." Chain signals see downstream signal states, not just next-block status, so path-based interior division fits naturally. The "don't stop inside" principle becomes easier to apply fully, which 2.0 surfaces more intuitively than before.

Key: official 2.0 patch notes and wiki show bug fixes and UI tweaks, not fundamental signal rule rewrites. I found no official "signal mechanics changed in 2.0." So treat this as 2.0 operational stability and community experience, not a core-rule shift.

Practically, interior chain-partitioning often beats one big block; flow eases when "trains that can move do." Especially on one-way double main-line intersections, internal partition lets pass-through trains overtake slower turns, which feels more natural. Underrated small win.

Edge cases and congestion warnings

But deadlock root causes haven't vanished. 2.0 jams just as hard if misdesigned. Exit parking and block-length stay the culprits.

I hit this myself: 2.0 fine interior chains kept the intersection tame, but exit-side stacker was too small, backing up the whole section past the intersection anyway. Looked like "intersection signals broken" but was exit-side capacity—simple as that. Smart intersection plus narrow exit = everything stops. Entrance brilliance can't fix downstream starvation.

High-density multi-directional streams require care. Partitioned chains let non-competing paths run parallel, but if multiple directions back up toward exits, interior micro-blocks become parking-space amalgams. Logically sound, operationally stuck.

Also: stopping distance from high-speed approaches stretches further than intuition suggests. Calculated ideal stopping for single locomotive can exceed several hundred tiles—conceptually near 280 tiles in rough terms. This is math-based. Real trains vary by composition weight, multiple engines, and research, so short-block reflexes don't universally cure speed issues.

Version checks and practical testing

Track 2.0 info via official wiki (train signals page) + English-language patch notes together. Wiki covers core mechanics; patch notes show what got fixed that release. Signal-related fixes appear in 2.0, but no public major rule overhaul is documented. Real design leans on community context and hands-on testing.

Factorio@jp wiki layout examples and 2.0 supplements are really helpful. Especially, "partition interior by path conflict" beats fear of one-block interiors. I test new intersections by building, loading trains, and watching gridlock emerge (or not) rather than pure theory.

Load test focus: congestion-time behavior. Light load hides design flaws. Heavy load exposes them: exit-space starvation, stacker limits, post-merge backs all emerge. Interior chain-partitioned designs show true colors here. Stable designs get slower under load; fragile designs freeze.

Practically, right design is determined less by "light load works" than "heavy load breaks gradually, not catastrophically." 2.0 vibe favors interior chain partitioning, but don't relax on exit-side. Real-world testing beats assumption. See whether the layout genuinely flows or just happens to have space right now by overloading it. Design clarity at 10+ trains beats "somehow works" at 2.

Next topics to explore (links to be created)

Start small: build on a basic T or four-way first. Explore these in sequence, then test real-world:

• Station design and stacker construction (waiting lanes, capacity math)
• Chain signal patterns (entrance vs. interior vs. exit roles)

Official Factorio wiki (Train signals, Train network, Station design) and community layouts have detailed visuals and blueprint examples. As matching articles are added here, internal links will be filled in. Prioritize test small first and verify full trains fit in exits. That's the real foundation.