Factorio Ratio Calculation Basics and How to Determine Assembler Count

When your red and green science lines or electronic circuit production suddenly starts running short in spots, it's time to move beyond intuition to calculation. This guide walks you through production ratio concepts for vanilla 2.x, designed for players looking to stabilize mid-game manufacturing without modules. The essentials boil down to two formulas—and they apply to nearly every recipe once you grasp them.

You don't need to memorize much. Output per second = Recipe output count × Crafting speed ÷ Recipe time, and Assemblers needed = Target output ÷ Output per assembler (round up) — two equations that stay constant whether you're working with Assembler 1, 2, or 3, and most recipes respond to them predictably.

I used to think electronic circuits were the bottleneck when my green science line stalled. Turns out, copper cable was the real culprit. Once you start tracking ratio, that kind of problem becomes instantly visible. You shift from reactive "add more when things run short" to planned expansion, and the whole factory starts breathing easier.

Three Foundational Concepts for Factorio Ratio Calculation

Terminology: Recipe Time, Crafting Speed, and Output Count

The three terms you'll align first are recipe time, crafting speed, and output count. If these stay fuzzy, the same recipe yields different machine counts depending on who's calculating.

Recipe time, as shown in-game, is the reference duration at crafting speed 1. Hand crafting counts as speed 1, so the displayed time is your baseline "how long it takes if you make it by hand." When you place an item in a machine, the actual crafting time becomes recipe time ÷ crafting speed. This is the game-tick principle at work.

Crafting speed is the machine's production multiplier. Vanilla assemblers have Assembling Machine 1 at 0.5, Assembling Machine 2 at 0.75, and Assembling Machine 3 at 1.25. Same recipe, but your machine count changes because the speed value changes. Machine 1 is half as fast as hand-crafting; Machine 3 is faster. One machine's throughput depends on that number.

Output count is how many items one crafting cycle produces. These three elements are all the ratio formula touches. One machine's production rate = output count × crafting speed ÷ recipe time. Plug those terms into the equation from earlier, and it all clicks into place.

I got tangled up here early on. I switched to Assembling Machine 1 and thought it was slower than hand-crafting. But with crafting speed 0.5, a recipe's shown time became twice as long in practice. Once you write it as a formula, the confusion vanishes.

Time

wiki.factorio.com

Declaring Your Target Version and Assumptions

This article assumes vanilla 2.x. Factorio's balance shifts with expansions and module variants, so if you skip this step, "I built exactly what the guide said, but it doesn't balance" becomes inevitable. Space Age is treated as a separate expansion with different rules, not part of this foundation.

The other assumption is no modules, no beacons. Productivity modules boost output from the same input; beacons spread module effects to nearby machines at half strength. Tweak either, and your "Assembling Machine 3" builds stop matching a basic ratio table. For beginners, running plain assemblers first makes the math predictable and easy to follow. Modules and beacons come later, with conditions clearly marked.

Locking in these assumptions upfront keeps your numbers honest. When you're talking "scale up red science" or "double electronic circuits," you know which assembler you're using and whether bonuses are involved. Good factory design depends less on the formula itself than on keeping your input conditions consistent. The formula doesn't change; the conditions you feed it do.

Space Age

wiki.factorio.com

Hand Crafting and Machine Crafting Alignment

Hand crafting and machine crafting follow the same calculation rules. Both use "recipe time," "crafting speed," and "output count"—the framework is seamless. Hand crafting = speed 1; machines apply 0.5, 0.75, 1.25 (etc.) as multipliers on top. No need to relearn anything when you shift from hand to machine production.

That said, this guide focuses on assemblers because ratio calculations start mattering when you automate. Hand-making a few circuits works fine; automating hundreds per minute requires math.

Assembler tiers matter beyond speed. Assembling Machine 1 doesn't support fluid recipes, while Machines 2 and 3 do. Module slots start at Machine 2. In other words, early-game "just automate it" is different from mid-game "tighten the ratio," even though the equation is the same.

Early on, I'd swap in Assembling Machine 1 and expect hand-speed results. What I really did was bring hand-crafting intuition into a 0.5 speed environment—recipe after recipe got clogged. Once I separated "hand speed sense" from "machine speed," everything snapped into focus. Ratio calculation isn't mysterious math; it's translating hand intuition into machine throughput.

Assembling Machine 1 - Factorio Wiki

wiki.factorio.com

Core Formulas for Assembler Machine Count

Deriving the Equation and Unit Alignment

The core of ratio calculation comes down to two formulas: Output per second = Recipe output × Crafting speed ÷ Recipe time, and Machines needed = Target output ÷ Output per machine. The real trick isn't the formula itself—it's matching units before you plug in numbers.

Factorio recipe times are displayed at crafting speed 1. So when you feed a recipe to a machine, don't use the displayed time directly. Multiply by the machine's crafting speed. Assembling Machine 1 gets speed 0.5, Machine 2 gets 0.75, Machine 3 gets 1.25. Same recipe, different per-machine output. Let's calculate copper cable consumption: first figure out "how many does one machine make per second," and the whole picture clarifies.

If your target is stated in items/minute, don't divide directly. Divide by 60 first to get items/second, then feed that into your per-machine formula. Conversely, once you've calculated per-second output, multiply by 60 if you want to think in minutes. I used to skip this unit conversion and wonder why the count came out off by a factor even though the math looked right. Units, every time.

Without modules, the equation is refreshingly simple: recipe output, recipe time, and the machine's crafting speed. That's it. But add modules? Each module type changes a different part of the formula. Productivity modules boost the output side; speed modules and beacons boost the crafting speed side. The point isn't to abandon the formula—it's to recalculate with the adjusted numbers plugged back in. Assembling Machine 3 can scale from 1.25 to over 10 with the right setup, so two "Machine 3" lines can look wildly different if one has modules and one doesn't. The thinking stays the same.

Rounding Rule: Always Round Up, Plus a Sliver of Buffer

When you get your machine count, always round up. 2.1 machines? Place 3. 5.01 machines? Place 6. The reason is plain: production is discrete. You can't deploy 2.1 units; you deploy 2 or 3. Two is below your need.

Rounding down feels harmless—"it's only a tiny shortfall"—but across a whole factory, shortfalls accumulate. I've watched inventory of intermediate items gently drain when I rounded down on machine count, and after a few minutes, downstream assemblers hiccupped now and then. "Almost enough" doesn't look broken, but spread across minutes and tens of minutes, it kills throughput. The factory slims down one drop at a time.

Beyond rounding up, real-world operation benefits from spare capacity. This isn't changing the formula; it's giving your design a breath of slack. Theory says exact balance; practice says one extra assembler or a slightly fuller buffer zone. Belts compress inconsistently; splitters can drift. Perfectly balanced designs choke easily; designs with a little fat absorb those micro-pauses.

Setting Target Values for Intermediate Products

To find how many assemblers you need, you first have to decide how many items per second of what, exactly. You could work backward from your end product, but in practice, intermediate items like electronic circuits or copper cable are where bottlenecks happen. So set your target not on the final product, but on how much of the next-step material you want to keep stable.

The approach is straightforward: if you're thinking in minutes, set your end-product target in items/minute, then list out the intermediate materials you need in the same unit. Convert each to items/second, divide by per-machine output, and round up. Now you see the pinch points that aren't visible from the end product alone. When I scaled up green science, the brake wasn't at the final assembly—it was one step earlier in the supply chain. Ratios laid that bare immediately.

Intermediate items stay stable if you target them a touch higher than your finished product needs. Why? Because consumption often branches across multiple downstream lines, and those splits can shift momentarily. Copper cable especially—when lots of recipes want it, theory-perfect supply gets thin. One shortage anywhere downstream, and the whole thing wobbles. Overshooting intermediate targets slightly makes expansion painless later; you've got spare capacity already baked in.

Remember: this all assumes no modules. Productivity modules change how much intermediate material you need; speed modules and beacons change assembler throughput. That's advanced territory. Start with "how many plain assemblers for plain recipes," lock that in, then layer on bonuses afterward. It sounds like extra work, but it prevents confusion. The intermediate-item target you set here is where your design's backbone lives.

Concrete Example: Copper Cable and Electronic Circuits

Step 1: Per-Assembler Copper Cable Output

Let's trace how many copper cable assemblers and electronic circuit assemblers connect, starting with single-machine output. We'll pick a specific assembler (say, Assembling Machine 2) and look up copper cable's output per craft and shown recipe time, then multiply by Machine 2's crafting speed of 0.75.

At this stage, don't overthink electronic circuit demand yet. If you start from copper cable, "how much is enough?" becomes a guessing game. I used to place cable assemblers generously and hope it worked out, but cable would pile up in one setup and run dry in another. Intermediate items only make sense when you know what consumes them. Work backward from demand.

To proceed with concrete numbers, cross-check the official wiki for each recipe's:

• Output per craft cycle
• Recipe time (shown)
• Input item counts

Reference (verify against the wiki source): Copper cable — https://wiki.factorio.com/Copper_cable , Electronic circuit — https://wiki.factorio.com/Electronic_circuit .

This guide focuses on the method of plugging in numbers and working backward; when this content goes live, you must insert real data from the wiki (e.g., "Copper cable: 1 craft yields X units, takes Y seconds; Electronic circuit needs Z copper cables, takes W seconds").

Step 2: Per-Assembler Electronic Circuit Copper Consumption and Throughput

Now the downstream side: electronic circuits. Same deal—look up output per craft, recipe time, and Machine 2's crafting speed 0.75 to get electronic circuits per second for one assembler. The new piece is the copper cable requirement per electronic circuit.

If one electronic circuit needs a certain amount of copper cable, and you know how many circuits one assembler makes per second, you can find how much copper cable that one assembler eats per second: circuits/sec × cables per circuit = cables/sec consumed.

Now you can compare upstream supply to downstream demand in the same units.

This sequence works because your design usually pivots on downstream needs. "Scale up electronic circuit production" is easy to decide; "figure out copper cable per second independently" is vague. Anchor to downstream targets, back-calculate upstream demand. When you later want to add red circuits or inserters (both need cable), you'll already have your supply architecture sketched.

My factory sprawled because I doubled electronic circuits without recalculating copper cable supply. I thought ratio was right, but within minutes, all the cable was gone, and the circuit assemblers starved in a cycle. This "ratio looks okay but starves anyway" almost always traces back to cable demand math being skipped.

Step 3: From Target Output to Required Assemblers

Now we convert to actual machine counts: Set an electronic circuit target in items/second, Calculate how many circuit assemblers you need, Figure out total copper cable consumption, Back-calculate cable assemblers needed.

Say you want G electronic circuits/second. One assembler outputs E circuits/second. You need G ÷ E circuit assemblers (round up). One circuit needs W copper cables; all your circuit assemblers together consume circuit assembler count × W cables/second. One cable assembler outputs K cables/second. You need total cables demanded ÷ K cable assemblers (round up).

The payoff: upstream and downstream machine counts lock together in one chain. Double your circuits? You know exactly how many more cable machines appear. Swap to Machine 3? Both sides recalculate instantly. Assembler speed is 0.5 vs 0.75 vs 1.25—big deltas, so the answer shifts noticeably. Ratio calculation makes which assembler you're using visible in the output.

Once you nail this, review your whole line every time you build it. Four circuit assemblers but only two cable assemblers? That discord won't matter for a few minutes, but soon, one segment starves, and the other overflows slightly. Buffers thin. This imbalance is the telltale sign of ratio and actual layout not matching.

Design Tip: Close Proximity and Direct Insertion Are Powerful

Copper cable → electronic circuit is a classic ratio puzzle and a placement puzzle. The reason: cables are a high-consumption intermediate, and once you load them on a belt, they chew bandwidth. A basic transport belt can theoretically move 900 items/minute per lane, but large cable flows over distance consume that bandwidth heavily.

Place cable assemblers next to circuit assemblers. Even better, use inserters to hand cable directly from assembler to assembler—no belt involved. Smelt copper into cable on-site, feed it immediately to circuits. This strategy cuts the cable load on your main bus; it becomes copper plates, not cables. The design breathes easier.

I once made cables in a separate area and bused them over to circuits. The ratio count matched theory, but cables would thin out periodically, and circuits would stutter. When I moved cable production right beside circuits and handed items over with inserters, suddenly stable. I changed no numbers—just logistics. Transport was the bottleneck, not assembler count. Whether a ratio works in practice depends heavily on layout.

Beginner Approach: Overshooting Slightly First

When you're new to ratios, don't chase exact integer balance. If calculations say n circuit assemblers and m cable assemblers, round both up, then add one more cable assembler anyway. Give intermediate items a thin surplus. It works because cables are consumed frequently.

This rounding style is beginner-friendly because you can watch the line and learn: if downstream stalls, you're short; if upstream slowly fills, you've got slack. Theory-perfect designs demand you monitor compression and take-off bias simultaneously. Overprovision slightly, and you isolate "math error" from "layout problem" much faster.

I bombed the "exact balance" approach repeatedly. Numbers said enough; reality said famine. In hindsight, beginning with oversupply, then trimming is faster learning. A running line teaches you more than a broken one. Ratio math is precise; your first build doesn't have to be.

Check Whether Your Line's Throughput Actually Fits the Belts

Converting Tiles/Second to Items/Second

Even if ratios balance, the whole system only works if belts can move the volume. The core equation: Belt throughput = Tiles/sec × Density × Lane count. From the Transport Belt Physics guide, a basic transport belt moves 1.875 tiles/second, items compress at 4 per tile per lane, and belts have 2 lanes, so full compression gives 1.875 × 4 × 2 = 15 items/second.

Learn this conversion, and "will one belt handle this?" becomes instant. Basic belt = 15 items/sec; fast belt = 30 items/sec; express belt = 45 items/sec. If you need 18 items/sec of something, basic won't cut it; fast will barely work, express has room. After ratio count, I always map out what each item needs and cross-check against those three benchmarks. Skip this, and you get the classic bottleneck: the formula says fine, but one stream starves while another slack fills up.

Main-bus design hinges on translating item/sec into belt count. Once you know your throughput in items/sec, decide: one belt, two belts, or on-site production? Ratios show you equipment shortfalls; belts handle item flows. Same units (items/sec) make both readable.

Transport belts/Physics

wiki.factorio.com

Spotting Compression, Starvation, and Recovery Tricks

Here's the gotcha: 15 items/sec is only true for fully compressed belts. Once items spread out, throughput drops. A belt can display 15 items/sec only if both lanes stay packed. If your formula says "need 15 per second" and your belt looks half-empty, you've found the problem.

Compression breaks easily after splitters, mergers, and wherever inserters feed unevenly. One side of a split consumes less; two belts merge messily; inserters dump on one lane. Total supply is fine, but the belt surface looks thin. Downstream stalls anyway.

I always trace a belt and watch for gaps. Solid stream = compressed; obvious spaces = starved. When something runs short despite theory, I check belt compression first. The cause is usually "supply is thinner than it looks" at the input.

Fixes are systematic: tighten compression at the supply endpoint, watch the merge afterward for gaps, balance inserter input across both lanes, etc. Small tweaks often restore missing throughput without touching a single number. One upstream segment was underfeeding until I widened its outlet compression; suddenly everything below came back to life. Belts weren't full; I made them full. No assembler changes needed.

Splitter Balancing and Belt Count Targets

Splitter basics: one input to two outputs at 1:1 split. Both branches get half the supply. This is how a fully divided main bus keeps things even. Splitter mechanics add up; multiple splitters distribute across many outputs evenly. See Balancer mechanics if the deeper theory interests you.

Crucially, splitters don't create items. Fifteen items/sec on input → fifteen items/sec spread across outputs. A splitter lets you reroute and share; it doesn't multiply. If you need thirty items/sec total and split a 15/sec source two ways, you get nowhere near thirty.

Think of belt counts this way: what's your total demand in items/sec? Does it fit in basic (15), fast (30), or express (45)? Within those thresholds, one belt works; beyond them, you need more lanes or an upgrade. Near the top? Upgrade for breathing room. Splitters handle distribution, not volume addition.

My usual workflow: calculate demand in items/sec, match it to the three belt tiers, and decide—one belt, multiple lanes, on-site production, or a belt tier jump. Ratios find production shortfalls; belt math handles transport. Bridge them with items/sec, and your design becomes legible.

Balancer mechanics

wiki.factorio.com

When to Use Machine 1, 2, or 3—and Why Counts Shift

How Speed Impacts Machine Count

Same recipe, same target, different machines = different counts. Assembling Machine 1 is 0.5; Machine 2 is 0.75; Machine 3 is 1.25. Plug these into your formula, and assembler count shrinks as speed rises.

The math is stark. Machine 2 processes the same recipe 1.5× faster than Machine 1; Machine 3 is 2.5× faster. Ten Machine 1's doing a job? Swap to Machine 2, you need roughly seven. Jump to Machine 3, you might use just four. Speed directly cuts headcount.

In the early game, I finish with Machine 1 plenty. Red science, basic components—all doable. But mid-game hits, you research and deploy Machine 2, and suddenly your old "need ten" becomes "need seven." Your blueprint still says ten because you haven't recalculated. Downstream starves; intermediate material piles up. This isn't a broken design; it's a one-tier speed boost breaking an imbalance.

See the Assembling machine entry on the wiki for the full spectrum. Pragmatically, early builds prioritize "just automate it" with Machine 1. When you upgrade to 2 or 3, rerun your ratio math for that section. Same recipe, different machine = different line balance. Design doesn't break; ratios do.

Assembling machine

wiki.factorio.com

Fluid Recipes and Module Compatibility

Speed isn't the only difference. Machine 1 doesn't handle fluid recipes; Machines 2 and 3 do. Only Machines 2 and 3 take modules. So Machine 1 isn't a "slower version"—it's a narrower tool.

Quick comparison:

This split shapes your design. Mid-game fluid recipes vanish Machine 1 as an option. Late-game module-heavy optimization demands Machine 2 or 3. When you decide to run modules, your ratio sheet changes entirely because speed bonuses enter the math.

Modules become serious in the late game. Machine 3 with speed 3 modules and 12 beacons can hit manufacturing speeds of 11.25—completely different from base 1.25. The "need ten" calculation becomes "need one" with those bonuses. Every late-game production line hides massive speed multipliers under a smaller footprint. Ratio tables without module assumptions look sparse compared to reality.

Update Checklist

Swapping machines breaks balance easily. You change the machine, but your ratio gets old. Equipment gaps and hungry downstream appear at once. I've replaced just the machine and watched throughput get weird—materials surplus in one spot, shortage in another.

When updating, use this sequence:

1. Recalculate per-machine output with the new speed value
2. Recalculate machine count for each stage with the new numbers
3. Identify fluid recipes and confirm Machine 1 can't run them anymore
4. If modules apply, separate that calculation from baseline
5. Recheck belt counts and split ratios against the new demand

Post-upgrade recalculations matter because a single-stage speed bump cascades. One faster process changes the before-it and after-it. Your Machine 1 ratios were optimal for Machine 1 conditions. New machine = new conditions = new ratios. Mid-game is especially fragile here because you're researching into higher tiers, and each jump stresses something else.

Common Pitfall: Ratios Align, But Supply Still Fails

Diagnostic Order: Belt → Inserter → Machine → Power

When you've run the numbers, placed the right count, and it still starves, the math usually isn't wrong—one of the hidden assumptions broke. I troubleshoot in order: belts, inserters, machines, power. Start upstream and work down.

First stop: belt compression. A belt isn't full just because it's moving. If merged portions stay half-full, if curves crumple flow, if one lane feeds and the other drifts, real throughput is less than theory. Electronic circuit builds especially suffer here because input density is high. Your belt "works," but doesn't fill the gap to the machine entrance.

Next, inserters. Ratio math assumes "material reaches the machine instantly." Reality: long arc distances, cramped in/out on one side, basic inserters in a high-volume spot—items don't get in fast enough. I've stared at "the math says enough, but this machine hardly fires," then swapped one inserter to a stack inserter or rerouted, and it clicked. Inserters are invisible until they bottleneck, which they do often.

Machine-wise, production bar resets happen. Productivity modules fill a bar that boosts output. New recipe? Bar empties. Setup again. For a few seconds post-change, output is soft. It's not a supply crisis; the machine is re-learning. Also watch for mixed module configs: one row has speed modules, another productivity, an old Machine 2 lingering—suddenly, real speed varies per unit, imbalance shows up, and one side drowns while another air-gasps.

Power and upstreams close the loop. Famine downstream often traces to drought upstreams: copper plates thin, smelters slow, miners run out of fuel. The broken line looks like a production limit; it's really a raw-supply limit. Trace backward.

Symptom Mapping: Light Inlet, Clogged Outlet, Periodic Stalls

Symptoms guide diagnosis. Inlet light = upstream short or belt slack or inserter lazy. Trace backward to source. Belt has gaps, splitter imbalances one side, or raw material is missing.

Outlet clogged = this stage over-produces or downstream pulls slowly. Usually, the outlet inserter can't keep pace. Upgrade its speed or reroute it shorter. If the machine fills internally but can't eject, extract is the chokepoint.

Periodic halts = average supply is fine, but momentary dips starve. Multi-stage siphons, one fluctuating feeder, or power blips. Electric setups suffer brownouts; fuel lines hiccup. Single-point supplies blink out; suddenly, the shared resource empties. Wait, refill, repeat. Smooth upstream or add margin.

With productivity modules, watch output bar state. A freshly-reset bar looks weak for seconds. Mistaken for underproduction, but it's just post-recipe ramp-up.

Operational Tactics: Buffer Machines and Strategic Chests

Perfect 1:1 ratios fail in practice. I keep a spare assembler or two on high-consumption intermediates. Not surplus waste—real insurance. Electric boards take many inputs, so a single dedicated machine absorbs flux.

Buffer chests matter if sited correctly. Input-side buffers absorb upstream flux; I rarely use those. Supply-boundary buffers (where train or main bus feeds a factory section) smooth temporary imbalances. Don't hide root cause with giant buffers; use them to soften waves.

The strongest move is aligning module configuration. Mixed module rows in the same production line? Unpredictable. Each row should have consistent conditions—all speed, all productivity, all plain—so effective output per machine doesn't drift. Consistency beats optimization.

Advanced: Modules, Beacons, and Space Age Math

Plugging Corrections Into the Formula

Beyond this point, don't ditch the formula—inject corrections into it. The backbone stays the same; you're just adding modifiers.

Productivity modules boost output count per craft. Same recipe time, same inputs, more items out. Calculation: feed a higher output value into your formula.

Speed modules and beacons boost crafting speed. Recipes cycle faster. Calculation: feed a higher speed value into your formula. Speed module stacks; beacons spread bonuses at half value to nearby machines within range.

Layer them together carefully. I calculate base (no modules), then add productivity, then add speed, to watch each layer's impact. Never jam all variables at once; errors hide.

Beacon Placement Basics

Beacons broadcast module effects to a 9×9 area at half strength. Key is: how many beacons does one assembler sit under? Count that, scale the effect, and feed it into speed calculations.

Placing beacons is where speed lines become engine rooms. Productivity modules go in the machine; speed modules go in surrounding beacons. One machine under three beacons gets hit with 3 × 0.5 = 1.5 bonus stacks. Different placement, different total bonus, different throughput. Count carefully.

Reading Machine 3 at 11.25 Speed

Assembling Machine 3 base is 1.25. With speed 3 modules + 12-beacon setup, it hits 11.25 theoretical speed. Wildly different from base. One machine at that speed does the work of nine baseline machines.

How? Your formula's speed slot fills with 11.25 instead of 1.25. Per-machine output explodes. Machine count collapses. But one stalled unit now stalls the whole pipeline, and supply-line burden soars. Belts and inserters become the true limits.

This is why late-game ratio tables look empty: they're assuming boosted speeds you can't see from the vanilla baseline. It's not magic; it's buried speed.

Space Age as Separate Curriculum

Space Age introduces branches, quality tiers, and condition-specific recipes that the vanilla formula can't fully capture. Rather than cram it into "base ratio," treat it as a next course.

Factorio's wiki on Space Age shows the expansion isn't just "harder vanilla"—it's fundamentally different. Quality and branching factors don't fold neatly into "output count × speed ÷ time." Separate space-age design from vanilla mastery; learn one, then add the other.

Ready to Use: Calculation Flow and

Summary

Ratio calculation holds up best when you work backward from downstream demand and verify belt capacity can handle it, rather than memorizing formulas first. I keep Assembling machine speed differences and belt theoretical values as my minimal memorization set, and only calculate when something deviates. When a line isn't producing, troubleshoot in this order: under-compression first, then inserter limits, then upstream shortage. Once production speed Modules, speed Modules, and Beacons enter the picture, what matters more than the formulas themselves is documenting which assumptions your numbers were based on -- that's what determines design quality.