【Factorio】How to Choose Railway Intersections (2.0 / Space Age Compatible)

In Factorio 2.0, railway intersection flow changes dramatically based on "what to choose for your factory scale" and "how to place signals," more than the shape itself. This guide is written for beginners to intermediate players wanting to learn how to distinguish between T-junctions, cross intersections, roundabouts, and elevated rails, based on vanilla and Space Age mechanics in the UK gaming community.

I once made the mistake of building a cross intersection right after upgrading to double rails, leaving it as a single block—trains could only pass through one at a time, causing endless gridlock. Simply dividing the interior into four blocks and following the basic rule of chain signals at entry and normal signals at exit dramatically improved flow. This taught me that intersections are really about "waiting-free design" rather than "choosing the biggest shape."

By the end of this article, you'll be able to choose an intersection that matches your traffic volume and build at least one deadlock-free design with confidence.

Prerequisites for Factorio Railway Intersection Design: Fix Train Length and Direction First

Standardise double-rail direction across your entire network

Before considering intersection shapes, fix whether you're running single or double rails and whether you're using right-side or left-side traffic. This guide assumes Factorio 2.0 vanilla and Space Age. Older railway articles and outdated images often mix v1.x mechanics, and it's safer to avoid reading 2.0 rail specification differences directly.

Single rails save track materials and suit early temporary routes. However, oncoming traffic management and signal design become dramatically harder, and the moment traffic increases, you're stuck with constant meeting waits. Intersection design shifts from "how to safely pass trains through both lanes" to "where do we stop opposing trains in the first place?" Honestly, I expanded my factory on single rails, then had to redraw all the tracks for double rails later. If you want stable intersections, double rails from the start are easier.

If you use double rails, standardise right-side or left-side traffic across your entire network. In Factorio, stations and signals are typically handled assuming right-side placement relative to direction of travel, so right-side traffic is more convenient for UI in-game. When this mixes by base, you get exceptions at every branch, merge, and station entrance, making design templates hard to reuse.

In 2.0, rails went from 8 directions to 16 directions, significantly increasing signal placement freedom on curves. Older articles sometimes state "you can't place signals on this curve" or "this branch needs spacing," but some of those situations have changed in the current environment. However, this improvement degree varies by environment (MODs, map settings, specific placement), so checking actual effects in your own save is recommended. Some player reports show branch/merge manoeuvrability has improved, but it's not universally applicable to all cases.

Defining and measuring longest train composition

After direction comes defining the longest train composition running your network. For example, if you standardise on a 1 locomotive + 4 cargo wagon 1-4 composition, all subsequent intersection sizes, station stop positions, and waiting block lengths are determined by that. Starting without this clarity leads to mixed compositions like 1-2, 1-4, and 2-8, resulting in weird breakdowns where signals are correct but trains jam.

With intersections especially, visual compactness matters less than "does the longest composition fit?" The 'Tutorial: Train signals - Factorio Wiki' section also establishes that block length should match the longest train on your network. Often when flow is poor despite correct signals, the root cause is composition length miscalculation, not the signals themselves.

The simplest method is building your actual composition in-game and using its occupied length as the standard. Here, the [Factorio Wiki: Rail] fact that rails are placed in 2-tile units becomes genuinely useful. When fine-tuning intersections and block lengths, thinking in 2-tile increments keeps designs stable. I've adjusted blueprints without this awareness, leaving the exit block oddly short—numbers looked sufficient, but actual track placement had accumulated rounding errors, with the rear carriage stuck in the intersection.

The longest composition here means the maximum possible composition on your network, not your typical composition. If you run long ore trains and short liquid trains, the intersection should accommodate the longer ones. Intersections are shared infrastructure—if only some long compositions break the rules, the whole system stops easily.

Tutorial:Train signals - Factorio Wiki

wiki.factorio.com

Standardising block length and post-exit waiting space

With longest composition defined, use that length to standardise block length and post-exit waiting space. Intersections use chain signals at entry and normal signals at exit as standard, but this only works if "there's enough clear space for the train to fully exit." Short exit blocks mean the front clears while the rear stays in the intersection, blocking all other directions.

The standard is straightforward: intersection exit blocks must be long enough to fit the longest composition completely. In other words, don't leave the rear in the intersection. Adding a stop margin helps prevent jamming in practice. Beautiful cross intersections and roundabouts fail instantly without this condition, devolving into deadlock-like behaviour.

This applies equally to T-junctions, crosses, and roundabouts. Interior block-splitting designs for increased throughput are easier in 2.0, but if exits jam, you can't leverage those benefits. Think of interior splitting as acceleration and exit length as foundation—that framing keeps things organised.

Note: Space Age added elevated rails reducing planar intersections, but even elevated approach/exit sections retain waiting block logic. Elevated isn't a complete solution—rather, fix "where does the longest composition fit" first, whether planar or elevated. That's the foundation for stable operations. Once locked in, intersection type selection shifts from "I like this shape" to "can this exit accommodate composition length?"

Main Railway Intersection Patterns: T-junction, Cross, Roundabout, Elevated

T-junction: Strong for branch connections

T-junctions are most convenient for bumping branch lines into main lines—ore bases, oil outposts, that sort of thing. Space requirements stay small-to-medium and fewer branching directions mean much easier handling from early to mid-game. I still prefer T-junctions for initial placement, connecting new mining branches to trunk lines. Keeping essential branch and merge clean makes track routing straightforward.

Signal complexity is moderate. Following basics: entry is chain signal, exit is normal signal, preventing trains stopping mid-intersection. T-junctions have fewer route combinations, making interior blocks more intuitive than crosses. 2.0's curve signal placement improvement simplified branch/merge setup considerably. Old designs look cramped but now assemble more naturally—many cases work where they couldn't before.

Simultaneous passage ease is moderate. Branch-to-main transitions and main line straight-throughs separate cleanly and flow, but insufficient exit space jams immediately. T-junctions compress easily, but spacing them closely makes them effectively combine into one large intersection. Compact appearance hides giant traffic dynamics—definitely a common pitfall.

Suitability: excellent early-to-mid game, remaining viable large-scale as "branch ingestion" but different at main-line crossing points. Mid-game ore branch additions work fine with T-junctions, but main-line intersections need different solutions. 2.0 handles T-junctions very smoothly; Space Age keeps them viable for ground connections without elevated rails.

Cross intersection: Main line connections. Interior block division is key

Cross intersections are the main choice for connecting main lines. East-west-north-south flows demand main network backbone where T-junctions can't cope, making crosses necessary. Space requirements are moderate, signal complexity moderate-to-high. The shape seems obvious but 1-block builds completely fail. My initial gridlock was exactly here.

Cross intersections critically need proper interior subdivision. Different routes become separate blocks, and non-colliding paths allow simultaneous entry, boosting throughput beyond waiting-one-by-one. For example, if straight-through paths and some turns don't interfere, you escape single-train bottlenecks. Simple in theory but tricky practising "which paths must stay together?"—crosses show interior design differences clearly.

The factorio@jp Wiki has placement examples (e.g. https://wikiwiki.jp/factorio/%E5%88%97%E8%BB%8A%E3%83%8D%E3%83%83%E3%83%88%E3%83%AF%E3%83%BC%E3%82%AF/%E9%85%8D%E7%BD%AE%E4%BE%8B). However, older images and obsolete techniques mix in, so post-2.0 safer approach: reference block division thinking rather than copying layouts.

Simultaneous passage ease is high among the four types. Proper cross interior division handles main-line traffic reliably from experience. Main-line gridlock reduction came from block organisation—waiting queues shortened when subdivided. Appearances deceptively size independent of actual throughput.

Suitability: mid-game onwards, especially large-scale. As stations and train count climb, avoiding crosses becomes impossible. 2.0 vanilla makes them strong primary infrastructure; Space Age keeps them vital for ground main lines. Even elevated-capable setups keep ground crosses refined for efficiency—not everything needs elevation.

Roundabout: Easy to understand, but traffic growth exposes limits

Roundabouts offer low-to-moderate design complexity, making intuitive sense and working first-try. Space requirements are moderate; combining branches, merges, and turnarounds into one shape is beginner-friendly. Community examples treat them as standards, and assembly feels confidence-building—"this just works."

However—crucial misconception here—clarity and throughput capacity are separate things. Roundabouts famously resist congestion, but when traffic rises, the loop itself becomes bottleneck. Handy early-game but struggling large-scale is typical. I assumed "this handles everything" initially, then late-game increased trains filled the loop until I rebuilt from scratch multiple times.

Signal placement stays more intuitive than crosses, but interior block division matters for roundabouts too. Single-block loops only pass one composition before others wait, killing loop efficiency. Over-splitting wastes space; insufficient exit space clogs the middle. Looking circular doesn't bypass fundamental intersection logic: "hold at entry, release clearing vehicles at exit."

Suitability: high early-to-mid, moderate large-scale. Small networks, multi-direction flexible connections, turnaround incorporation: excellent. Main-line traffic cores struggle under growth, though. 2.0 improved ease, not universal strength. 2.0 doesn't make roundabouts "problem-solved"—easier assembly doesn't fix congestion concentration.

Elevated intersection: Space Age exclusive. Plane separation simplifies management

Elevated intersections offer Space Age-exclusive vertical crossing options. The primary advantage: reducing planar line intersections, simplifying management logic. Rather than controlling collision complexity with signals, "prevent collision happening" solves problems easier. With fewer planar crossings, simultaneous passage gets high ratings; outlook improves versus ground intersection management.

Trade-off: space requirements increase, structure complexity rises. Planning elevation choice, ground station integration, escape routing demands broader design thinking. Not simply "ultimate intersection"—rather, reshaping operational philosophy "collisions don't occur" instead "manage collisions."

Suitability: mid-game onwards, especially large-scale. When traffic climbs past ground-handling capacity, elevation resolves problems. AUTOMATON coverage showed elevated rails addressing player-struggled management, clearly validating the mechanic. Larger networks gain "prevent collision" over "handle collision" efficiency.

2.0 vs vanilla difference clarifies here. 2.0 raised ground rail freedom; 2.0 doesn't include elevation. So 2.0-improved ground intersection and Space Age elevation option evolve separately. 2.0 vanilla baseline: ground T/cross/roundabout mastery; Space Age addition: "don't intersect" option next level. Comparing 'Rail - Factorio Wiki' and 'Train network/placement examples' shows this difference clearly.

Rough pattern-use comparison:

(Note: Chart summarises general tendencies, not strict performance rankings under identical conditions. Actual intersection throughput varies significantly with rails (length, curvature), signal granularity, composition length, operation patterns. Plan using chart guidance, but verify in your signal configuration.)

Rail - Factorio Wiki

wiki.factorio.com

Signal Placement Fundamentals: Chain at Entry, Normal at Exit

Normal vs. Chain signal differences

Core intersection signal rule: chain signals at entry (line source), normal signals at exit (destination). This applies T-junction through roundabout, fundamentally preventing mid-intersection deadlock rather than collision, hence key.

Normal signals check whether the immediate forward block is clear. Clear? Train enters. So even if exit backs up, trains push mid-intersection and stop there. Problematic because mid-car-bodies block cross-directions easily, strangling other flows.

Chain signals check clearing-likely prospects including downstream routes before entry. "Only clear trains proceeding to exit" basically. Entrance repositions outside intersection. Looks like waiting but recovery speed differs hugely—mid-blocking makes later trains deadlock unavoidably; outside-waiting preserves alternate path flow. Major practical difference per 'Tutorial: Train signals - Factorio Wiki'.

I started with normal entry signals, watching trains halt mid-intersection, other directions blocking each other mutually. "Signals exist, why nothing works?" caused confusion. Switching entry to chain stopped mid-intersection occupancy instantly. Gridlock vanished. Theory-before-building differs—felt-understanding followed seeing results. Perfect alignment with tutorials.

Interior subdivision allows simultaneous passage

Entry chain/exit normal improves safety significantly, but growing traffic introduces interior block subdivision benefit. Treating whole intersection as one closure means waiting despite open routes—single entry stops all others. Huge-looking crosses still force single-train passage, defeating purpose.

Subdividing interior by collision patterns creates multiple blocks—non-colliding routes pass simultaneously. Independent right-turns or separate exit paths become separate blocks, permitting concurrent entry. Theory sounds obvious but practically tricky—where conflicts, where separation work?—showing interior design variation across attempts.

Same thinking applies roundabout-through-cross. Important: conflict points and separation potential expressed through signals. Previous-section "single-block cross fails" originates here. Proper sections shorten occupancy time, lightening downstream pressure.

2.0 curve signal flexibility enables fine subdivision previously impossible. Designing reveals "small signal shift enables separate block?" discoveries often, changing passage feel despite minor visual difference.

Minimal configuration example

Simplest setup: chain at all intersection entries, normal immediately post-exit. This alone cuts mid-intersection accidents dramatically. I always start new intersections minimal before fine-tuning internally—full interior subdivision immediately obscures conflict visibility otherwise.

Once passing, add interior signals separating non-colliding routes for more throughput. Critical: interior additions don't compromise entry-chain/exit-normal skeleton. Reverting entry to normal resurrects mid-stopping despite subdivision—signal advantage collapses.

Actual layouts require exit-space train-composition accommodation. Undersized exits leave rears hanging mid-intersection despite front clearance, wasting subdivision gains. Intersections plus post-direct straight must both "train clears completely" for signals working correctly.

Minimal's unglamorous but foundation-critical. Failures here break all patterns. Conversely, respecting this stabilises T through roundabout through cross. Signal confusion? Revert minimum baseline fastest resolution ever.

Pattern-specific construction and suitable contexts

T-junction basic procedure

T-junctions work main-to-branch or branch-to-main best—mining, refining, supply outposts. Preserving main flow while side entry/exit works perfectly. I expanded steadily through T-junction branching, finding stability versus main-junction spamming. "Fewer route conflicts, readable jam patterns" explains the reputation better than simplicity alone.

Construction: first, preserve main straight while single-side branch merges/splits. Then apply earlier-noted basics: entry judges entry, exit cuts blocks. T-junctions compress easily, making post-exit waiting space overlooked-critical. Branch entry, main-redirect both jam exit immediately, cascading mid-section collapses.

Subtle-huge: don't space T-junctions too close. Small-individually doesn't prevent series-cascade collapse. Composition-rear hangs next intersection, actual behaviour becomes giant combined structure. I've done this repeatedly—compact visual hid complex actual behaviour, single-direction gridlock spreading everywhere. Branch additions tempt dense placement; spacing by composition-length+ prevents cascade, sometimes requiring elevation separation.

Cross intersection basic procedure

Crosses are main-north-south-east-west connectors par excellence. Network core growth requires crossing sizes T-junctions can't handle. Complexity rises but properly-built crosses handle massive flow.

Crosses fundamentally need interior subdivision. Never lock to 1-closure. Competing routes require separation—non-interfering paths deserve simultaneous entry. 2.0 curve flexibility enabled fine-splitting previously cramped.

Overlooked: generous post-exit block length per composition. Crosses focus on center precision but outside-clearance matters hugely. Rear hanging mid-intersection despite front-exit wastes subdivision gains. Self-experience: composition-length exit spacing made stable—appearance seemed larger but "fully exits" attitude stabilised dramatically.

Examples like 'Train network/placement examples - factorio@jp Wiki*' help visualisation, though older designs mix in. Post-2.0, reading block-division thinking rather copying works better.

Successful crosses: "large complex shape" versus "conflict-reduced proper-exit form"—latter proven stronger. Main-line suitability roots here.

Train network/placement examples - factorio@jp Wiki*

factorio@jp Wiki*

wikiwiki.jp

Roundabout division examples and limit signs

Roundabouts score easy-design, relatively less-congestion, attracting confidence. Routing escape loops, combining turns-and-straight into rings, plus early-success experience makes them beginner-excellent. I initially found roundabouts easier than crosses' signal mechanics. Merging direction combinations intuitively appealed.

However, roundabouts aren't universal. Light traffic flows beautifully; increased trains make the loop itself competing-resource where few trains block many. Small-traffic advantage doesn't guarantee large-volume capacity. Missed distinction causes late-game discoveries: all trains queuing pre-loop, exits similarly blocked, hard-to-fix gridlock.

Interior subdivision means loop non-monolithic—between entry/exit, cut multiple blocks. Non-interfering routing runs better parallel. But endless subdivision doesn't scale—undersized blocks, jam-exits still bottleneck, wait-waves propagate outside anyway. Roundabout strength: "held trains stay outside, exited trains don't re-block" matters versus interior tweaks.

Limit signs: same-direction continuous trains jam inner-loop permanently, recovery impossible. Experience: initial roundabouts holding until growth, traffic-spikes filling loop solidly, saturation spreading everywhere. Conversion to subdivided crosses with extended exits restored main-line flow. Roundabouts never sustained serious trunk loads became clear—excellent support, main-heart unsuitable.

Elevated (vertical) layer-split patterns

Elevated intersections offer Space Age-exclusive vertical crossing, reshaping design philosophy. Base pattern: ground main-flow, upper cross-flow. East-west ground straight-through high-volume, north-south top level, busiest direction non-stop-possible. Alternate approach: high-density entry/branch merge overhead, ground simple. Strategy: high-volume direction non-stop, rest managed staggered.

Area and footprint increase. Elevation approach/exit remains signal-managed, not magic-free. Plane cross complexity versus plane-reduction simplicity improves stability significantly though. Ground ten-way intricate subdivision becomes space-efficient layer-separation.

Large networks gain clearest elevated advantage—collision-prevention beats collision-handling eventually. Elevated costs area, whole-network design demands rise, but major-line stability far exceeds planar-maximum agonising. Earlier plateau-reach versus endless ground-tuning appeals.

Elevation isn't "other intersections' superior version," but plane-reduction operation-change—different evolution. 2.0 ground-freedom improvement and Space Age elevation parallel progression. Combined thought: 2.0 polished ground fundamentals, Space Age adds structure-separation option.

Common failure patterns: deadlock, short blocks, too-near intersections

Mid-intersection stops causing configuration

Beginner-cardinal: entry normal-signal with 1-block interior. Trains judge "entry possible" and push in, exiting-backed trains stop mid-intersection. Cross-directions also block mutually, rapid cascade-failure. Early confusion: "signals present, everything stops?" remained unexplained until basics clicked—I struggled genuinely.

Occurs T-junctions through crosses. Branch-merge overlapping especially: front half-in, stops, rear blocks-behind, following trains compound, network-wide cascade. Instant improvement: chain entry basics prevent mid-intersection blocking. Post-exit subdivision enables parallel non-colliding passage.

Overlooked: stations and signals assume right-side, entry-side oriented. Reversed placement breaks logic despite appearance—some directions don't regulate, wrong-stop stations, unintended waits. Single-rail dual-direction especially risky, cardinal-point instruction loss causes "seemingly placed but non-functional" failures commonly.

Exit-block inadequacy recognition and correction

Intersection-clear gridlock-ongoing suggests exit-length insufficient. Textbook: front clears, rear remains mid-intersection—view half-out illusion. Block-occupation persists, strangling opposites. "Intersection exited but total-block-stops" frustration.

Visual: congestion halted composition rear-position. Rear over-intersection means length-insufficient. Cure: extend exit past composition-length-complete clearance. Not signal placement—mere post-stretch solves it. Did this repeatedly: interior-fiddling yielded nothing, exit-extension magic. Wiki fundamentals—composition-per-block, rail 2-tile-unit basis—solve half-understood problems easily.

Adjacent-intersection cascade-gridlock and spacing guidance

T-junctions easily space tightly, inviting another classic failure: short-spacing becomes large-composite-intersection. Individually-small paired placement masks giant-structure behaviour. Composition-rear hangs next-branch, actual dynamic: separate-logic single-mega-intersection. Partial-first-output blocks next-entry, cross-directional-join, cascade-collapse follows.

My worst failures matched this. Three-adjacent T-junctions compacted, single-direction continuous trains occupied-multiple-branches, mutual-blocking everywhere. Visual "two small T-junctions" hid mega-intersection behaviour. Solution: composition-length-plus-spacing minimum, alternatively, elevation-separation. Plane-saturation-beyond reached, structure-splitting outweighs plane-refinement eventually.

2.0 enabled tight placement theoretically, but practical-saturation unchanged. Rail 2-tile-unit basis makes compressed-appearance space-deceptive easily, practical-output-space disappears underestimated. Compact visual = risky actual design.

Single-rail operation limits and double-rail conversion points

Single-rail attracts early budget-wise, easily route-wise, running early-expansion perfect. Once-increased, single-rail opposition-meeting-waits hit hard. Exchange-points or sidings inadequately manage bidirectional control. Transport falls—reason: line-single not just, but meet-point bottleneck.

Single-rail also punishes direction/station orientation-errors hard. Right-side-orientation convention means dual-direction mismatched-setup breaks. Single direction correct, opposite fails—station non-stop, unexpected-waits. Understanding-before-trouble avoided these completely.

Mid-scale upward, double-rail conversion-intention beats single-rail persistence. Separated directions restore signal intuition, intersection logic simplifies. Single-rail succeeds limited-branches, low-throughput. Main-routes, multi-station full-network: double-rail outweighs patience. Gridlock-cascade hits single-rail harder, rebuilding-cost higher than foreseen-doubling. Practical-sense: growth-point, exchange-expansion versus double-conversion: latter-ease recognised myself.

What Changed in Factorio 2.0 / Space Age

2.0's 16-direction shift and signal placement freedom increase

Factorio 2.0 refined rails 8-direction to 16-direction. Appearance-change disguises intersection-design impact significantly. Major: curve-signal placement massively expanded. Previous "perfect-spot-curve-impossible" frustration reduced enormously. Pre-2.0 awkward curves spawned workarounds, 2.0 enables intuitive placement.

Most-benefit personally: cross-intersection interior subdivision. v1.1 curves blocked desired-signal-cutting, forcing wide 1-block sections frustratingly. 2.0 curve-following signals permit non-colliding-route separation previously impossible, interior-design logic finally-buildable. Curve-intuitive signals—previously constrained—unlock subdivision previously-theoretical.

''Zero-start Railway Construction (Convenience Features Edition)'' acknowledges 2.0 foundation-shifts. Copy-pasting old designs obscures "wide-spacing necessity" understanding when old-version-constraint actually-existed. Recognising historic-need explains seemingly-excessive spacing: v-1-era workaround, not universal-law.

2.0's branch/merge handling improvement

2.0 quietly pleasured: parallel-line branch/merge takeaway-ease boosted. v1.1 required huge spacing, simple connections consumed areas wastefully. Mid-section inter-parallel-track operations impossibly wide, awkward-roundabout results inevitable.

2.0 relaxed constraints—gaps no-longer-prohibitive for branch/merge. Station connections plus main-return, main-escape: previously-cramped now-accommodates. Practical: prior "here's impossible, detour" routing now-direct. Intersection-preceding assists-downstream configuring naturally nearer, tight-intersection-avoidance-friendlier, jam-resistant forms encouraging.

Subjectively, 2.0 design-time plummeted. "Parallel-spacing restrictive, line-routing impossible" redraws dropped markedly. Precision-intersection crafting versus obvious-routing availability—latter matters operations-wise. Old technique: foundation remains, layout-direct-reading surpasses pixel-exact-following post-2.0, thinking-read guides better.

Space Age's elevated rails

Space Age introduced elevated rails. 2.0 plane-improvement diverges, prevents-intersection entirely philosophy enables elevation. Post-October-2024-release, ground-crossing-reduction, up-down-separation feasibility changed network-capacity concepts.

Elevation strength: signal-mastery outweighs conflict-elimination. Ground cross-intersection-regardless retains collision-points always. Elevation sorts main-straight ground-vertical, support-side main-staggered—logic cleanly-separates. Traffic-volume-increases show this difference starkly.

Personally, elevation-comfort came from "untangling-gridlock" rather "managing-mess." Ground plural-main-lines merged always-bottleneck-somewhere. Elevation separation discharges formerly-conflicted trunk-instantly-organising. Large-factories expanding-core solidifies this single-move: mixed-plane-impossible-above, elevation-native-obvious.

[AUTOMATON-elevated-coverage] popularity makes sense—waiting-community feature-delivery satisfaction. Railway-centric players particularly value this. Big-networks gain "no-jam-structure-design" advantage over "jam-control-mastery," precisely elevation-offer.

Factorio DLC Allows 'Lifting Tracks.' Highly Anticipated Elevated Railways Finally Arrive - AUTOMATON

Developer Wube Software announced Oct 2 that Factorio's expansion "Space Age" will implement elevated railways, long-awaited by fans.

automaton-media.com

Old-article difference-reading translation points

Consulting older railway guides, clarify 2.0-vanilla versus Space Age context matters. Confusion risks "necessary-now?" and "why-so-wide?" judgment confusion.

Especially reread: curve signal-configuration, parallel-line spacing-width. Former 16-direction-shifts changed, latter 2.0-improved, meaning historic-optimal no-longer-mandatory cases rose. Previous-generation "we-had-no-choice" cramping and detours aren't currently-essential—recognising old-era-constraint origins eases understanding.

Conversely, elevated-rail examples are Space Age-specific. 2.0-improvement confusing elevation-together risks misunderstanding. Structured: 2.0 ground-rail-enjoyment-upgrade, Space Age ground-limitation-structural-leap. 'Rail - Factorio Wiki' baseline keeps distinction clear.

Practically, 2.0 curve-signal freedom significantly-improved