Factorio Train Signals Explained | Standard and Chain Signals with Block Basics

In Factorio, the railway signal system relies on a surprisingly simple rule: standard signals check only the next block, while chain signals look further ahead to prevent trains stopping inside intersections. Once you grasp this difference, intersection design, junctions, and single-track layouts all fall into one clear pattern: chain signal at entrance, standard signal at exit. I spent roughly 3 hours stuck on a single crossroads, hitting route-not-found errors, trains stopping mid-intersection, and deadlocked single-track standoffs—but once I separated each signal's role and repositioned them, everything resolved immediately. This guide is written for players who want to diagnose why gridlock happens rather than just place signals randomly. It covers the core rules and intersection design approaches using practical examples, with an eye toward Factorio 2.0 and beyond.

Target Version and Prerequisites

Specifying the Target Version

This article is written primarily for vanilla Factorio 2.0. If you're using Space Age (the expansion DLC or large community mods), check their compatibility separately. The fundamental signal principle—dividing track into blocks, with one train per block maximum—is shared with version 1.x. I focus mainly on 2.0 UI and operational feel in the explanations below.

Assumed Skill Level

I assume you've completed the tutorial and understand train schedules at a basic level. You've placed stations, set train destinations, and run trains at least once. That's enough to follow this guide. If you haven't run a train yet, you'll likely get stuck on station naming and schedule behavior before signals become clear.

Another critical detail: know the length of your longest train composition. Most intersection gridlock and siding deadlocks stem not from signal type mistakes, but from "the train's tail still occupies track even after the head passes." Before touching multi-player routes, I always check the longest train first. It's tedious, but it prevents one misplaced tail from cascading into accidents.

Throughout this article, I don't assume you already understand standard vs. chain signals—I fill in that gap with examples. However, I skip basic train UI operations, station naming, and schedule syntax.

Topics This Article Doesn't Cover

This section stays focused on correct signal placement and block cutting for intersections, junctions, and single-track in vanilla mode. Broader topics are excluded to keep the scope clear.

Specifically, I don't cover circuit network integration with trains. Station enables, reading signals, and circuit-based dynamic control are interesting, but the priority is safe flow using signals alone. Circuit logic wrapping a signal problem just makes diagnosis harder.

Station stacker design is out of scope too. Stackers represent signal mastery—you must weigh entrance congestion, per-lane wait length, and exit merging as one system. I focus only on the foundation: "how to cut blocks" and "prevent mid-intersection stops."

I skip UPS optimization as well. Trade-offs between fine-grained vs. wide intersections, single vs. dual-track strategy, and station count directly affect game performance. That's a large-factory concern, separate from understanding signal mechanics. Focus first on preventing gridlock and deadlock; clear thinking comes from that.

Factorio Signals: Just Two Types—Standard vs. Chain Signal

Standard Train Signal Behavior

The standard train signal is remarkably simple: it checks only the next block. If the next block is empty, proceed. If it's occupied, stop. That's the core logic.

Factorio's signals divide track into blocks, ensuring only one train per block at a time to prevent collisions. Standard signals mark those boundaries—perfect for straight sections and exits after intersections. Placing them at the exit side keeps behavior predictable: once the train clears the intersection, it flows naturally.

Signal colors are also neat here: green means go, yellow means the next block is reserved or about to turn red, red means don't enter. Yellow often looks like a caution light, but it also appears when the train can't brake in time before the next signal. On high-speed trunk lines, if you cram signals too close, yellow becomes constant, triggering endless brake-accelerate cycles. Even with a single locomotive, theoretical braking distance can stretch hundreds of tiles—tight spacing doesn't always help.

The classic mistake: placing standard signals at intersection entrances leads to trains entering because the immediate next block is empty, then stopping mid-intersection when the path ahead fills up. This is the textbook rookie error. Standard signals aren't bad—they just have the wrong job. They're great at exiting traffic, poor at preventing mid-intersection stops. Separate the roles in your mind and confusion melts away.

Chain Train Signal Behavior

In Factorio 2.0 onwards, communities often report that fine-grained chain signal subdivision inside intersections works smoothly. I've used 2.0 extensively, splitting ten-way intersections into path-specific internal sections with chain signals, and the "this will break" feeling is much weaker than before. In fact, directional throughput often improves with internal subdivision.

But—it's not foolproof. Unusual geometry or heavy traffic can still jam everything. Dense train pileups, insufficient exit space, and miscalculated lane lengths remain dangerous even if you chain-divide the interior into perfect fragments. The point isn't that 2.0 makes bad design irrelevant; rather, the "don't stop mid-intersection" principle became more naturally applied—and more importantly, more effective when applied correctly.

A good reference is the exit-space-shortage example in "Zero to Factorio: Railway Building (Chain Signals)" (link to jias.jp below). Honestly, I diagnose gridlock by asking "does the exiting train actually fit in the space after the intersection?" before I fuss with signal type. Usually, that question decides it.

Quick Differentiation and Right-Hand Rule

My clearest one-liner: standard checks only the next block; chain checks further to hold trains before entrance. Cut it even shorter: "decide where to stop—that determines which signal."

Practically, "mid-intersection stop → chain at entrance; post-intersection flow → standard at exit" cuts accidents sharply. Names are easy to mix up; stopping locations are memorable. I once placed them backwards routinely until I thought in terms of where trains wait instead of memorizing names.

Easy to miss: trains read signals on their right side only. Directionally, left-side signals are invisible. Place signals only on one side of dual track, and you accidentally create one-way routes. I once spent serious time on "path not found," only to find I'd signal only one direction.

So the takeaway is simple: Standard sees next block only. Chain sees further. Trains read the right side. Lock these three facts in, and you can explain "why is it stopped?" for any scenario.

Tutorial:Train signals/ja

wiki.factorio.com

Understanding Blocks: One Block, One Train

Signals Define Blocks

Factorio signals don't just say "go" or "stop"—they partition track into blocks (sections), and only one train per block is allowed. Grasping this transforms "why is my train stopped in clear track?" into a solvable puzzle.

This rule is fundamental in the official Factorio Wiki's signal tutorial. Signals manage track occupancy by block, not by steering individual trains. Whether at an intersection, single-track, or station approach, trains don't collide because of this rule.

I stumbled here initially. I thought more signals = faster flow. Wrong. How you partition into blocks matters far more. Oversized blocks make single trains hog wide sections, choking following traffic. Clever subdivision—at intersection entrance/exit and station approach—lets trains inch forward, smoothing congestion noticeably.

That said, fine slicing isn't free. Exit-side blocks especially need length for the longest train to sit completely after clearing. A short exit block means the head exits but the tail stays in the intersection, blocking cross routes. I once over-subdivided exit blocks to reduce congestion, actually worsening it.

Signal Colors and Block Reservation

Standard train signals basically check whether the next block is free. Empty = green, occupied = red, in-between = yellow. These colors link tightly to train reservation logic, not just aesthetics.

Here's the motion: even before a train enters a block, once its path is set, that block gets reserved, and following trains' signal state changes. Occupancy ripples backward as a chain of color changes. On high-speed lines, watching the color front advance backward is mesmerizing—and tells you reserve status.

Yellow is subtle on express lines. A train can't stop instantly, so if yellow-to-red happens within braking distance, the train coasts through red. Theoretical stopping distance for a single loco is hundreds of tiles; too-tight block spacing causes constant yellow running. That's not a bug—it's correct physics.

Chain signals extend judgment one step further. Instead of checking just the next block, they see through to the exit signal, lighting red if any downstream block is blocked. This prevents "I can enter but can't exit" mid-intersection. Standard peeks at entry; chain peeks at exit viability.

Right-Side Signals and "No Route" Errors

"Path not found" while tracks clearly connect is a classic early-game trap. Often: trains read right-side signals only. Mirrored intersection designs, backward signal placement, or single-sided dual-track signal job leaves one direction uncontrolled—effectively one-way despite intent.

This causes confusion on bidirectional single-track. You intend both directions, but signal one direction only, creating an accidental one-way. Single-track logic doesn't forgive directional signal mismatch. I replayed this mistake several times on single-track sidings before grasping the right-hand rule.

Another variant: half-doubled single-track, one-way here, attempted-bidirectional there. Mismatched signal directions make the route untravelable to a route-finder. One flipped signal anywhere cuts pathfinding.

And sometimes stations or blocks themselves occupy the way. Short exit blocks trap long trains, occupying the whole block; following trains can't find a legal route with that block locked. It's less a signal error, more a sizing error.

Diagnose "path not found" by checking: right-side signals present and faced correctly? Then single-track signals bidirectional? Then station validity and block sizing. I solve most "how is this path impossible?" in those three steps. Track occupancy and signal face matter before signal type.

Foundation Pattern: Entrance Chain, Exit Standard

Why Chain at Entrance

Intersections split into clear roles: entrance and interior = chain, exit = standard. Same rules apply to T-junctions and single-track squares.

Chain signals fit entrance duty because they check whether the exit is truly reachable, not just the next immediate block. If the path downstream is red anywhere, the entrance turns red, halting trains before the intersection. Standard signals just say "immediate next space free?" which fails here.

Official Factorio Wiki tutorials teach this: chain at entrance, standard at exit. It's not exotic—it's stricter entry judgment, looser exit judgment. Most critical rule to anchor.

Internal Subdivision and Caution

Interior subdivision also uses chain signals. Many paths through a ten-way intersection don't overlap, so partitioning by non-competing routes lets them run in parallel. One big interior block stops any train in the whole space; fine partition lets orthogonal flows continue.

Placement strategy: exit first, then entrance and interior.

1. Place standard signal beyond the intersection
2. Ensure exit-block length fits longest train + margin
3. Place chain at immediate entrance
4. Sub-divide interior by path if needed
5. Test with multiple trains; watch for interior stops

Fine subdivision isn't universal magic. **Interior fragments must be *waiterable***, not micro-slices. I've over-divided and found the congestion didn't improve—exit space was the real bottleneck.

Reference 列車ネットワーク/配置例 - factorio@jp Wiki* (Japanese community wiki). They detail: "partition by non-competing paths," which aligns with "where can trains wait safely without blocking cross-traffic?" Think in that frame.

Train Network / Example Layouts - factorio@jp Wiki*

factorio@jp Wiki*

wikiwiki.jp

Standard Exit + Adequate Staging Space

Standard signals at exit roles because they flow exiting trains forward simply. Post-intersection is "next block clear?" territory, where standard signals excel.

The real magic, though, is block length. An exit block must fit the longest train completely in wait state. If the head exits but the tail stays in the intersection, that tail blocks cross routes. Deadlock ensues.

I reduced gridlock noticeably by sizing exit blocks to longest composition + spare tiles. Simple, but impact is huge. Since blocks limit one train each, a short exit block bottlenecks the whole intersection.

This applies across T, cross, and single-track squares: size exit space to hold the entire exiting train before the next signal.

Specialization: Single-Track, Junctions, and Dual-Track Intersections

Bidirectional Single-Track

Single-track rail halves material cost—tempting! But operationally, it's high complexity. Both directions share one rail, so train passing (siding) management becomes paramount. Blocks allow one train per unit, so single-track without sidings = "one direction at a time"—low throughput, coordination heavy. For beginners, it's genuinely tough.

A modest helper: one passing siding cuts train capacity by 1–2 compositions. Beats full dualization, easier than nothing. Place it mid-span, spaced so trains reach it before conflicting.

Critical: **don't let opposite-direction trains wait at junctions or main merges.** Sidings exist to let trains pass before those critical points. Deadlock elsewhere on net cascades instantly from a stuck single-track queue.

Single-track is glamorous but finicky. Complex ≠ satisfying when it deadlocks. Big networks I prefer dual-track one-way.

Junction (Branch-Off) Signaling

Junctions look simple but jam easily. Chain before the split, standard on each outbound leg, same as intersections.

Chain signal at the branch point sees the selected path's exit. If one branch is jammed, the chain turns red, holding all traffic before the split. Standard signals direct each exit cleanly.

Swap standard for chain at the branch entrance—mistake. Trains see "immediate next block is free, so I can enter," ignore the fact that their chosen branch is gridlocked, and jam inside the junction. Then cascades to trunk lines.

I did this on T-junctions many times: minor station congestion stuck trains mid-junction, back-propagated to main line. Basic form (chain branch-entrance, standard outbound) locks it down.

One-Way Dual-Track Intersections (Most Stable)

One-way dual-track is the easiest, most predictable setup. Right-hand one direction per track avoids direction confusion; throughput beats single-track; setting is much clearer than either alternative. Beginners start here and seldom regret it.

Standard form: chain on each approach, standard on each exit, interior chained by path. Throughput scales smoothly, rules unify across junctions and intersections.

Dual-track costs more rail but separates traffic cleanly. Complexity drops; accidents vanish. Multi-player? Dual-track is way more forgiving.

Long trains on high-speed track incur extreme stopping distances. Theoretical optimizations from unit math suggest stopping ranges in the hundreds of tiles—precise numbers depend on weight, loco count, and research tier, so these are approximations, not guarantees. Point: tight block spacing on express lines causes continuous braking and acceleration, harming both throughput and UPS.

Common Failures and Diagnosis Steps

Symptom: "No Route" Errors

"Path not found" with visible track is the classic signal beginner trap. Causes cluster tightly.

First: is the right-side signal present and correctly oriented? Right-side rule is non-negotiable. Mirrored intersections often reverse one side's signal direction by mistake, rendering that direction unreadable. Bidirectional single-track with only one-direction signals? Instant one-way.

Second: on single-track, is there a facing pair of signals both directions? One direction only = accidental one-way. Opposite direction sees no signal = unreachable.

Third: station validity and block sizing. Stations can be disabled or misnamed. Exit blocks too short trap compositions, locking them in indefinitely. Following trains see "exit is permanently occupied" = no legal route.

Diagnosis order: right-side signals → single-track bidirectional pairs → station state and block capacity. Most "impossible path" snafus clear via those three checks.

Symptom: Trains Stop Mid-Intersection

This is the nasty one. Trains enter, then halt inside, blocking cross routes. Three common roots.

Most common: exit block too short. Head clears, tail stays. That blocked block denies cross-traffic a legal route. Simple fix: measure longest train, add spare space to the exit block.

Second: exit-side already gridlocked. Intersection past is jammed; entrance should be red, but if you used standard signal (not chain), the train sees "next space is free" and enters anyway. Then halts inside waiting for the exit to clear. Diagnosis: does exiting train have a waiting space? If not, interior will fill.

Third: entrance isn't chain. Standard entrance permits "immediate next block free" entry, ignoring downstream problems. Chain would see the blocked path and hold the train before the intersection. Entrance signal type is critical here.

Observe: does the stopped train halt mid-intersection or just before? Mid = signal type or exit space. Just-before = chain working as designed. Congestion isn't mid-intersection, it's normal queueing.

Fix order: lengthen exit blocks, clear downstream jams, convert entrance to chain if needed.

Symptom: Single-Track Standoff (Head-On Deadlock)

Two trains on opposite ends stare at each other, immobilized. Cascades backward to entire network.

Most common: too few or poorly-placed sidings. Passing siding count and position decide whether trains can reach it before meeting on-track. Insufficient sidings = can't pass = gridlock.

Next: entrance signal doesn't see far. If entrance signal is standard (not chain), trains push into the single-track block, ignoring opposite trains, until collision-like stop. Chain entrance sees "opposite train blocking the path" and holds outside.

Third: siding too short for train. Composition doesn't fully fit = still blocks = doesn't help.

Diagnosis: does the standoff happen before or after the siding? Before = siding logic or count. At = siding too short. During = entrance signal misconfiguration.

Single-track is inherently tight on capacity. Sidings are the escape valve; their position and length are the design.

Deadlock Release and Prevention

Stuck gridlock? Don't rebuild; diagnose.

1. Check right-side signals (presence and orientation).
2. Check exit block length and downstream congestion.
3. Check entrance uses chain.
4. For single-track, check sidings.

To break a complete deadlock: move the one train closest to gridlock center backward temporarily. Rarely, shifting one frees the whole chain reaction. Manual multi-train moves create new jams.

Then: apply the root fix (signal direction, exit length, chain entrance, siding placement) and re-verify with traffic.

Official Factorio Wiki's signal tutorial, jias.jp's exit-space examples, and factorio@jp Wiki's layout gallery are rich with tested patterns. Diagnose by symptoms, trace to root, repair. Speed improves sharply once you think "where is this train waiting?" instead of "are all the colors right?"

Factorio 2.0+ Considerations

Interior Chain Subdivision Safety

In Factorio 2.0 onwards, interior chain subdivision feels stable and effective. I've split complex ten-ways internally and watched parallel flows work smoothly—unlike older versions where I'd worry about cascading failure.

Key distinction: "interior subdivision is now feasible" ≠ "it's bulletproof." Chain logic is still chain logic. The appeal is better alignment: partitioning by non-competing paths suits chain signal design naturally. 2.0 didn't change the rule; it made the rule easier to apply skillfully.

Official patch notes don't declare signal-mechanic overhauls in 2.0. Framework changes and display fixes, yes. Core block/reservation logic? No major change is public. So I read 2.0's reputation as "communities find this layout stable" rather than "the game rewrote signal rules."

Empirically, interior partition-by-path helps flow. Non-orthogonal routes don't compete for the same interior space, so fine-grained chains let parallel motion happen. Practical win.

Trouble Zones: Congestion and Edge Cases

Deadlock hazards don't vanish in 2.0. Exit-space shortage and block-length miscalculation cause grief regardless of version.

Real story: I fine-subdivided a 2.0 ten-way interior with chain signals—stable, zero crashes—but miscalculated exit stacker capacity. Dense traffic piled past the intersection, back-propagated to trunk. The intersection itself worked perfectly; the system jammed upstream.

Lesson: clever intersection logic is 30% of victory. Receiving space is 70%.

Unusual geometries and high-density arrival (multiple trains queuing to enter same intersection) are the edges where even smart signaling hits walls. Output starvation beats input logic.

Long express-line trains demand stopping distances in the hundreds of tiles—rough estimates from unit data suggest ~280 tiles as a ballpark, but composition weight, loco count, and research shift this significantly. Tight block crunching doesn't sidestep this fact.

Verification and Live Testing

When tracking 2.0 changes, scan official Wiki signal pages + English patch notes together. Wiki clarifies base mechanics; notes show what was fixed.

Japanese resources: factorio@jp Wiki's layout section is rich with 2.0 examples and explains the "partition by non-conflict" reasoning crisply.

Reality-test: don't trust low-traffic layouts. Quiet systems gloss over flaws. Ramp train count up and watch. A "perfect" intersection fails under load if output is too narrow. Stable design degrades predictably (slow, not sudden crash).

The mark of good design: congestion is smooth, not chaotic. Trains queue nicely, flows restart after external jams clear. Poor design: deadlocks, oscillation, unexpected halts.

Test-driven design often beats theory here. Once you see how layout behaves under stress, signal wisdom clicks.

Where To Read Next

Start small: test T-junctions and crosses with two or three trains. Verify these patterns:

• Station design and stacker capacity (waiting lanes, exit space)
• Chain signal patterns (entrance, interior, exit variation across intersection types)

Official Factorio Wiki (Train signals, Train network, Station design) and Japanese/English community wikis publish schematics and blueprints liberally. As the site grows, internal links will fill gaps. For now: think small, verify exit space, and incrementally expand. That's the surest path to confidence.