Factorio Train Signals Basics | Standard and Chain Signals

In Factorio's railway system, standard signals look only at the next block, while chain signals look further ahead to prevent trains from stopping inside intersections. Once you grasp this difference, the solution becomes remarkably simple for intersections, junctions, and single-track layouts: entry chain, exit standard. Even I spent about three hours stuck at a four-way intersection, cycling through routing failures, intersection stalls, and single-track deadlocks. Fixing them was simply a matter of repositioning signals according to their proper roles. This article is aimed at readers who want to diagnose why their networks jam, covering the fundamental rules and intersection design principles through practical examples, with an eye toward Factorio 2.0 and beyond.

Target Version and Prerequisites

Version Scope

This article assumes vanilla Factorio 2.0 as the primary reference. If you're using the Space Age expansion (DLC or large community mods), verify compatibility separately. The core signal principle—dividing track into blocks with a maximum of one train per block—remains consistent with 1.x versions. This guide focuses primarily on 2.0's interface and operational practices.

Assumed Skill Level

You should have completed the tutorial and understand basic train scheduling. You've placed stations, assigned destinations to trains, and gotten them running. That's sufficient. If you haven't moved a train yet, you'll get stuck on station mechanics and schedules before signal logic becomes relevant.

Know your network's longest train composition. Intersection and siding jams often stem not from wrong signal types, but from "the train doesn't fully clear before we position the signal"—a common mismatch. Before editing someone else's track in multiplayer, I always ask for the longest consist length first. Overlooking this detail leads to seemingly correct layouts that cause accidents when trains pass.

This guide doesn't assume you already understand standard and chain signals; we'll build that understanding with examples. However, basic train UI controls, station naming, and schedule creation are covered elsewhere.

Topics Not Covered Here

This article focuses on barebones signal placement and intersection design within vanilla Factorio to prevent jams and deadlocks. Broader topics are omitted to stay focused.

Circuit network integration is out of scope. Station activation, signal reading, and dynamic control are powerful tools, but signal-only safe operation is the priority. Wrapping signal-solvable problems in circuit logic actually makes troubleshooting harder.

Station stacker design gets its own treatment. Stackers combine everything—entry congestion, lane length, exit merging—into one theme. We stop at "how to cut blocks" and "prevent stopping inside intersections."

UPS optimization also stays outside. Intersection granularity, single vs. double-track division, station count—these all tie into UPS eventually. That's a megabase concern, separate from learning signals. Focus first on preventing congestion and deadlocks; that keeps design decisions clearer.

Factorio Signals Come in Just Two Types: Standard vs. Chain Signal Differences

Standard Rail Signal Role

The standard rail signal is simple: it looks only at the next block. If the block ahead is clear, go. If it's full, stop.

Factorio's signal system divides track into blocks, and only one train per block can prevent collisions. Standard signals serve as basic dividers. Straight sections and exits work smoothly with them. Place one at the exit to route trains out cleanly.

Signal colors are worth noting: green = proceed, yellow = next block reserved or imminent red, red = no passage. Yellow often looks like "caution," but it also appears when a train can't brake fast enough. I've watched high-speed lines turn yellow-heavy because I crammed signals too close, causing constant deceleration and re-acceleration. Even a single engine has substantial stopping distance at speed, so dense standard signal placement isn't always wise.

Placing a standard signal at an intersection entrance invites disaster: "the next block is free so enter, but the path ahead is jammed—stop inside the intersection." This is the textbook beginner jam. Standards aren't bad; they're just in the wrong spot. Use them for clean exits, not for preventing intersection stops.

Chain Signal Role

In 2.0 and later, the community found that fine-grained interior chain signal division works surprisingly well in most cases. I've split four-way intersections by route with chains and rarely hit the instability I saw in older versions. Multi-directional simultaneous flow becomes easier when interiors are partitioned.

That said, it's not a silver bullet. Special junction conditions or dense traffic can still cause gridlock if the exit space is insufficient. Chain signals can subdivide the interior as much as you like, but if the exiting train has nowhere to land, it stops mid-interior, blocking other routes. The takeaway: 2.0 doesn't make careless interior chaining safe; it just makes the right approach more viable.

The "ゼロから始めるFactorioの鉄道構築（連動式信号編）" example of insufficient exit length drives this home. When I debug jams, I ask "does the exiting train actually fit in the receiving space?" before fiddling with signal type. Honestly, that single check solves most issues.

One-Liner Distinction and Right-Side Rule

My clearest phrasing: Standard signals see only the next block; chain signals see beyond, waiting at the entrance to prevent mid-intersection stops.

In layout terms: entry chain to prevent stops inside → exit standard to smooth outflow. Stop thinking about names and start thinking about where trains wait. I spent early hours reversing them by name until I focused on the actual waiting points.

The right-side rule is easy to miss but vital. Trains read signals on their right as they travel. Place signals on the left, and that direction becomes one-way by default. The Factorio Wiki's train signal tutorial emphasizes this.

This almost derailed me in a "no path" debugging session: I had signals everywhere—except on the side the train needed to read. Adding the mirror-image signal to the opposite direction instantly restored routing.

So the core takeaway: standard = next block only, chain = look ahead, trains = read right-side only. Memorize this trio, and you can explain almost any jam.

Tutorial:Train signals/ja

wiki.factorio.com

How Blocks Work: One Train Per Block, Period

Signals Create Blocks

Factorio signals aren't merely "go" and "stop" signs. They're boundaries that divide track into blocks, and each block holds exactly one train maximum. Understanding this transforms "why is my train stuck?" into something explicable.

The Factorio Wiki's train signal tutorial makes this crystal clear: signals manage track occupation per block, not train guidance. Whether at intersections, single-track, or station approaches, trains don't collide because of this rule.

I stumbled here initially, thinking more signals = faster flow. Wrong. How you partition into blocks matters far more. Long blocks starve downstream trains because one consist locks down a vast section. Careful short divisions upstream of intersections or stations let trains inch forward and eases congestion noticeably.

But fine-grained partitioning isn't a universal fix. Exit blocks especially must be long enough for the full consist to exit. Short exit blocks cause the consist's tail to linger inside the intersection, blocking cross-traffic and cascading into deadlock. I once over-divided an exit hoping to ease congestion and made it worse.

Signal Colors and Reservation Behavior

Standard signals check if the next block is clear. Clear = green. Occupied = red. In-between = yellow. This isn't just cosmetic; it ties to train path reservation.

Reservations work ahead: even an empty block turns yellow once a train commits to entering it. Standard signals go green (next block free) → yellow (next block reserved or train approach imminent) → red (next block occupied) as things progress. That "suddenly yellow with no train visible yet" moment? Pre-reservation.

Yellow's impact shines on high-speed lines. A train can't stop on a dime; if it's in the stopping zone when the signal turns red, it coasts through anyway. Single engines have stopping distances in the hundreds of tiles, so cramming tight signal spacing on a fast trunk line causes constant yellow-light cruising. This is normal, not broken.

Chain signals extend this one step further. Instead of the next block, they see all the way to the exit signal. If any step in that path is red, the chain turns red or yellow preemptively. So chains at intersection entrances ask "can I actually exit?" before committing.

Right-Side Signals and No Path Available Causes

"The tracks connect, but No path available"—this happens constantly after learning signals. A textbook cause: the signal is on the left, not the right, from the train's perspective. Right-side-only rule makes that direction one-way invisibly.

Single-track runs into this hard. You intend bidirectional operation but only wire up one side's signals, accidentally one-way. Trains find no return route.

Another pattern: mixing one-way and two-way partway through. Dual-track main lines sometimes have dual-directional branches awkwardly mid-route. A single signal-direction mismatch breaks routing for trains trying that path.

Sometimes blocks themselves are locked—the exit block too short for the longest consist leaves the tail in the intersection, consuming that whole block. Downstream trains see "the path requires that full block, which is occupied" and find no valid route.

When "signals are correct" yet routing fails, check signal placement sides, signal directions, and block fit. These three account for almost all my fixes. Once you start tracking which block each train reserves and where it can fully stop, No path available becomes predictable.

Core Setup: Intersections Use [Entry Chain, Exit Standard]

Why Chain at Entry

The fixed pattern for intersections: entry and interior = chain signals; exit = standard signals. This works from T-junctions to four-ways. Philosophically: use chains to stop trains before the intersection if needed, use standards to smoothly release exiting trains.

Chains work here because they ask "can this route fully clear?" not just "is the next square free?" If exit space is full, the entry chain goes red and trains wait outside the intersection—not inside it. Standard signals trigger entry too easily, letting trains in and stopping them mid-intersection, blocking other routes.

The Factorio Wiki pinpoints this as foundational: chains at entry, standards at exit. It's not advanced technique; it's strict entry, permissive exit.

Interior Partition and Caveats

Chain signals subdivide the interior to let separate routes run in parallel. Four-way intersections have (roughly) four distinct paths; one giant interior block stalls all users. Partitioning by route helps.

Safe procedure:

1. Place standard signal(s) on the exit.
2. Reserve exit block space for the longest consist.
3. Place chain signal at the entrance.
4. Partition interiors with chains if multiple routes compete.
5. Run multi-train tests; watch for mid-interior halts.

Interior chaining isn't universally correct. Tight interior divisions must still be "wait zones," or they just fragment the problem. In my experience, congested intersections suffer from insufficient exit space more than insufficient interior signals.

Community examples (factorio@jp Wiki, jias.jp) center on "entry chain, exit standard" plus "interior chains match route conflicts." Focus on where trains actually wait.

Train Network / Layout Examples - factorio@jp Wiki*

factorio@jp Wiki*

wikiwiki.jp

Exit Standard Signal + Block Length Guarantee

Standard signals at exits smoothly forward exiting trains to the next block. Once out of the intersection, routing shifts from "can we exit at all?" to "is the next block free?" Standards fit this role naturally.

Critically, the exit block must physically fit the longest consist. If it doesn't, the train's rear hangs in the intersection, occupying that block. This blocks other routes, creating No path available-like symptoms from good signal placement. This is a layout failure, not signal failure.

After I made exit blocks long enough to contain the full consist plus a few tiles, my previously scattered gridlocks largely vanished. Small change, huge impact. Exit block length is a structural throughput limiter; short intersections jam inherently.

Same logic applies to T-junctions and four-ways. Front-load the exit standard signal and length; the entry chain position follows naturally from there.

Single-Track, Junctions, and Dual-Track Intersection Patterns

Bidirectional Single-Track

Single-track halves rail usage—attractive in early game or for distant spurs. But operationally, it's tough. One line, two directions: passing management dominates. With one train per block, two-way single-track struggles unless both directions fit in one block, forcing alternating flow—low throughput.

Passing sidings (siding for trains to pass) unlock bidirectional single-track. A single ~50-tile siding between two stations roughly doubles the passable train count on that line. I once merged a single-track feeder into my main without a siding, creating indefinite head-on waits. Adding even one siding eased it greatly.

The catch: trains must be able to reach the siding before hitting the main. Positioning matters. Single-track struggles because blocking the main line is catastrophic; multi-train backs up linearly.

Community examples (jias.jp, factorio@jp Wiki) confirm: single-track works but requires siding strategy. Romantic, high difficulty.

Branching Signal Layout

Branches mimic intersections: chain at the entry, standard at each branch exit. Trains see "does my chosen route open to the exit?" and only move if so. Closed branches don't draw trains in; they wait outside.

Placing a standard at the branch entrance invites trains in speculatively. If a branch then clogs, the train stops mid-branch, blocking other routes. Chaos ensues.

T-junctions are deceptively simple-looking. I've jammed entire networks by under-signaling a resource branch. The principle: "don't let trains commit to a route unless they can fully exit."

One-Way Double-Track Intersections (Stable Pattern)

One-way dual-track intersections are the safest, easiest pattern. Right-side operation segregates directions cleanly, and signal reading flows predictably. Throughput beats single-track, and design is intuitive. Start here.

This setup embodies entry chain + exit standard directly. Right-turn, straight, left-turn paths each get chains at their entry and standards at their exit, with interior partitioning as needed. Direction separation removes a huge source of confusion.

Single-track saves rail but drops throughput hard, especially without meticulous siding placement. Double-track burns more rail but lets you unify intersection logic and scale traffic easily. In multiplayer, the clarity is invaluable.

Stop distance at high speed is another angle. Ideal stopping distance (from speed/acceleration specs) can reach hundreds of tiles, sometimes ~280 tiles for single engines under certain conditions. This is a theoretical estimate; real gameplay varies with consist weight, multiple engines, and research. Cramming short signal blocks doesn't guarantee safety.

Common Failures and Diagnosis Steps

Symptom: No Path Available

"Signals in place, but No path available"—usually a signal-reading failure, not track continuity. I've spent hours mystified, but answers cluster.

First: is there a signal on the right side? Trains read the right. Left-only, reverse-facing, or absent right-side signals invisibly one-way a corridor. Symmetric-looking intersections often have flipped signal directions on one side. Dual-directional single-track sometimes has signals only on one side, forcing one-way.

Station state and naming matter too. Invalid or duplicate-name stations block path discovery even with correct signals. I've wasted 30 minutes re-signaling when the actual culprit was a typo in the station name.

Diagnosis order:

1. Check right-side signal presence and orientation.
2. Confirm single-track pairs are bidirectional (both sides wired).
3. Validate station status and naming.

It's mechanical once you treat it as "how does the train read this line?"

Symptom: Train Stops Inside Intersection

Trains halting mid-intersection is painful. Usually: exit block too short, exit-side jam, or wrong entry signal type.

Most common: the consist doesn't fully clear the exit block. Head clears, tail stays inside, blocking cross-paths. Chain and straight signals don't matter if the layout traps the train's rear. jias.jp's examples show this clearly; I've crippled four-way intersections by leaving exit space unchanged after upsizing consist.

Second: exit-side congestion. Upstream gridlock means the entry chain should be red, but if it's a standard signal, "next block free" still lets trains in. Then they halt mid-intersection, cascading failure.

Check: does the stopped train have space to fully exit downstream? If not, extend it. Is the exit side jammed? Untangle it. Is entry a standard (should be chain)? Fix it.

Usually the problem lives outside the intersection, not inside it.

Symptom: Single-Track Deadlock

Two trains facing off on single-track—disaster. Causes: missing sidings, bad siding location, or entry signal that shoves trains into the single-track.

Most common: insufficient or poorly placed sidings. Adding one siding can let 1–2 more consists operate; bad positioning lets trains commit to the main before accessing it.

Entry to single-track should use chains to "see past" the interior; standards compress trains into the single-track body. Bidirectional single-track plus poor entry signals = passing trains collide inside.

Diagnosis:

• Is there a passing siding? Where? Can both trains reach it before collision?
• Is entry a chain (checking for exit viability) or a standard (pushing in blind)?
• Do trains head-on before the siding, or reach the siding and queue?

Single-track deadlock is almost always layout (siding), not signal type.

Deadlock Clearance and Prevention

Once gridlocked, diagnose before wholesale demolition. My procedure:

1. Right-side signals: presence and direction.

Fixes No path available cases fast.

1. Exit block length and downstream jam.

Intersection mid-stops usually trace here.

1. Entry is chain (not standard).

Careless entry signals allow mid-intersection commits.

1. Single-track: siding count and position.

Deadlocks stem from insufficient passing room or poor entry logic.

For active deadlock, release one train (the one nearest the jam epicenter) rather than moving all of them. This cascades clearance; multi-train manual ops risk new jams.

After clearance, fix root cause and re-signal. Wrong signal direction? Flip it. Exit too short? Extend it. No siding? Add one. This prevents recurrence.

Wikis (official and factorio@jp) highlight right-side rules and block concepts. Approach jamming diagnostically—symptom → root cause → fix.

Factorio 2.0+: What to Watch For

Interior Chain Subdivision Viability

Factorio 2.0+ lets interior chain partition run surprisingly smoothly in most cases. I've subdivided complex four-ways by route and rarely hit the instability I expected. Complex merges work better when interiors are split.

But "works well" doesn't mean "always safe." 2.0 patch notes and Wiki clarify signal handling; no game-rules overhaul is documented. The stability is observed practice, not official mandate.

Interior subdivision _does_ help because chains inspect exit-path viability. Competitive routes benefit from partition; I've seen throughput improve with interior chains vs. one giant block, especially on dual-track mains.

Edge Cases and Dense Traffic Caution

Deadlock potential doesn't vanish in 2.0. Exit insufficiency remains the core killer. Finely partitioned interiors won't save a starved exit. I subdivided an intersection beautifully in 2.0, only to watch it gridlock when stackers upstream filled beyond capacity—the jam wasn't signals, it was exit space.

High-density multi-directional networks are risky. Chains subdividing interiors enable parallel routes, but if all exits back up, those internal blocks become holding pens. The whole line stalls.

Fast lines feeding intersections need respect for stopping distance. While calculations (from speed/acceleration specs) suggest ~280-tile stopping for single engines, this is theoretical. Real consist weight, multiple engines, and research change outcomes. Short signal blocks don't guarantee safety at high speed.

Spec Verification and Real-World Testing

Track 2.0 changes via official Wiki and English patch notes together. Wiki solidifies core rules; patch notes reveal what changed. Signal-rule overhauls don't appear in documented changes, so past knowledge mostly holds.

factorio@jp Wiki's layout examples and 2.0 notes are gold for Japanese readers. The "partition interior by route conflict" mindset beats fearful monolithic blocks.

Load-test by stressing intersections with trains until saturation. Low-density operation masks problems. Congestion surfaces real issues: exit space, stacker depth, merge handling. 2.0 interior chaining earns its keep here.

Stability is best judged by high-traffic behavior. Sound designs slow under load; broken ones halt abruptly. Interior partition shines here, but only atop solid exit planning.

Next Reading (Internal Links TBD)

Start small—a single T-junction. Then escalate. These topics deepen the foundation:

• Station design and stackers (lane depth, capacity).
• Chain signal patterns (entry, interior, exit use-cases).

Factorio's official Wiki (Train signals, Train network, Station design) and community layouts (Reddit, factorio@jp, jias.jp) host extensive diagrams and blueprints. When this guide links internally, those resources will feed the details. Begin with small test, full consist clearance check, then scale. That's the path.