Factorio Train Signals Basics | Normal/Chain and Blocks

In Factorio's railway system, normal train signals look only at the 'next block', while chain signals look further ahead to prevent trains from stopping inside intersections. Once you understand this distinction, intersection design, branching, and single-track layouts follow a simple rule: chain signals at entrance, normal signals at exit.

I spent about three hours stuck on a four-way intersection myself, hitting dead-end routing, trains stopping mid-intersection, and single-track deadlocks one after another. But once I reorganized the signals by role and repositioned them, every problem solved itself.

This guide is written for anyone who wants to diagnose "why things jam up" with an eye toward Factorio 2.0 and beyond. It walks through the fundamental rules and intersection design thinking using real examples.

Target Version and Prerequisites

Specifying the Target Version

This article primarily covers vanilla Factorio 2.0. If you're using the Space Age expansion (DLC or community-made large mods), check their specific mechanics individually. The core signal principle—dividing track into blocks with a limit of one train per block—is shared with the 1.x series. This guide mainly aligns with 2.0 UI and operational feel.

Assumed Skill Level

I'm assuming you've completed the tutorial and understand basic train scheduling. You've placed stations, set destinations in a train's schedule, and run a train at least once. If you're at that stage, you're ready. Conversely, if you haven't moved a train yet, signal issues may be overshadowed by station names and schedule behavior, making the content harder to follow.

Another crucial thing: knowing the longest train composition you'll use on your network. Many intersection and siding jams stem not from wrong signal types, but from "we placed signals assuming the train clears, but the tail lingers." In multiplayer, I always confirm the longest composition before touching someone else's track. Skipping this makes even correct-looking layouts behave weirdly in passing situations—messy and time-consuming.

This guide doesn't assume you already understand normal vs. chain signals; I'll fill that gap with examples. However, I skip over basic train UI, station naming, and schedule mechanics themselves.

Topics This Guide Does Not Cover

This section narrows scope to foundational block-cutting and intersection design in vanilla that keeps crossings, branches, and single-track from breaking down. Broader topics are outside scope.

Specifically, I don't cover circuit network coordination with trains. Station enable signals, reading, dynamic control via circuit conditions—these are fun, but safe signal-only flow comes first. Wrapping circuit logic around a chain-signal problem actually makes diagnosis harder.

Detailed stacker design is also separate. Stackers are a capstone of signal understanding, requiring you to think through entrance jams, each waiting lane length, and exit merging together. I stop at "how to cut blocks" and "keeping trains from stopping inside," the foundation stackers rest on.

I don't delve into UPS optimization. How finely to divide intersections, when to use single- vs. double-track, how many station heads to line up—these eventually touch UPS. But that's mostly a megabase perspective, a different goal from learning signal mechanics. Focus first on preventing gridlock and deadlock; design decisions stay clearer that way.

Factorio Signals: Only Two Types—Normal vs. Chain Signal Differences

Normal Train Signal Role

The normal train signal is quite simple. It looks only at the next block. If the block ahead is empty, it lets the train through; if occupied, it stops it. Start with that understanding and you're fine.

Factorio signals divide track into blocks, enforcing the rule that only one train can occupy a block at a time, preventing collisions. Normal signals serve as the basic divider, so they work well on straight sections and after a train exits an intersection. Placing them on the exit side of an intersection to push trains away keeps behavior clean.

Signal colors make sense here too: green means clear, yellow means the next block is reserved or about to turn red, red means blocked. Yellow feels like "proceed with caution," but it also appears when a train physically can't stop in time given its braking distance. When I work high-speed trunk lines, signal spacing is tempting to cram short, creating yellow lights everywhere and constant slowdowns. Even for a single locomotive, stopping distance from first principles is extremely long—sometimes hundreds of tiles—so normal signals can't be arbitrarily close together.

Conversely, placing a normal signal at an intersection entrance tends to cause "the next block is free, so I'll enter—but the way ahead is jammed, so I stop inside the intersection." Classic beginner failure. The signal isn't bad; its role is just different. Good at pushing exiting trains, poor at preventing mid-intersection halts. Splitting by role—entrance vs. exit—prevents confusion.

Chain (Linked) Train Signal Role

One thing worth noting about 2.0+ operations: intersections with finely subdivided interiors using chain signals work without major issues in most scenarios, increasingly per community experience. I've subdivided four-way intersection interiors by routing direction in 2.0 and found "internal division broke it" feeling much rarer than before. Multi-directional simultaneous passage can actually be smoother with internal splits.

However, this isn't a silver bullet. Special crossing conditions or high-density traffic can still jam if exit space is insufficient. No amount of internal chain subdivision prevents gridlock if the composition won't fit past the exit. The tail stays behind, starting deadlock. So 2.0 doesn't magically excuse sloppy internal chaining; rather, it makes the "don't stop inside" philosophy more practically viable.

The 'Factorio Railway Building from Zero: Linked Signals' post shows exit space shortage examples well. When I fix jams, I check "does this train have a place to fully stop after exiting?" before tweaking signal type. Honestly, that decides most cases more than chain placement itself.

One-Liner Distinction and Right-Hand Rule

My clearest one-liner: normal signals see only the next block; chain signals see ahead to the route and make trains wait before entering. That one sentence covers most of it.

In practice, "don't stop inside → chain at entrance; push exiting trains → normal at exit" cuts failures dramatically. Memorizing signal names gets muddled, but remembering where trains wait pulls everything into focus. I used to reverse them by name alone until I started thinking "where do I want this train to sit?"—confusion vanished.

Easy to overlook: the right-hand rule. Trains read only signals on their right side (direction of travel). Miss this and a signal looks placed but reads nothing, acting as one-way. The 'Train Signals Tutorial - Factorio Wiki' covers this as foundational.

This rule, modest as it seems, is genuinely critical. When I faced "no route" trouble, I'd only placed signals on one side. Two-directional track with signals on one direction's right means the opposite direction sees no signal at all. Adding the matching signals on the other side immediately opens routing. Happens a lot.

So this section's essence is simple: normal sees next; chain sees ahead; trains read right. These three facts let you diagnose "why did it stop?" pretty clearly for almost any setup.

Tutorial:Train signals

wiki.factorio.com

Block Mechanics: One Block, One Train—The Baseline

Signals Create Blocks

Factorio signals aren't just "go/stop" signs. They're block boundaries that divide track. The space between signals, or that one signal defines, becomes a block—into which only one train can enter at a time. Grasp this and "why is the train waiting ahead?" becomes much clearer.

The principle: signals manage occupancy authority by block, not direct train routing. In intersections, sidetracks, before stations—trains don't collide because of this rule.

I stumbled here first. I thought more signals = more flow. Actually, how you cut blocks mattered far more. Long blocks lock one train to a wide zone, jamming followers. Smart short divisions around intersections and station approaches let trains inch forward, smoothing gridlock. Tidying blocks alone can visibly smooth trunk-line flow.

But fine cutting isn't always right. Especially exit blocks of intersections or sidetracks—the train must fully clear before the next one reserves it. Short exits cause tails to linger in the intersection, blocking crossings. Once, I cut exits too fine for "gridlock fix" and made congestion worse. Subdivision works, but blocks must actually let trains sit and wait.

Signal Colors (Red, Yellow, Green) and Reservation Behavior

Normal train signals mostly check if the next block is free. Free → green; can't enter → red; in between → yellow. Treat this as pure "signal light pretty" and you'll get confused—train entrance reservation ties directly to color.

Tangibly, even an unoccupied block reserves ahead once a train's heading there, changing the signal state downstream. Normal signals show green while a block is empty but shift to yellow as reservation firms, then red as the train nears. This flow makes it clearer why "nobody's here yet, but it's yellow."

Yellow matters for high-speed runs. Trains can't stop instantly, so even reaching red within stopping distance, they pass through yellow anyway. Stop distance from first principles is several hundred tiles, so cramming normal signals in a long express line creates constant yellow—frequent slowdowns and re-acceleration. This is correct behavior, not a bug.

Chain signals extend this one step ahead. They see not just the next block, but the exit signal beyond, so if any downstream point is red, the chain itself turns red or yellow. Chaining at intersection entrance prevents "I can enter but not exit" crashes by halting at the source. Where normal signals ask "can I enter the next section?" chain asks "can I fully clear?" Think "exit-aware entry" vs. "entry-only."

Right-Side Signals and No Route

"Track connects but somehow no route"—a trap right after learning signals. Classic example: no signal on the train's right side (direction of travel). Trains read only right-side signals, so misplaced or left-side-only signals become invisible on that direction, acting as if nothing's there.

This creates "I meant dual-direction single-track" becoming "one direction signal-capable, reverse raw." Single-track's routing failure from signal direction mistakes is devastating. I caused "can't find station" states on sidetracks constantly by underestimating the right-hand rule. Once you know, it's obvious; visually, barely visible.

One-directional overlaid mid-dual-direction is another common failure. Main trunk built one-way; station and branch left semi-dual → routing breaks if signals disagree. One wrong-way signal ruins the whole path.

Further, even with correct signal direction, blocks themselves may choke exit: if exit blocks can't house the longest train, it partially clears, the remaining tail occupies the block, and downstream sees "can't reach destination" effectively. Block design, not signal type, breaks it.

Intersection/station trouble despite "correct-looking" signals usually means signal direction, block cuts, or exit length are off. I check these three and solve 90% of issues. Rather than signal minutiae, I track which block reserves and where trains can fully halt, making no route readable almost mechanically.

Start Here: Intersections Use Chain at Entrance, Normal at Exit

Why Chain Signals at Entrances

The bedrock of intersection design: chain inside and at entrance, normal at exit. This forms pattern wisdom across T-junctions, four-ways, and more. Role-wise: chain prevents mid-intersection stops by forcing waits at entry, normal flows exiting trains forward.

Chain excels at entrances because it sees not just "is the next bit free?" but "does this route fully exit?" Blocked exits turn the entrance red, holding trains before the intersection. Normal signals let "next block free" = "proceed," causing entry followed by stuck-in-middle gridlock. My infamous four-way failure had exactly this.

The official 'Train Signals Tutorial - Factorio Wiki' mandates chain entrance + normal exit as foundational. Not arcane technique—just tightening entry judgment while normalizing exit flow. The rule to anchor on.

Internal Intersection Subdivisions and Caution

Chain signals also cut intersection interiors, letting different routes run parallel and simplifying simultaneous passage. Reason: if multiple paths cross the same spot, subdividing by path smooths flow. Four-way intersections don't use a single giant block; instead, splitting right/straight/left prevents jam-prone mono-occupation.

Placement order: finalize exits first, then fill entrance and interior.

1. Place normal signal past the intersection
2. Reserve exit block length for waits
3. Chain signal immediately before entrance
4. Subdivide interior by route conflict if needed
5. Run multiple trains, check for mid-intersection stops

Finer subdivision doesn't automatically win. Earlier points emphasized blocks must accommodate waiting trains. Short interior fragments become useless without actual sit-space. My sense: congested intersections usually suffer "insufficient exit" more than "too-few interior divisions." Gridlock root often lies outside the intersection.

Community 'Train Network/Layout Examples - factorio@jp Wiki' shows intersection design hinges on "entrance chain + exit normal" plus interior splits matching route conflicts. Think "where train sits and which route unblocks" more than "how many signals look smart."

Train Network/Layout Examples - factorio@jp Wiki*

factorio@jp Wiki*

wikiwiki.jp

Normal Signal at Exit + Ensuring Wait-Block Length

Normal signals at exits push exiting trains to the next block plainly. Once past the intersection, "don't jam inside" matters less than "can the next section take it?" so normal fits the role. Entrance chain + exit normal pairs cleanly.

The real catch: exit blocks must hold the longest train completely. If only the head fits, the tail stays inside intersection, blocking crossing paths. Even perfect signal layout fails with short exit blocks. This is design error, not signal bug.

I changed reservation to longest-composition length plus a few tiles buffer, and the gridlock sprawl visibly shrank. Humble tweak, outsized effect. One-block-per-train means short exit blocks = tight design = jam-prone.

Same for T-splits and four-ways. Route exit normal first, measure trailing room from that signal's perspective, and size intersection around that. Exit placement determines entrance chain position naturally.

Usage by Single-Track, Branches, Double-Track Intersections

Bidirectional Single-Track

Bidirectional single-track halves rail spend versus dual-track, tempting in early-game resource scarcity or when extending to distant ores. Visually, single-track runs deep.

Operations, however, are brutal. Sharing one track between opposite flows means crossing management, not intersection mastery, is the core. By block rules, one train per block means no passing-siding → one direction waits for the other to clear, crushing throughput. Beginner-friendly? Not really.

Exchange sidings (passing sections) rescue single-track. Community layouts frequently show inserting one passing zone jumps usable train count by 1–2 trains, dramatically. Beats full dual-track cost and noticeably helps. I tacked ~50 tiles of siding onto a gridlocked single-track support line, enabling mid-line passing, and main-line jam lightened sharply.

Vitally, don't let trains queue at trunk/branch entrance. Most gridlock stems not from signal type but "trains wait in bad spots." Check jias.jp single-track or factorio@jp examples—single-track works, but prerequisites: passing-siding placement and length. Real tradeoff: appeal vs. difficulty. Very clear.

Branch Signals

Branches seem simple but signal-wise are sneaky gridlock sources. Logic mirrors intersections: chain before branch + normal at each exit as the frame. Trains enter, seeing "chosen route's exit clear?" If a branch is jammed, the chain turns red; traffic reroutes. Normal exits flow onward.

Why: chain looks past the immediate junction to each branch's exit, so if right branch is blocked, rightbound trains halt pre-branch, not inside. Normal would permit "next block free" entry even if branch destination clogs, snarling the junction and beyond. Classic mess.

I ran into this on T-junction support lines. A station backs up slightly, trains push into the branch fork, followers pile behind, even trunk gets blocked. Branches feel smaller than intersections; easy to overlook. Prevent-mid-branch-stops is exactly as critical as intersections. Place chain at branch entrance, normal at each exit branch, call it solved.

Branch design matters less on internal subdivision than on where you want trains to queue. Entrance chain fixes wait location upstream, normal exits push onward. Simple pattern, potent on branches.

One-Way Double-Track Intersection—The Stable Baseline

One-way double-track intersections are arguably the most balanced: stability + throughput. Splitting each direction into its own track, signal-reading organizes simply, routing becomes intuitive. Design clarity and single-capacity scales well. Complex? Much less. Complexity averted.

On such a setup, the chain-entrance/normal-exit pattern shines unchanged. Each direction has a chain at entry, normal at exit; internal chaining cuts by routing. Right/straight/left flows coexist neatly, bottlenecks obvious.

Single-track saves rail but starves throughput and adds hard signal work. Double-track burns rail yet offers direction separation, making the configuration almost foolproof. Multiplayer? Clarity is gold—other players understand it instantly. I default to double-track for large networks.

One note: high-speed sections demand unexpectedly long stopping distance. Ideographic calculation (using Unit wiki speed/accel values) suggests single-locomotive stop distance can reach roughly 280 tiles. This is a calculated estimate; real values shift with consist weight, multiple engines, and research. Short signal spacing can't overcome pure physics.

Common Failures and Diagnosis Steps

Symptom: No Route Breakdown

"Signals placed, train says no route" usually means signal-read mechanics break, not track integrity. I puzzled over connected rails for hours before realizing I'd wired signals wrong. Root causes cluster in a few places.

First: is there a right-side signal? Trains read right-side signals only. Left-only or reversed signals? That direction sees no signal—one-way unintentionally. Especially on symmetric intersections or single-track reversals, direction reversals hide easily. 2.0 has signal tweaks but nothing stating behavior fundamentally changed; suspect layout mistakes first.

Single-track especially: are both directions signaled as pairs? Bidirectional on one rail + signal pair only one way = accidental one-way. "One direction works, return gets no route." Dual-direction single-track needs signal pairs read from both angles. Missing either direction breaks routing.

Stations too: station disabled or name mismatches = no route despite correct signals. Multi-copied stations with off-by-one names, circuit-disabled stations left on—signals read fine but trains can't target. Spent 30 minutes repositioning signals; cause was station name typo. Humbling.

Diagnostic order: right-side signal presence/direction, then single-track signal-pair completeness, then station state/naming. Official Wiki precedent: right-hand rules and block-reading first. No route traces back to "how does the train see this?" nearly always.

Symptom: Mid-Intersection Stop Breakdown

Trickier: train enters, then stops inside. Signal colors alone confuse; culprits narrow sharply. Usually: exit block too short, exit backlog, or entrance is normal-signal (wrong call).

Most common: exit block can't house the full train. Head clears intersection, but tail lingers inside. This blocks crossing routes and chain-reacts. jias.jp examples nail this; own four-way learned it painfully when I swapped to longer trains, left exit unchanged, and caused paralysis. Tiny overhang, massive operational breakage.

Second: exit-side already gridlocked. Intersection entrance should chain-red if nothing can exit, but normal signals let "next block free" = "enter anyway," causing mid-intersection stop. Entrance type and downline jams combine badly. Mid-stop → all directions entangle.

Key check: does stopped train have safe wait-space downstream? If not, the intersection structurally jams. Before chasing signal type, expand exit. Intersection troubles usually hide outside the intersection itself.

Spotting: is the stop inside-intersection or pre-entrance? Inside suggests signal type or exit-space issues; outside suggests chain is working (holding appropriately). Design remedy: extend exit or untangle downline. Intersection-focused fixes often miss the real problem.

Symptom: Single-Track Deadlock Breakdown

Single-track head-to-head standup freezes not one pair but entire chains. Diagnosis splits into causal layers.

First: insufficient passing sidings? Too few = trains peak capacity, dead-on collision. Adding one siding jumps capacity by 1–2 trains often. Sidings exist but jams still occur = siding placement fails to intercept trains before they meet headlong. Trains must naturally detour before simultaneous block-entry. Bad positioning = useless sidings.

Second: single-track entrance lacks chain signal? Pushing trains into single-track with normal signals, ignoring downstream, forces train into interior. Interior becomes waiting-ground = interior blocks become jams. Single-track demands entrance chain more rigidly than intersections—look-ahead matters acutely.

Deadlock signature: siding present but trains stop just before it each time → pre-siding signal position error, allowing simultaneous entry. Sidings created but short/un-reached → block-capture by composition + composition not fully in siding. Siding "exists" != "functions."

Experience: single-track jams = routing + waiting-place design, not signal type. Public Wiki's rationale for beginner double-track recommendation is that signal-read misses here surface fast. Single-track, design mistakes explode visibly.

Deadlock Dissolve and Recurrence Prevention

When stuck, rather than raze everything, parse where trains queue structurally, step-by-step. My actual go-to:

1. Verify right-side signals exist and face correctly

No route and one-direction blockage often hide here; T and single-track folding are typical blind spots.

1. Check exit block length and congestion

Do tails linger mid-crossing? Is downline backpressure present? Exit-side jams root most mid-stop failures.

1. Confirm entrance-side chains (not normals)

Normal-signal entrances let trains into bad situations; fix it first for mid-crossing symptoms.

1. Single-track: review siding count and position

Deadlock = too few sidings, poorly placed, or interior-pushing entrances.

Actual gridlock needs emergency unblock: briefly remove a central signal or manually shift one train, declogging the cascade. Move only the gridlock center, not everything. Usually one train clear → domino-return. Over-shifting creates new jams.

Post-unblock: identify root cause, re-signal, test. Left-right signal swap, single-track pairing, exit-length boost, siding repositioning. Methodical fixes prevent re-jam better than "got lucky."

Wiki's signal tutorial and jias.jp specifics (exit shortage examples) are resources. Symptom-by-symptom parsing — "where's the stop?" — solves most. I'm far faster at fixes since asking "does the train have exit room?" first, before tweaking signal type.

Factorio 2.0+ Awareness

Subdividing Intersection Interiors with Chain—Viable?

Factorio 2.0+ interior chain-signal subdivision behaves quite stably across most scenarios, per community experience. I've finely cut four-way interiors by routing in 2.0, and "oops, internal chaining broke it" became less present. Community consensus leans stable, mostly concern-free, barring rare edge-cases.

Key takeaway: subdivision is now more reliably practical, not a universal fix. Chaining's inherent look-ahead aligns well with route-specific blocking. Intersections respond better. This isn't "2.0 broke per-signal logic;" it's "2.0 environment makes the principle easier to apply."

Real caveat: deadlock sources didn't vanish. Exit-space shortage and short holding-blocks remain culprits. 2.0 enables internal chaining; it doesn't magic away structural undersizing. I once finely chain-split 2.0 intersection interiors but starved exit stacker—next junction blocked the whole grid. Intersection signal-craft looked smart; reality was exit-side storage too tight. Smart entrance ≠ unblocked if exit can't receive.

Density edge-case: simultaneous multi-direction assault on a subdivided intersection. Fine chaining lets non-competing routes coexist, neat initially. But if exit-side clogs en-masse, internal microzones become waiting-area Frankenstein rather than flow. Theory vs. gridlock-under-load can diverge.

Plus, high-speed trunk lanes into intersections. Stop distance (calculated as ~280 tiles single-engine) is theoretical floor; real values vary with consist, engines, research. Short block stacks won't absorb that physics.

Special Cases and High-Load Caution

2.0+ changes visible in official 2.0 patch notes center on bug fixes and UI, not sweeping signal-core rewrites. So real-world tuning still hunts exit real-estate and waiting-block viability.

I test designs by stressing them with high train density, not just smooth-flow ease. Low-count grids hide issues; volume runs surface them. Intersection looking "signal-wise sound" yet hanging under load? Likely exit/stacker undersizing. This split between "math looks right" and "gridlock occurs" is the real frontier.

Spec Confirmation and Hands-On Testing

For 2.0+ intel, pair official Wiki train-signal pages with English patch notes. Wiki solidifies baseline mechanics; notes reveal contemporaneous fixes. Signal-related updates exist; signal-core overhaul isn't evident from available records, so community observation and personal testing guide design choices.

Factorio@jp Wiki's layout examples and 2.0 notes are invaluable. Especially "interior subdivides per route conflict" philosophy beats blanket fear of internal blocks.

Test under congestion, not calm flow. Light traffic hides flaws; peak demand exposes waiting-space shortfalls and exit failures. Good design handles crowds by smoothing, poor design by jamming. Inspect gridlock mode, not smooth-sailing mode.

Practically, high-load stability > pretty empty-world operation. 2.0 doesn't excuse sloppy design; it makes thoughtful design easier to deploy.

Next Topics to Explore (Internal links TBD)

Start small—test a T or four-way yourself. Follow these sequentially:

• Station design and stackers (waiting lanes and holding capacity)
• Chain signal placement patterns (entrance/interior/exit role-splits)

Official Factorio Wiki (Train signals, Train network, Station design) and community examples offer extensive diagrams and blueprint examples. Once site articles expand, internal links will be added. Begin small, verify exit capacity, iterate. Focus beats perfection.