You’ve got belts running, inserters clicking, and assemblers churning out science packs. The factory works — but it doesn’t think. Circuit networks are what separate a functional factory from one that actually responds to the world around it, making decisions while you’re busy doing other things.

This guide is aimed at players who already have the basics down and want to take automation to the next level. If you’re still getting comfortable with belts, inserters, and assemblers, start there first — circuit logic will make a lot more sense once those fundamentals are solid.

🎯 Understanding the Signal Layer

Before any of the clever tricks, it helps to have a clear mental model of what circuit networks actually are. At the most basic level, you’re building a system with two kinds of participants: sensors that read the game world and output signals, and actuators that receive signals and do something in response.

Chests, tanks, mining drills, train stops, and power accumulators are all sensors — wire them up and they’ll start broadcasting information about their current state. Inserters, pumps, and train stops can act as actuators, switching on or off based on what signals they receive. The magic happens in the middle, where combinators let you transform, compare, and store those signals.

Think of red and green wires as the nervous system running through your factory, with each combinator acting as a small decision node. Once you see it that way, the whole system starts to feel less intimidating.

The Three Combinators

The arithmetic combinator does math — add, subtract, multiply, divide, and bitwise operations on any signals you feed it. The decider combinator evaluates a condition and outputs a signal only if that condition is true. The constant combinator stores fixed values you define, making it ideal for configuration panels and “target stock level” settings.

Most advanced circuit builds use all three in combination. A constant combinator holds your desired thresholds, a decider compares current levels against those thresholds, and an arithmetic combinator handles any scaling math that sits between them.

🧠 Core Patterns Every Factorio Engineer Should Know

Certain circuit patterns come up again and again regardless of what you’re trying to automate. Learning these building blocks means you can snap them together to solve almost any problem.

Pulsers and Edge Detection

Many automation tasks need a single one-tick pulse — a brief “yes, do this now” — rather than a continuous signal that stays on indefinitely. Incrementing a counter, toggling a mode, or triggering a one-time action all call for a pulse rather than a sustained signal.

The classic pattern uses a decider to output a signal only when the input exceeds zero, then clears it the following tick using feedback. You can use this to fire a trigger when a chest fills up for the first time, or to generate clock ticks for timed production bursts. It sounds abstract until you need it, and then you’ll wonder how you managed without it.

RS Latches and Stable Memory

An RS (Set-Reset) latch stores a binary state — on or off — and holds it until explicitly told to change. Two opposing decider combinators feed into each other: one sets the state when a Set condition is met, the other resets it when a Reset condition is met.

The real-world value of this becomes obvious the moment you try to manage backup power. Without a latch, a machine that turns on at 30% accumulator charge and off at 31% will flicker constantly, toggling dozens of times per second. With a latch, you set it to switch on at 30% and only reset when charge climbs back to 60% — smooth, stable, and no wasted energy from constant state changes. The same hysteresis principle applies to resource management decisions across your entire factory.

Counters and Memory Cells

A counter builds on the RS latch pattern, using arithmetic feedback to maintain a running total that persists over time. A decider outputs its own result back into its input while a condition holds, effectively remembering a value across ticks.

You can use this to track exactly how many train cycles a given outpost has completed, count rocket launches, or implement “quota” systems that produce exactly N items and then stop. The Factorio circuit network cookbook on the official wiki is excellent for seeing these patterns laid out clearly.

⚡ Practical Applications That Transform Your Factory

Abstract patterns are fine, but what most players want are concrete solutions to the problems they keep running into. Here are the automation scenarios where circuits make the biggest difference.

Fluid Systems That Never Deadlock

Fluids are notoriously difficult to manage because one backed-up product can halt your entire oil processing chain. The circuit solution connects all your relevant tanks on a single network and uses “source greater than destination” conditions to control cracking pumps.

Wire your heavy oil, light oil, petroleum gas, and lubricant tanks together. Set a pump enabling heavy-to-light cracking only when heavy oil exceeds light oil. Set another enabling light-to-gas cracking only when light oil exceeds gas. Add a third for heavy-to-lube when heavy exceeds lubricant. The result is a self-balancing system that automatically routes surplus fluids to where they’re needed without any deadlocks — something logistic network planning alone can’t achieve for fluids.

You can extend this further with priority cracking — only crack light oil to petroleum gas when your solid fuel chest is already full, for example — turning your refinery into a fully responsive production system.

Smart Production That Only Builds What’s Missing

The dynamic mall concept is one of the most satisfying circuit applications in the game. Instead of every assembler running continuously, you wire the system to only produce items that are actually low in stock.

A constant combinator holds your desired stock levels for dozens of different items. A logistics chest broadcasts its actual contents. A decider compares the two using the “each” signal wildcard — if any item falls below its target, that item’s signal gets passed to enable the relevant assembler. The entire mall only activates machines where there’s genuine demand, keeping your power draw and belt traffic low while ensuring you never run out of anything.

This scales impressively: one well-built combinator bank can drive an entire mall that manages itself while you focus on expansion. When combined with the base building strategies that work best for megabase layouts, you end up with a factory that barely needs active management.

Train Logic That Eliminates Partial Loads

The most common train inefficiency is dispatching a train before a full load is buffered at the outpost. Circuit-controlled station limits solve this elegantly.

Wire each row of chests at a loading outpost to a decider that outputs 1 if that row contains at least one wagon-worth of items. Sum those signals and compare against your train length. Only enable the train stop — or set its limit to 1 — when a full train load is confirmed to be ready. Your train network goes from sending half-empty wagons to dispatching reliably loaded trains every time.

Advanced routing takes this further: circuit penalties on signals can artificially increase path costs for certain routes, balancing multiple identical outpost stations against each other based on available chest space. You can also give mainline trains priority over shunting yard movements by altering signal costs with circuits, keeping throughput high during peak production.

Power-Aware Factories That Protect Your Grid

Accumulators output their charge level as a circuit signal when wired. That single fact unlocks a huge amount of grid management capability.

Turn off low-priority assemblers when accumulator charge drops below 30%, using an RS latch with reset at 60% to avoid the flickering problem described earlier. Shed power-hungry beacon setups during night hours when solar output drops. Flash warning lamps on your main bus when the grid enters critical territory. The game even supports multi-digit numerical displays built from lamps and combinators, so you can build an actual dashboard showing real-time grid state if that appeals to you.

🔧 Dashboards and Visual Feedback

One of the most underrated uses of circuit networks is just making information visible. The official cookbook documents patterns for numerical multi-digit displays and grid-based lamp matrices where each lamp is addressed via numbered signals. You can build a rocket launch counter on a billboard, display live science-per-minute output, or create a minimap-style layout where lamp brightness represents resource levels.

It’s purely aesthetic — none of it makes your factory more efficient — but there’s something satisfying about building a control room that shows you what your factory is doing at a glance. It also makes diagnosing problems significantly faster when you can see fluid levels or production rates without opening menus.

⚠️ Common Mistakes to Avoid

The biggest mistake new circuit engineers make is connecting signals without thinking about signal pollution. Every entity on the same wire colour shares all signals, so a chest full of iron plates will broadcast an “iron-plate” signal to everything else on that network. Separate your networks deliberately — use red wire for one logical group and green for another, and avoid cross-contaminating sensor outputs with actuator inputs.

The second common mistake is not using RS latches where they’re needed. If a machine is switching on and off rapidly because a condition is hovering right around your threshold, hysteresis is almost certainly the fix. Add a second threshold 5-10 units above or below your trigger point and implement a proper latch — the machine will run in stable long batches instead of micro-toggling.

Finally, don’t try to build complex circuits from scratch without understanding the constituent patterns first. Combinators are a programming environment, and like any programming task, the cleanest solutions come from composing simple, well-understood patterns rather than building everything as one monolithic network.

🎮 Building Your First Real Circuit System

The best way to learn circuit networks is to pick one specific problem in your current factory and solve it with circuits. Choose something concrete: your oil processing is deadlocking, your mall is building things you don’t need, or your trains keep arriving half-empty.

Starting with a real problem forces you to actually understand what signals are flowing where, rather than copying a pattern without knowing why it works. Once you’ve solved one problem from scratch, the next one comes much faster.

The micro vs. macro management balance in Factorio is genuinely interesting: circuit networks let you shift a huge amount of ongoing decision-making to the factory itself, freeing you up for the macro-level expansion and design work that actually moves the game forward. That’s the real payoff — not just clever automation, but a factory that genuinely thinks for itself.

---

Continue Your Journey

• Factorio Automation Basics: Belts, Inserters & Assemblers — The foundation you need before circuit networks click
• Factorio Train Networks Guide — Pair with circuit-controlled station limits for maximum train efficiency
• Factorio Logistic Networks — How bots and circuits work together in late-game factories
• Resource Management Tactics — The broader strategic decisions that circuits help automate
• Base Building Strategies — Layout principles that make circuit integration cleaner

What’s your favourite circuit network trick? Have you built something unexpected with combinators — a fully automated research queue, a power-load balancer, or maybe an in-base display? Drop it in the comments.