Getting Started with City Block Expansion in Factorio | Size and Signaling

When your main bus gets too bloated and you can't see where to add what anymore, it's time to consider transitioning to city blocks. This guide walks intermediate players through concrete steps to switch to a factory that's easier to manage and simpler to expand, covering vanilla Factorio 2.0 and Space Age environments.

The key is not to build a massive rail network all at once. Instead, lock in four things first—block size, train length, traffic direction, and intra-block logistics—then get to the point where you can cleanly replicate at least one complete block. This turned out to be the most stable progression I've found.

When I was running over 100 train stations, I got stuck for 3 hours due to trains stopping at intersections and stacker shortages, forcing me to almost completely redesign. City blocks aren't a magic cure for UPS issues, but if you set your rules before building, you can create a factory that holds together much more realistically during expansion.

Prerequisites and Target Versions for This Article

The baseline for what follows is Factorio vanilla v2.0 stable (around 2.0.73) and the Space Age DLC environment. The core focus is vanilla city block design, with Space Age additions and conceptual differences separated into their own section. Splitting this out early keeps "the fundamentals that work in vanilla" and "advanced applications from DLC" from getting tangled together. Honestly, I made my design scatter way more when I tried fitting all new features in from the start.

In this article, city blocks refer to a design philosophy where you lay down a regular rail grid, then fill each cell with production modules and build outward. The key is to treat this as a method for manageability and expansion ease, not as a dedicated UPS-first design like you see in the megabase community. Confusing these two leads to "it didn't come out as light as I hoped."

For dimensional discussion, I'll assume map chunks are 32×32 tiles as partitions. Following Map structure, aligning grid or block edges to multiples of 32 makes blueprint replication and adding another row much easier. That's why 96×96 setups are so common—they mesh perfectly with this approach.

Quick Terminology Notes

I'll standardize some terms here. Main bus is a thick belt trunk line where resources flow for expansion. It's very strong from early to mid-game, and the typical flow—eventually graduating to train-centric city blocks as the factory grows bigger—is really common.

UPS stands for Updates Per Second, a rough metric of game tick throughput. Factorio targets 60, and when it drops, you feel it in responsiveness. When I mention UPS, I'm talking about that processing load, not vague "feeling heavy."

Chained signals (or chain signals) are used at intersection entrances and let trains proceed only when the exit path is clear. City blocks tend to have lots of intersections, so getting comfortable with this term makes the later explanations much easier to follow.

→ See also

For chunk fundamentals, Map structure explains it cleanly. Space Age's scope is covered in Space Age. I'll pull only the essentials from there and keep the design philosophy grounded in vanilla.

Map structure

wiki.factorio.com

What Are City Blocks in Factorio?

City Block Fundamentals

City blocks in Factorio mean laying down a regular rail grid first, then treating each cell as an independent production zone you expand horizontally. Instead of running the factory along one long trunk, you divide it by role—"smelting block," "circuit block," "science material block"—and add identical copies when you need more. I see this less as the ultimate solution for megabases and more as a practical system to keep humans from getting lost during expansion. It's much easier to spot where something needs to go.

The foundation is rails, intersections, stations, signals, and blueprints built for replication. Because Construction plans exist, once you build one block cleanly, you can just keep placing the same shape. This is the satisfying part of city blocks—you don't redesign the layout every expansion cycle. Back in the main bus days, I'd lose half a day just reworking splitters and intersections; with blocks, it became "production ran out, so add another identical block," which lightened the decision load massively.

In practice, people often align block dimensions to chunks. Maps are divided into 32×32 tile chunks as covered in Map structure, so 96×96-based blocks are the textbook example for easy positioning. But there's no single right answer. Some run tighter 64-tile grids; others use 100×100 or thereabouts. Optimal size depends on how many stations you want, train length, whether you route with belts or bots inside, and so on.

The rail design hinges on intersection quality. The standard pattern—chain signal at entry, normal signal at exit, with signals on the right side of travel direction—is straight from the train signal tutorial. City blocks see more intersections, so if this is sloppy, you'll deadlock spectacularly. I once flooded my network with train stop-and-wait positions and brought everything to a standstill. Blocks look orderly at first glance, but messy signals break them.

Construction plans - Factorio Wiki

wiki.factorio.com

Main Bus vs. City Blocks: When to Use Each

The biggest difference is what counts as your expansion unit. Main bus extends the belt trunk and adds ingredient lines horizontally as you grow—very strong early to mid-game because you can trace materials visually. But as it fattens up, line count explodes and adjustments get heavy.

City blocks flip this: instead of lengthening the trunk, you scale by duplicating identical templates. "Copper plates running out? Add another copper plate block. Green circuits low? Place another green circuit block." Your expansion unit is crystal clear, role division works across teams, and broken spots are easy to isolate. Manageability-wise, there's real payoff.

That said, main bus isn't "old" and city blocks "new." My instinct says early-to-mid: main bus; large factory with mounting overhead: city blocks—that flow feels most natural. Start with a massive rail grid and suddenly the rail design itself becomes a burden. Push main bus too far and the trunk organization gets painful. Neither is universally superior; they're suited to different growth phases.

In practice, hybrid operation is powerful too. Feed main bus up to intermediates, but list heavy resource imports and mass science on city blocks. No all-or-nothing switch needed, and existing factories transition easier. Bigger factories almost never lean "all bus" or "all blocks"—they're somewhere in between.

Rough comparison:

City blocks shine on modularity and scalability, not raw speed. The article Factorio construction methods: merits and demerits covers this tradeoff—city blocks land on the "easy to manage and expand" side of that spectrum.

The UPS Misconception

One thing often misunderstood: city blocks ≠ UPS-strong. Split this conceptually. City blocks are an expansion and management discipline, not UPS optimization per se. Bigger train networks breed more intersections and pathfinding; sloppy design stacks compute cost. A tight grid of four-way intersections looks orderly but can punish UPS—trains retrace routes constantly, multiple intersections see waiting, flow and processing both suffer. Forums and Reddit have consistent takes: "Big city blocks are convenient, but not lightest." My experience matches—as station count and intersections grew, visibility improved but the rail net got finicky.

Real UPS reduction leans different: shorten transport, link processes directly, cut intermediate steps, minimize intersections. City blocks aren't opposed to this, but keeping a regular grid often means "take a detour if it preserves the pattern"—human-friendly but not always compute-friendly.

That's exactly why I don't score city blocks on UPS alone. Fast expansion decisions, maintainability, role separation, clarity for multi-player—these count too, and city blocks excel there. I've stuck with them in big factories not because they're lightest, but because changes don't cascade. The bigger your factory, the more you value reducing player cognitive load.

Four Pre-Build Decisions: Size, Train Length, Direction, In-Block Logistics

Choosing Block Size

Block size is the hardest thing to retrofit later. Intersections, stations, power, wiring, internal layout—everything hinges on it. Vagueness here means dimensions drift with each expansion. The trick is to anchor yourself to the 32-tile chunk grid from Map structure. Divisible-by-32 sizes align with radar views, blueprint handling, and future reviews.

96×96 tiles is super practical. That's exactly 3×3 chunks, and Factorio Grid Beginner Notes even walks through running at that scale. I use sizes in this family often because they're Goldilocks—not too tight, not too sprawling—and tweaking a single product is easy. A block might look 128×128 with externals but run 96×96 internal logic. Keep "outer footprint" and "actual production area" separate.

100×100-ish is also common—prioritizing design intuition over strict chunk alignment. Conversely, 64-tile blocks work for prototypes or small factories, but they compress fast. In my experience, starting small and cramped leads to spillover and kills the block-replication charm.

What matters: how many stations fit, how much process you close internally. Multi-input recipes eat space; plan station footprint and internal traffic lanes first.

Train length is super critical operationally—ideally stick to one configuration. Whether 1-2, 1-4, or otherwise depends on scale and logistics philosophy, but mixing ruins station, stacker, and fork dimensioning. One unified length is one rule; break it and design cost skyrockets.

A quick note on composition sizing: the specific tile count for configurations should come from the official Factorio Wiki or pinned sources, not guesswork. My own practice—"1-4 fixed + effective 96×96"—works for me, but verify before committing.

Train choice hinges on factory scale. Small batches, many trains = 1-2. Big hauls, fewer trains = 1-4. Critical isn't superiority but standardization. City blocks gain their edge from spec consistency; mix and the whole system weakens fast.

Traffic Direction (Left/Right)

Lock in direction before mass-replicating or you'll have mismatched intersections and stations everywhere.

I favor left-side traffic. Practically, Factorio's train setup assumes signals and stations on the right of travel direction, so left-side driving lets me tuck them inboard. A two-lane perimeter stays neater, signals bunch inside easier, outer form holds. The handedness mattered less than the "tucking efficiency." 96×96 examples often run left too; I found station connections got a lot cleaner once I switched there.

It's not an objective truth. Right-side veterans should keep going that way—fewer design mistakes. Terrain or existing main lines might favor right. The real win is replicating the whole intersection-station-mainline set identically, not which hand is objectively better. If you're torn, build one test intersection with a T-branch and station inlet, then pick what your hands prefer.

In-Block Logistics: Belts / Bots / Mini-Bus

Decide how you'll move stuff inside blocks and stick to it or designs'll fragment. Main options: belts, logistic bots, mini-bus (sub-bus).

Belts are most legible and throughput is easy to estimate. Belt transport basics: yellow = 15 items/sec, red = 30 items/sec, blue = 45 items/sec. See blue = 1 lane? Estimate stations and unload lines. Heavy single-flow items like plates or circuits are belt-friendly; you see flow and bottlenecks clearly.

Logistic bots simplify routing inside messy shapes. Multi-item, low-volume processes love them. But in my experience, robots feel easy until they're everywhere, then power and density get handwavy. Within one block, manageable; sprawl everywhere and visibility drops.

Mini-bus runs a short belt bundle inside the block. Outer = trains, inner = a few lanes. Tighter than all-belt, more visible than all-bot, and it works really well in practice. Multi-product blocks especially: short-distance multi-material distribution with a tidy look. I've switched sloppy direct-to-station setups to mini-bus and suddenly things snapped into place.

Quick heuristic: short distance + high throughput = belts; low volume + many items = bots; multiple supplies + mid distance = mini-bus. City block usability changes dramatically with this choice. Same 96×96, but "fixed internal logistics" copies fast; "ad-hoc every time" kills the vibe.

Belt transport system/ja

wiki.factorio.com

Expanding Your Factory with City Blocks

Grid-Only Staging in a Fresh Area

Staged migration is safest when switching from main bus to blocks. Don't retrofit everything at once or you'll starve old systems mid-construction. I've fallen into the "just rebuild everything" trap and ended up paused, ammo-dry, researching nothing—rough.

Build template blocks first, not production. Concrete: empty cells, intersections, standard in/out stations. No guts needed. Pre-framing lets you swap contents later. Map chunks partition things, so a clean grid keeps your overview sharp even with terrain.

I made the template intersection + station + direction lock, factoring in station facing and input/output placement. This is subtle but huge—blueprints can copy block content, but if station orientation shifts each time, you still do manual work. Locking those down meant stamping grids got way faster. Use Construction plans to carry a whole template—block body, intersection, standard station—in one package. Keep a book sorted: "frame only," "with stations," "production-ready."

Migrate Heavy-Demand Items (Smelting, Electronics) First

Once grids are down, move high-consumption items that bloat the main bus. Smelted plates, electronics boards—lots of downstream processes touch them, so leaving them on the main bus means tweaking the trunk every time you expand.

Flow: make new block smelting or green boards, verify stable output, gradually flip consumers over. Don't stop the old factory, add a new supplier and rebind later. If the new source hiccups mid-transition, the old one still feeds things.

Electronics especially scatter wide—red boards, blue boards, assembly machines, intermediates all ripple. Cutting boards out of the main bus center frees up config real estate. Same with smelting: belt is "add another trunk line," blocks is "add another smelter block." Standardization starts paying dividends here.

One Block Perfected → Copy → Scale Out

City block wins come from nailing one block before multiplying it, not from dreaming up a perfect masterplan. Get one stable, sound block—stations working, in-block flow steady, power solid, signals right—then copy.

Reason: fault isolation. Does traffic jam at the intersection, at unload, in belts? One block makes diagnosis easy. Spin up five half-finished blocks and you'll muddy the picture. I once templated unfinished stations and stamped them everywhere—same failure in six places. Painful.

Once one block works, blueprint it and roll it out. This is where your prep—template frame + intersection + standard station—shines. Common outer shell means swapping guts keeps the big rules intact. Duplicate the smelter block to add plate supply; duplicate the circuit block to add green circuit supply. Scale effortlessly.

Blocks weaken if you redesign every copy. They strengthen when you replicate perfected originals. Once my workflow flipped from "new design" to "copy existing," expansion got light-years easier.

Keep Old Factory as a Cushion

Don't scrap the old main bus factory the instant new blocks light up. Reserve it as a supply buffer—legitimately important. Fresh blocks look good on startup but reveal glitches after running: rail bottleneck, station backlog, stockout somewhere. Tear down the old factory mid-troubleshoot and you're sourcing resources during repairs. Miserable.

Dual supply running solves this. One system drops and the other patches. Construction supplies, ammo, science, repairs—"stops everything else" items especially profit from this backup. I've rushed to full cutover and surfaced mid-build shortages, watching the new blocks struggle and the cleanup drag. Keeping the old setup alive meant I absorbed issues while tuning the new side.

Judge timing by new blocks hitting stable output, not by visual appeal. Decommission old lines as they become redundant, not in one angry purge. City block migration is less "move everything" and more "rebuild the factory next to itself." This pacing sidesteps the worst gremlins.

Rail, Station, and Signal Fundamentals

Signals and Blocks

Signal placement breaks city grids faster than anything else. Mess this up while multiplying intersections and you'll see trains pile up despite orderly looks. For me, the breakthrough was pre-deciding where trains stop and where they don't.

Core rule: signals go on the right side of travel direction. If you're running single-direction lanes, place signals consistently right-hand relative to traffic. Flip-flopping breaks recognition—trains can't enter where they should.

Next: cut blocks finely between intersections. A long unbroken stretch = one block means anything partway down holds the rest. Short blocks let the front progress slightly and the next train move up, keeping flow alive. Less "boost throughput" and more "kill dead time," but the effect is real. Too many people—me included—missed this and built long sections that serialized everything.

Crucially, never stop trains inside intersections. I mixed normal signals into entrance and suddenly trains parked mid-crossing, sideways traffic locked, outbound clogged—gridlock in all directions. Switched entrance to chain = flow recovered instantly. Intersections are for moving, not waiting. City blocks repeat intersections, so this principle matters per intersection.

The Factorio Wiki train signal tutorial explains this: confirm the full path before entering. City blocks benefit from applying it consistently.

For deeper signal and blueprint specifics, Factorio Wiki's rail signals, blueprints, and main bus articles ground you. Then layer Space Age on top.

Tutorial:Train signals/ja

wiki.factorio.com

Intersections: Chain Entry / Normal Exit Pattern

Standard intersection is crystal clear: chain (linked) signal at entry, normal (rail) signal at exit. Why? Entry checks if you can clear the whole intersection. Exit says "if the next block opens, keep going." So trains don't wait inside.

Visually: place chain right where conflict starts, normal right after it clears. This makes intersections pass-throughs, not rest stops. City blocks grid intersections densely, so one inter-queue cascades forward. Treating the intersection as throughput-only stabilizes the whole network.

Articles breaking down chain signal logic walk through this cleanly. My gut: busy four-way grids break less when you stick to this pattern than when you get fancy with internal segmentation.

Stations and Stackers: Don't Block Main Line

Clean signals don't matter if stations clog the trunk. City blocks often see queued trains backing up and blocking the main artery. The fix: stackers, or waiting rails.

Role: off-ramp queued trains while stations fill, keeping the trunk clear. Multi-train pileups don't overflow into main lines, so throughput stays flowing. I underestimated this for years until blocky scale hit—"station holding space" solved more jams than intersection tweaks.

Design: match train length to platform and stacker length consistently. Short stacker + long trains = overhang into forks or mainline = defeating the purpose. Treat station entry, stacker, and post-exit stop position as one unit; nothing should protrude. Right-size or redo.

Second: separate arrival and departure from the main line. Station inbound should branch, hold, unload, then merge outbound—all off the trunk. Trunk = constant flow; station zone = wait, turn, stop, merge. Splitting duties this way isolates disruption.

Multi-player benefits hugely. If someone adds a station or train, separated logistics means predictable impact scope. City blocks' copy strength becomes a liability if you've stamped bad station designs everywhere. Good station template = solves half the scaling problems.

Chasing signal issues when the real problem is queued trains is super common. Train networks are about where they stop, not just where they run. City block design needs both.

In-Block Layout Strategy

One Block, One Product

Cleanest: one block = one product. "Green circuit block," "steel block," internal machinery self-contained, output singular. City blocks as production cells are easiest here—role obvious, duplication smooth, troubleshooting fast.

Strength: train timetable clarity. Inbound = raw, outbound = finished. No ambiguity; stack multiple and the pattern holds. Multi-player stays aligned. If someone adds a station and it's known to be "green circuit only," rules hold firm.

Downside: products multiply, trains multiply. Chasing throughput by overfragmenting creates busy rails for small payload. I've split too fine and ended up with rail congestion, not speed. Find your balance between clarity and transport efficiency.

Multi-In, Single-Out

Alternative: ingest multiple inputs, output one finished product. Fewer super-products, more up-front material. Inside, it's clean—material lanes in, machinery central, product out.

This shines on complex high-product items. Many ingredients but one output = station simplicity. Modify the recipe? Interior swap, inbound stays locked. Pretty usable.

Key: "lots of inputs ≠ lots of stations." Some materials light, some heavy. Decode to belt lanes first, then count. Blue lanes might share a station; red lanes might split. This avoids station under/oversizing, a common trap.

Bot philia tempts here—routing multi-material is easy with bots. But scale matters. Light trial run? Bots fine. Mass production? Belt reliability often wins. I prototype-bot, then upgrade to belt for the live version—front-loads rework but avoids bottlenecks later.

Mini-Bus Internals

Flexibility angle: nest a small belt bundle inside the block. Outer = trains, inner = local branch. Feels like smuggling main-bus logic into blocks, weird at first. Actually quite strong.

Gain: flexibility on recipe and expansion. One-product blocks are tight; adding steps means redesign. Mini-bus inside absorbs tweaks—spare lanes, midstream insertion, internal rework—all without rebuilding the shell. I was rigid, got stuck, switched to internal mini-bus, and suddenly had room to breathe.

Natural fit: in-situ intermediate creation. Copper plates in → copper wire made here → mini-bus feeds both local use and export. Less bottleneck on outside supply, more versatility. Future repurpose gets easier.

First impression was "that's un-blocky," but actual execution is managerially strong. Trains handle the big picture, internal small-bus absorbs variance. Replica-friendly and tunable. City blocks with explicit rules hold up; ones with slack space do too, different way.

Station Count and Train Sizing

Station count flows from input types, needed throughput, fixed train length, not from symmetry or aesthetics. Vague here and you'll see "station exists but can't unload fast" or "throughput fine, but waiting piles up."

Method: decode each material to belt lanes. Yellow, red, blue—how many per substance? That tells you unload footprint. Then ask: one station handle it, or split? Throughput demand, not item type, drives this.

Train length similarly: not beauty, but how many stations fit and how fast can they cycle. Long trains = fewer circuits, more idle time per run. Short = nimble, frequent, tiny payload. Which fits your block's station count? Size accordingly.

Mismatch here is subtle but ruins expansion. Insufficient station width = backup on rails = blocked trunk. Over-station sizing wastes build. Pre-bake train length, then layout from there.

Front-load this or redesign often. Stations + waiting + flow = one thought, not three separate problems.

Common Pitfalls and Fixes

Early mistakes happen in predictable places. City blocks look organized so they feel right, but station, waiting, fork, train consistency is what actually governs stability. I've believed my neat grid only to watch it crumble once running.

Block Too Cramped for Station Queuing

Shrink blocks and you'll cram stations in, only to have queued trains spill into main lines, stopping at forks and cascading backward. Looks compact, breaks reality.

Fix: size for station platform + stacker + inbound deceleration + outbound merge, all within the block. Buffer space is non-negotiable. I've sized "just the station" and rehashed the design multiple times. Margins matter.

Train Length Changed Mid-Run

Length shift = every block's sizer breaks. Stacker doesn't fit, fork stop-points shift, signal blocks desync—dominoes fall.

Prevent: one configuration, locked. Blocks replicate it wholesale; rig one, apply everywhere. Mixed lengths shatter replication, the whole advantage crumbles.

Forced Everything Into Blocks

Temptation hits: "make everything blocks!" Neat, unified, satisfying. But low-demand items dilute the network—trains run half-empty, stations multiply, management load explodes. Exhausting.

Better: keep the old setup or mini-bus for low-throughput stuff. Migrate high-demand progressively. Hybrid works.

Over-Intersected Grids

Dense lattices feel efficient. Trains navigate chaos, paths multiply. Except too many intersections = too many stop points. Every crossing is potential wait.

Solution: trunk straight, forks to the edge, consolidate on-ramp/off-ramp, not scattered crossings. Flow beats option count. Straight passage over everywhere-accessible complexity. Feels counterintuitive but networks flow calmer.

Expecting UPS Heaven From Blocks

Dangerous myth: blocks = UPS victory. Nope. Blocks manage people, not compute. Scale to many blocks, intersections explode, stops multiply, pathfinding thrashes—heavier, not lighter. UPS-first designs trim routes, cut intermediates, thin intersections. Opposite of multiplying blocks.

Keep this straight: city blocks are human-scale management, not compute optimization. Both good for different reasons, but distinct aims.

Space Age and v2.0 Perspective

Space Age and Factorio 2.0 don't invalidate city block fundamentals. Foundation stays; options expand. Rail rules from 1.1 still work. Signal unification, train length locking, template replication—all effective post-DLC.

My own experience: no full redesign felt necessary. Intersection doctrine and single-length commitment remain the kingpins; surrounding bells and whistles don't destabilize them. Honestly, I prepped for radical change and found the baseline mattered most.

At the same time, 2.0 + Space Age broaden tool range. Old large grids don't become obsolete, but they're no longer the exclusive standard. Friendly terrain + expansiveness? Blocks strong. Tight geography or modest scope? Thick trunk plus selective blocks works fine. Multiplayer especially: team size changes the calculus. Bigger groups love transparent rules; smaller groups can freestyle more.

Avoid "grid = always right" or "blocks are past tense." Context matters more now.

A big one: don't fetishize the grid. Blocks aren't mandatory for everything. Good processes sometimes are belt-heavy, sometimes train-heavy, context-dependent. 2.0 brings that flexibility into the open. Trying to force everything into squares wastes the freedom.

New-element design specifics are still uncertain. Space Age adds stuff, but how much it rewires layout practice isn't crystallized yet. Old rules still hold empirically, so anchor there, then experiment with deltas on live runs. Theorycrafting every ingredient upfront is slower than build-test-adjust.

Felt Experience: What Mattered in Signal Design

DLC context didn't force train network overhauls for me. Intersection doctrine + train length lock kept even large nets stable. Old basics are the loadbearer. Fancy new stuff doesn't let sloppiness slide—break the rules and 2.0 chokes just as hard as 1.1.

For deeper signal and blueprint specifics, official Wiki entries and trusted primers are safest. Factorio Wiki's rail signals, blueprints, and main bus articles ground you. Then layer Space Age on top.

Suggested reading order: main bus fundamentals → train signal rules → train network principles → blueprint workflow. Chain that arc and "what goes on trains," "how not to deadlock," and "how to copy" click together. City blocks aren't standalone—context-embedded articles teach more than one essay alone.

Summary and Next Steps

City blocks aren't a factory rebuild—they're a tactic to cut expansion overhead. Win condition: lock train length, block spec, direction, in-block routing upfront, then perfect and copy the minimum block. When I honored that minimum-unit-first discipline, material supply stayed smooth and expansion kept pace.

Actionable sequence:

1. Pick one train length, template it—empty block + intersection + standard station—as a blueprint
2. Migrate one system (smelting, electronics, or plastic) to the new block; keep old main bus as supply reserve
3. If signals seem wrong, review Tutorial:Train signals and Blueprint in the wiki

Try to change everything at once and you'll thrash. One spec, one complete block, then multiply. Most reliable path forward.