Factorio Train Signals Fundamentals | Standard vs. Chain Signals and Blocks

In Factorio's railway system, in-game train signals work with a clear rule: standard train signals look only at the next block, while chain signals check the entire path ahead to keep trains from stopping inside intersections. Once you understand this distinction, the design rule becomes remarkably simple: chain signals at entry, standard signals at exit. This principle applies whether you're building T-junctions, four-way intersections, or even bidirectional single-track lines.

I spent three hours debugging a plus-shaped intersection, hitting dead ends from poor routing, trains stuck in the middle, and gridlocked single-track lines—all in sequence. But once I separated the signal roles and repositioned them correctly, every issue vanished. This guide is for anyone who wants to diagnose "why trains are jamming" and move beyond trial-and-error design. I'll walk through the fundamental rules and intersection logic using real-world examples.

Target Version and Prerequisites

Version Scope

This article assumes vanilla Factorio 2.0+ primarily. If you're using Space Age (the expansion DLC or large-scale community mods), check compatibility separately for those features. The core signal principle—dividing track into blocks with a maximum of one train per block—remains consistent from 1.x to 2.0. I'll focus on 2.0's interface and practical operation throughout.

Assumed Skill Level

You should have completed the tutorial and understand basic train scheduling. You've placed stations, assigned stops to a train, and gotten it running. If you're at that stage, this guide will click. If you haven't driven a train yet, you may struggle with station names and schedule behavior before getting to signals.

One more crucial point: know the longest train composition you'll use on your network. Most intersection and passing-siding jams come not from wrong signal types, but from "the train's rear still occupies the block even though the front has left." Before touching other players' track in multiplayer, I always check their longest train first. Overlooking this causes seemingly correct layouts to fail mysteriously under traffic.

Throughout this guide, I'll work from the assumption that you don't yet understand standard vs. chain signals—I'll build that intuition through examples. What I skip are basic train UI controls, station naming, and timetable setup itself.

Topics Outside This Scope

I'm focusing on vanilla signal logic and foundational intersection/junction/single-track design to prevent gridlock. Broader topics get their own treatment elsewhere:

Circuit network + train control is excluded. Station enabling, signal reading, and dynamic circuit-based control are interesting, but you should be able to run trains safely with signals alone first. Wrapping a chain-signal problem in circuit logic only makes diagnosis harder.

Station stacker design deserves separate depth. Stackers are the capstone of signal mastery, balancing entry congestion, lane lengths, and exit merging. Here, I focus on the foundation: how to divide blocks and keep trains out of intersections.

UPS optimization is also out of scope. Whether to split intersections fine or balance single and dual track, how many stations to run—these affect performance but represent large-factory thinking, not core signal logic. First, prevent gridlock; then optimize.

Factorio's Two Signal Types: Standard vs. Chain Signals

Standard Train Signals

A standard train signal is elegantly simple: it reads only the next block. If the block ahead is empty, go; if occupied, stop. Start here and you're fine.

Factorio's signals divide track into blocks. The rule is: only one train per block at a time. Standard signals enforce this boundary, making them perfect for straightaways and intersection exits. After a train leaves the intersection, a standard signal on the exit cleanly flows it to the next block without fussing.

Signal colors matter here: green means proceed, yellow means the next block is reserved or about to turn red, red means blocked. Many players treat yellow as "caution," but it's actually the game saying "you probably can't stop in time." On high-speed main lines, if I cram signals too close together, yellows pile up and trains spend half their time decelerating and re-accelerating. Single-locos have theoretical braking distances in the hundreds of tiles, so standard signals packed densely don't always help.

The trap is placing a standard signal at an intersection entry. The train sees "the next block is open, so I can enter," but if what lies beyond is congested, it stops inside the intersection. This is the textbook beginner jam. Standard signals aren't wrong—they're just the wrong tool at entry. Think of it as: they're good at flowing traffic out, bad at preventing mid-intersection stops.

Chain Signals

On Factorio 2.0+, the community sees intersection interiors divided by chain signals as largely stable. I've run many plus-shaped intersections with interior chains splitting by path, and the "this breaks everything" feeling is gone. For multi-directional simultaneous traffic, interior chains often work better.

But this is not a free pass. It's not that 2.0 made sloppy chain placement harmless. Rather, 2.0 makes the "don't stop in the middle" philosophy easier to implement. The core remains: if the exit buffer runs short, trains back up into the intersection, chain signals or not. I've seen plenty of carefully chained intersections jam simply because the exit block couldn't hold a full train.

This resonates with examples in 『ゼロから始めるFactorioの鉄道構築（連動式信号編）』. When I troubleshoot a jam, I ask first: "Can this train, once it leaves, fully fit in its destination?" before second-guessing the signal layout.

One-Sentence Distinction and Right-Side Rule

Here's my clearest wording: "Standard signals read only the next block; chain signals read ahead to the exit, so they hold trains before an intersection." That one sentence handles most cases.

In practice, chain at entry, standard at exit cuts accidents dramatically. Most people mix up signal names; thinking "where should the train wait?" instead fixes it fast.

Easy to overlook: the right-side rule. Trains read signals only on the right side of their travel direction. If you place signals on the left only, that direction becomes effectively one-way. The 『チュートリアル：列車用信号 - Factorio Wiki』tutorial grounds this rule as fundamental.

This nearly killed me once: I was stuck on "no route found" but the real cause was signals only on one side. On dual track where I thought I'd placed two-way logic, one direction had no readable signal—so routing failed for that way. Adding the mirror signal instantly fixed it.

So: standard reads next-only, chain reads ahead, trains see right-side signals. Those three facts let you diagnose stalls by description alone.

Tutorial:Train signals/ja

wiki.factorio.com

How Blocks Work: One Block, One Train

Signals Create Blocks

Factorio's signals aren't just "go" and "stop" signs. They're block boundaries dividing track. The section between signals—or from a signal to the next—is one block, holding exactly one train max. Grasping this transforms "why is my train waiting?" from mystery to logic.

This principle is bedrock in 『チュートリアル：列車用信号 - Factorio Wiki』. Signals manage occupancy rights by block, not direct train guidance. That's why trains never collide: the block rule enforces it everywhere—intersections, single-track, station approaches.

I initially thought more signals = faster flow. Wrong. How you divide into blocks matters far more. Oversized blocks let one train monopolize wide areas, starving downstream. Undersized blocks near intersections and stations let trains inch forward and ease congestion. I've seen main-line flow smooth out noticeably just from block layout.

But fine-tuning everywhere isn't the answer. Exit blocks from intersections and passing sidings must fit your longest train completely. If the exit is too short, the rear stays trapped inside, clogging cross-routes. I once tried cramming exit blocks smaller to fight gridlock—and made congestion worse. Subdivision works, but trains need a place to fully wait.

Signal Colors and Reservation

A standard signal checks if the next block is free. Free = green, occupied = red, with yellow in between. These aren't just visuals; they tie directly to train entry reservations.

As soon as a train "decides" to enter a block, that block is reserved. Downstream trains see the signal change color even though no train is there yet. Standard signals turn yellow as entry becomes imminent and red once the train is nearly upon them. The reservation system runs ahead.

Yellow is real on high-speed sections. Trains can't stop on a dime, so if red comes within braking distance, the train coasts through anyway. Single-loco braking might span hundreds of tiles, so cramming signals tight creates long stretches of yellow-light running. That's not a glitch—it's physics-aware behavior.

Chain signals extend this lookahead one step further. They read not just the next block, but down the path to the exit signal. If any block on the route is red, the chain turns yellow or red too. That's why chains at intersection entry prevent "next block is open, but I can't exit" jams. Standard signals see "can I enter?"; chain signals see "can I leave?"

Right-Side Signals and "No Route Found"

"Track connects but no route is found" is a common pitfall once you've started placing signals. Typical culprit: signals missing from the right side of the travel direction. Since trains only read right-side signals, placing them left-only—or backward—makes that direction invisible. Your layout looks bidirectional; gameplay sees one-way.

This bites single-track especially hard. You intend "both directions," but end up with signals only on one way and none the other. Routing fails for the bare direction. I've made this mistake repeatedly; it's sneaky because the track looks fine.

Another pattern: one-way logic scattered through a two-way layout. You run dual-track one-way, then try to mix bidirectional at stations or junctions. One misaligned signal breaks the route.

Or, blocks jam even with correct signal orientation. The exit buffer is too short for your longest train. The front reaches the exit block but the rear stays trapped inside, occupying the whole block. From downstream, that block appears unreachable—"no route found" is the symptom, but insufficient exit space is the disease.

Troubleshooting: check signal orientation, block occupation, and exit length in that order. I diagnose most jams this way without touching signal types.

The Foundation: Chain at Entry, Standard at Exit

Why Chain Signals at Entry

Intersections rest on chain entry, chain interior, standard exit. This pattern works for T, plus, or any crossing. Philosophy: hold trains at entry to prevent mid-intersection stops (chain), then push departing trains forward (standard).

Chain signals excel here because they see whether the path actually clears to the exit, not just whether the next block is open. If the exit is stuffed, the chain entry goes red and holds the train upstream. Standard signals would let the train enter on a technicality, then jam in the middle. I spent hours in a plus-intersection doing exactly that.

『チュートリアル：列車用信号 - Factorio Wiki』treats chain-at-entry as foundational. It's not advanced; it's stricter entry logic with loose exit logic—precisely the right balance.

Interior Subdivision and Caveats

Partition the interior with chain signals too, splitting by crossing path. Why? Separate routes can proceed simultaneously rather than one train blocking all others. A plus-intersection has right-turn, straight, and left-turn paths that don't fully overlap; lumping them into one block stops traffic unnecessarily.

Layout order: decide exit first, then interior, then entry.

1. Place a standard signal after the intersection clears.
2. Ensure the exit block has room for a full train.
3. Place a chain signal just before the intersection entry.
4. Subdivide the interior with chains if needed.
5. Run multiple trains and watch for mid-intersection stops.

Fine division of interior chains helps in congestion, but finer ≠ automatic success. The interior blocks are only useful if trains can actually wait there. Small fragments with big trains don't solve anything. Honestly, when an intersection jams, the real culprit is usually weak exit space, not insufficient interior chains.

『列車ネットワーク/配置例 - factorio@jp Wiki』shows that intersection design hinges on "chain entry, standard exit" plus interior splitting matched to traffic conflicts. Design for where trains wait*, not for visual symmetry.

Train Network Examples - factorio@jp Wiki*

factorio@jp Wiki*

wikiwiki.jp

Exit: Standard Signal + Adequate Buffer

Standard signals on the exit route outbound traffic cleanly. Once clear of the intersection, trains need simple forward flow, and standard signals provide that.

But the real anchor is exit block length. The block must fit your longest train entirely. If it doesn't, the rear lingers in the intersection, clogging paths. I've resolved dramatic gridlocks by simply extending exit blocks by half-a-dozen tiles. Unglamorous but transformative.

This applies to T, plus, and any crossing equally. Size the intersection around your longest train + a few extra tiles, and upstream chain logic follows naturally. When stuck between widening the intersection and extending the exit, choose the exit. Train capacity and flow hinge on it.

Single-Track, Junctions, and Dual-Track Intersections

Bidirectional Single Track

Single-track saves rail—often halving consumption. It looks romantic. But it's operationally demanding.

Single-track requires trains to share one line both directions, so collision prevention rests on passing sidings. A closed block admits one train; if no passing siding exists upstream, trains wait a long time. Traffic is inherently low. It's not beginner-friendly.

Passing sidings unlock capacity. A single-line route with one mid-section passing siding often fits 1–2 extra trains. I once added a ~50-tile passing siding to a resource branch and immediately cut gridlock because trains could swap directions mid-line instead of fighting at the main merger.

Core principle: don't let trains wait on the main line or junction approaches. Single-track capacity is fragile; waiting in the wrong spot cascades into network-wide stalls. Siding position and length are everything.

Community examples (jias.jp single-track guides, factorio@jp Wiki) highlight that single-track works if passing sidings are right. It's viable, but conditional. Dual-track is forgiving; single-track demands precision.

Junctions: Splitting Paths

Junctions are deceptively simple to misconfigure. Apply the same rules: chain at entry (the junction decision point), standard at each branch exit.

Chain signals at the split let trains check whether their chosen branch has a clear path to the destination. If the right branch is congested, the chain upstream goes yellow/red. Without that, trains enter the junction willy-nilly and jam inside.

I've done this wrong on resource T-splits: a small station backup rippled upstream through the junction into the main line. Swapping the entry to a chain signal stopped junction clogging and freed the main line immediately.

Interior subdivision is less critical here than for full intersections, but the principle holds: enter via chain, exit via standard, with exit block length as the physical anchor.

One-Way Dual-Track Intersections

Operationally smoothest is dual-track, one direction per line. Rails cost more, but routing is transparent, signal orientation is consistent, and throughput is high.

This setup lets you apply the chain-entry / standard-exit / interior-chain blueprint directly. Right-turn, straight, left-turn paths are segregated by track, so interior subdivision is geometrically clean. You're also working from the "trains separate by direction" foundation, which drastically cuts mistakes. In multiplayer, this clarity is gold—others can fix bugs instead of wrestling the design.

Compare single-track: you save rail but accept low capacity and high signal complexity. Dual-track burns more rail but unlocks simpler design, higher throughput, and fewer "wait, where's the jam?" moments. For quantity production, dual-track one-way dominates.

One subtlety on speed: high-speed sections demand longer blocks because trains' braking distance is substantial. A single-loco ideal calculation suggests stopping distances in the hundreds of tiles (roughly 280 in some cases), though real values shift with train weight, multiple locos, and research. Still, don't assume short blocks solve speed-junction conflicts.

Diagnosis: Common Failures

Symptom: No Route Found

"Tracks link but trains won't route" stems from signals not being readable from that direction.

First check: is there a signal on the right side of the travel direction? Left-only, backward, or missing right-side signals make the track unreadable for that way. Even symmetric-looking layouts hide this. Check orientation carefully.

Single-track is particularly vulnerable: if you want bidirectional, you need signal pairs covering both directions. One side naked? That direction becomes one-way in the game's eyes.

Second check: in single-track, do both directions have paired signals? If only one direction is signaled, the other route doesn't exist to the pathfinder.

Third: is the station actually enabled and named correctly? Disabled stations or name mismatches break pathfinding even with perfect signals. I've wasted 30 minutes repositioning signals when the station name was misspelled.

Sequence: check right-side signals and orientation → single-track pairs → station state and name. This catches nearly every no-route case.

Symptom: Train Stops Inside Intersection

"Train enters intersection then halts mid-crossing" has a narrow set of causes.

Most common: exit block too short for your longest train. The front leaves the intersection, but the rear stays inside. That occupies the whole exit block, clogging perpendicular paths. jias.jp has a great visual on this. Even trains half-tail-out are infrastructure killers. Extend the exit block by train length + margin.

Next: the exit destination is already congested. The exit block chains out, preventing entry even though the chain looks green. This is a downstream jam, not an intersection flaw. Unclog the exit destination.

Third: chain signal at entry is actually a standard signal. Standard signals let trains enter on "next block is open" alone, ignoring what lies beyond. If that's your setup, trades to chain immediately.

Watch where the stopped train sits. Inside the intersection = check exit length and exit dest. Before the intersection = chain is working. Gridlock usually has roots outside the intersection itself.

Symptom: Single-Track Deadlock

Two trains facing each other, both stuck cascades backward through the entire network.

Suspect: insufficient or poorly positioned passing sidings. Adding one siding often solves it; misplaced sidings don't. Trains must naturally reach the siding before hitting opposing traffic.

Next: entry chain signal is absent or the single-track interior entry uses standard. Standard signals let trains commit to the single-track before checking if the other direction is clear. They end up facing in the line itself, unable to back out. Use a chain signal at the entry to single-track sections.

Diagnosis: do two trains stop on the single-track stretch itself? Then sidings are missing or misplaced. Do they stop before reaching the siding? Signals or siding position is wrong.

Single-track gridlocks are tougher than intersection gridlocks because they're smaller and more cascading. Look for: right-side signal completeness → siding positions and lengths → entry chain setup.

Deadlock Recovery and Prevention

When a jam fully locks, don't demolish everything. Diagnose step-by-step.

1. Check signal orientation and right-side placement.

Route-not-found and one-way-only symptoms vanish here. Intersections and turnarounds hide orientation mistakes.

1. Check exit block length and downstream congestion.

Mid-intersection stops trace back to short exits or outflow jams. Interior stops mean the exit can't empty.

1. Check intersection entry is a chain signal.

Sloppy entry lets trains jam inside. Chain at entry is the easiest win for interior stalls.

1. For single-track, check passing siding count and position.

Deadlocks are usually siding gaps or bad placement forcing trains to face on open track.

To break an active deadlock, move only the most gridlocked train—usually the one at the jam's center. Sidestep it temporarily; often the rest flow backward automatically. Bulk manual shifting creates new jams.

After the emergency clear, fix the root cause: misaligned signals → fix orientation; short exit → extend it; standard at entry → swap to chain; siding gaps → add sidings. Then retest under load.

The official 『チュートリアル：列車用信号 - Factorio Wiki』 leans heavily on right-side and block logic. jias.jp drives home exit-buffer inadequacy. Work through issues this way and signal behavior becomes mechanically readable instead of mystical.

Factorio 2.0+ Considerations

Can Interiors Be Chain-Subdivided?

On Factorio 2.0+, **interior intersection chains divided by path are stable in practice. I've built complex plus and junction crosses with fine interior chains; they run smoothly far more often than my pre-2.0 intuition warned. Community consensus is yes, they work unless you hit an outlier scenario.**

Important distinction: "interior chains work" ≠ "everything works." Chains should work well with intersection interiors because the chain-reads-ahead design suits path-based subdivision. 2.0 doesn't change the signal-reading rules; it's more that the subdivision strategy and signal behavior align better.

No official 2.0 signal-overhaul post-exists. Patch notes show signal bug fixes and UI tweaks, not fundamental rewrites. So this is more "2.0 environment + community experience = interior chains stable" than "2.0 rewrote signals."

Subjectively, chunking interiors by path—rather than one huge block—flows trains better, especially on dual-track. Let non-competing paths proceed in parallel; it's cleaner.

Edge Cases and Congestion Cautions

Gridlock root causes didn't vanish. 2.0 hasn't erased exit-buffer shortage or block-design errors. I've built fine interior chains only to hit stalls because the exit simply couldn't swallow the outflow. The interior chains looked smart; exit collection capacity was the real bottleneck. No amount of interior cleverness fixes a too-narrow exit.

High-volume networks—where trains converge from multiple angles—expose interior-chain limits. Subdividing interiors helps parallel traffic, but if all paths merge at a narrow downstream, the interior becomes a waiting hall. Complex ≠ capable.

Heavy trains and high-speed sections also matter. Stopping distance for a single loco can theoretically exceed hundreds of tiles (ballpark 280), depending on speed and acceleration. Compact interior blocks don't automatically compensate for speed-zone dynamics.

Confirming Specs and Testing

Track 2.0 info via official Wiki (train signals, train networks, station design) + English patch notes side-by-side. Wiki locks down core rules; patches show bugfixes. Based on available data, 2.0 doesn't rewrite signal behavior—just stabilizes and polishes.

Japanese sources like factorio@jp Wiki carry post-2.0 examples and nuance. The "subdivide interior by conflict, not arbitrarily" takeaway is practical gold. I prototype new intersections by spawn-testing tons of trains, not theorizing first.

Stress-test reveals truth. Intersections with light load look fine even if flawed. Heavy load exposes bad signal layouts, short exit blocks, undersized stackers. Designs that stay "slow" under strain are good; those that suddenly jam hard are sketchy.

Assess designs by robustness under load, not smoothness under calm. Interior chain subdivisions shine or fail here. 2.0 doesn't hand you a free pass; it just makes the right strategy easier to execute.

Next Topics to Explore

Start small with real intersections. Once core signals click, expand into these:

• Station design and stackers (waiting lanes, buffer capacity)
• Chain signal patterns (entry vs. interior vs. exit rules)

Official Factorio Wiki (Train signals, Train network, Station design sections) and community blueprint shares have excellent diagrams and examples. As corresponding articles appear, internal links will be added here. Prototype first—build a T-junction, run 3 trains, watch where they stop, and adjust. That hands-on cycle beats any ruleset alone.