Decoding the Matrix: A Beginner's Guide to Factorio Circuit Logic
Hey there, fellow engineer! So, you've mastered the art of the main bus, your production lines are humming, & you're churning out science packs like a well-oiled machine. But you keep seeing these little red & green wires in the build menu & hearing whispers of "combinators" & "circuit networks." It sounds complicated, maybe a little intimidating, like something only programmers or electrical engineers would touch.
Honestly, I get it. The circuit network in Factorio can look like a plate of spaghetti logic that’s just waiting to short-circuit your brain. But here’s the thing: it’s nowhere near as scary as it seems. At its core, it’s just a way to make your factory smarter. It’s about giving your machines simple instructions, like "hey, stop making stuff when this box is full," or "turn on the backup power when our batteries are dying."
Think of it as the next evolution of your factory. You've automated production; now it's time to automate control. This guide is for the absolute beginner. We're going to start from scratch, assuming you know nothing, & build up your understanding one simple concept at a time. By the end, you'll be able to build some genuinely useful contraptions that will make your factory more efficient, resilient, & frankly, pretty cool.
Chapter 1: The Absolute Basics - Wires & Signals
Before we can build any fancy logic, we need to understand the fundamental building blocks. It all starts with two things: wires & signals.
Red Wire, Green Wire: What's the Difference?
You’ve got two colors of wire to choose from: red & green. And the biggest secret that confuses SO many new players is... there's no difference in what they do. Yep, you read that right. They both carry information in the same way.
The only reason you have two colors is so you can run two separate, independent networks in the same area without them interfering with each other. Think of it like having two different Wi-Fi networks in your house. You can connect some devices to one & some to the other, & they won't get their signals crossed. For most simple builds, you'll probably only ever need one color, so just pick whichever one you like aesthetically.
To use them, you just select the wire from your toolbar, click on one machine, & then click on another. You can also string wires across power poles to cover long distances, which is SUPER handy.
So, What's a "Signal"?
If wires are the... well, wires, then signals are the electricity. They are the information that flows through the circuit network. A signal is always a combination of an item (or a virtual icon) & a count.
The simplest way to see this is to connect a wire from a chest to a nearby power pole. Just one connection. Now, put some iron plates in the chest. If you hover your mouse over the power pole, you'll see a new little pop-up showing the iron plate icon & the exact number of plates in that chest. That's a signal! The chest is broadcasting its contents onto the network.
If you connect two chests full of iron plates to the same network, the signals add up. A chest with 100 plates & another with 50 plates will create a single signal of "150 iron plates" on that network. This is a crucial concept: a network can only have one value for each type of signal. All matching signals on the same colored wire combine into a total sum.
You can get signals from all sorts of things:
Chests & Storage Tanks: They broadcast their contents.
Inserters: Can be set to send a signal of what they're holding.
Belts: Can read the items flowing on them.
Roboports: Can output logistic network contents.
And this is where the magic begins. Once you have that information flowing on a wire, you can use it to make decisions.
Chapter 2: Your First Smart Machine - Simple Inserter Control
Let's start with the most common & immediately useful circuit you can build. We're going to stop an inserter from over-filling a chest. This is perfect for your "mall" where you're making things like belts & inserters for yourself, & you don't need a massive steel chest full of 2,400 assemblers.
Here's the setup:
An assembler making something (let's say, gear wheels).
An inserter taking the gears out of the assembler.
A chest for the inserter to put the gears into.
Normally, that inserter will run forever until the chest is completely full. We want to tell it to stop when it has, say, 100 gears.
Here's how you do it:
Take a red wire (or green, your call!).
Click on the inserter.
Click on the chest.
You've now created a tiny circuit network. The chest is broadcasting its contents (the number of gears) & the inserter is now listening to that signal.
Now, click on the inserter. You'll see a new "Circuit Network" panel in its GUI. This is where you give it instructions. You'll want to set the "Mode of operation" to Enable/Disable. This tells the inserter that it should only turn on or off based on a circuit condition.
Below that, you'll see the "Enabled condition." This is your logic statement. It has three parts:
A signal (what to look for)
An operator (<, >, =)
A value (a number)
We want the inserter to work only when the number of gears in the chest is less than 100. So, we set it up like this:
Click the first box & select the Gear Wheel icon.
Click the middle box & choose the < (less than) symbol.
Click the last box & type in 100.
And that's it! The inserter will now diligently work, moving gears into the chest. But the moment the chest's contents reach 100 (or more), the condition "Gear Wheels < 100" is no longer true. The inserter will stop, patiently waiting until you take some gears out, which makes the condition true again.
Congratulations, you've just built your first logic circuit! This simple principle of reading content & enabling/disabling a machine is the foundation for SO much in the circuit network.
Chapter 3: Meet the Brains - The Combinators
Simple inserter control is awesome, but the REAL power comes when you introduce combinators. These are the brains of your factory's nervous system. They take signals, do stuff to them, & send out new signals. There are three types, & they're each pretty simple once you know what they do.
It’s kind of like how businesses use automation to handle customer requests. A customer asks a question (an input signal). The system needs to figure out what they want & give the right answer (the output signal). This is exactly where a tool like Arsturn comes in for businesses. It helps them build custom AI chatbots that act as the "brains" of their customer service. The chatbot can understand a customer's query, apply logic (like a decider combinator), maybe look up some information (like an arithmetic combinator), & then provide an instant, accurate response, 24/7. We're essentially building a physical version of that same "if-this-then-that" logic in Factorio.
The Constant Combinator: Your "Set Point"
The Constant Combinator is the simplest. It doesn't calculate anything. It just outputs a signal (or multiple signals) that you set manually. You plop it down, connect it to a network, click on it, & pick a signal & a number. It will then broadcast that signal constantly.
Why is this useful? It's for creating a desired value or a "set point." In our last example, we typed the number "100" directly into the inserter. But what if we wanted to control 10 inserters at once? Or what if we wanted to change that number easily without going to every single inserter?
You could use a constant combinator. Set it to output "Gear Wheels = 100." Then, instead of comparing the chest contents to a fixed number in the inserter, you could compare two signals. This is where things get interesting & leads us to the next combinator. A cool trick is that you can also set negative values in a constant combinator, which is incredibly powerful for certain calculations.
The Arithmetic Combinator: The "Calculator"
The Arithmetic Combinator is your pocket calculator. It takes input signals, performs a mathematical operation (add, subtract, multiply, divide, & some more advanced stuff), & sends the result to its output wire. It has a distinct input side & output side, so make sure you're wiring it correctly!
A classic use case is for managing inventory requests. Let's say you want to keep 500 iron plates stocked in a chest.
Place a Constant Combinator & set it to output Iron Plates = 500. This is your desired amount.
Wire your storage chest to the input of an Arithmetic Combinator. This is your current amount.
In the arithmetic combinator, set the operation to Each * -1, & set the output to Each. The "Each" wildcard is super powerful—it means "do this to every signal that comes in." So this combinator will take the number of iron plates (say, 120) & output -120.
Now, connect both the Constant Combinator & the output of the Arithmetic Combinator to the same network (you can just run both wires to the same power pole).
The signals will add up. The network will see +500 from the constant combinator & -120 from the arithmetic combinator. The final signal on the network will be "Iron Plates = 380". This number is the difference between what you want & what you have. It's your request amount. You can then send this signal to a requester chest or a filter inserter to bring you exactly 380 more plates. This is WAY more flexible than just setting a simple limit.
The Decider Combinator: The "Decision Maker"
The Decider Combinator is the true "if-this-then-that" machine. It looks at its input signals, evaluates a condition, & if that condition is TRUE, it sends out a completely new signal that you specify. If the condition is false, it sends nothing.
Let's go back to our simple inserter example. Maybe we don't want to just stop the inserter. Maybe we want to turn on a light to let us know the chest is full.
Wire your gear chest to the input of a Decider Combinator.
In the combinator, set the condition: If Gear Wheels > 99.
For the output, you can choose anything! A common practice is to use one of the virtual signals, like the letter "G". Set the output to G = 1. Make sure to select the "1" option, not "Input count."
Now, wire the output of the decider combinator to a Lamp.
Click the lamp & set its condition to turn on if G > 0.
Now, when your gear chest has 100 or more gears, the decider's condition becomes true, it outputs a "G" signal, & the lamp turns on. You've just made a status indicator! This is incredibly powerful for monitoring your factory at a glance.
Chapter 4: Putting It All Together - Simple & Powerful Builds
Okay, you know the pieces. Let's assemble them into some classic, must-have factory gadgets.
Smart Oil Cracking
This is one of the first "big" problems that circuits solve beautifully. You have crude oil being refined into heavy oil, light oil, & petroleum gas. You can crack heavy oil into light oil, & light oil into petroleum gas. But you don't want to crack it all, because you still need heavy oil for lubricant & light oil for solid fuel. You only want to crack the excess.
Here's the logic:
Only crack heavy oil IF you have more heavy oil than light oil.
Only crack light oil IF you have more light oil than petroleum gas.
Here's the build:
Connect all your heavy oil, light oil, & petroleum gas storage tanks with a single red wire. This creates a network that knows the total amount of each fluid.
Place a pump on the pipe leading from your heavy oil tanks to the chemical plants that crack it into light oil.
Connect that pump to your red wire network.
In the pump's circuit condition, set it to: Enable if Heavy Oil > Light Oil.
Do the same for light oil cracking. Place a pump on the pipe leading to your light oil cracking plants, connect it to the red wire, & set its condition to: Enable if Light Oil > Petroleum Gas.
That's it! Now your cracking plants will only turn on when there's an imbalance. Your fluid levels will automatically balance themselves. No more production stalls because one fluid tank is full!
This kind of responsive, automated system is a game-changer for factory efficiency. It's the same principle businesses strive for. They want to connect their different departments—sales, support, marketing—so the business can react intelligently to customer needs. For a business, this could mean using a platform like Arsturn to build a no-code AI chatbot trained on their own data. This chatbot can then act as that central nervous system, understanding customer needs from the website (like reading fluid levels) & automatically routing them to the right department or providing the right information (like enabling the right pump), boosting conversions & providing a seamless, personalized customer experience.
Basic Backup Power
You're using solar panels, which is great! But you have accumulators for the night, & for those big laser turret attacks, you have some backup steam engines. You don't want the steam engines running all the time; that's a waste of fuel. You only want them to kick on when the accumulators are low.
Place a Power Switch between your main power grid & your bank of steam engines. This device acts like a gate for electricity.
Place one Accumulator somewhere.
Use a wire to connect the Accumulator to the Power Switch.
Click the Power Switch & set its condition to: Enable if A < 20. (The "A" signal is a special signal from the accumulator representing its charge percentage).
Now, your steam engines are totally disconnected from your grid. But the moment your accumulator charge drops below 20%, the power switch flips on, your steam engines fire up, & they start powering your base & recharging your accumulators. You can even add a second condition with an SR Latch (a more advanced topic for another day!) to make it turn off only when the charge reaches, say, 80%, to prevent it from flicking on & off rapidly.
Chapter 5: The Tip of the Iceberg
Honestly, we've barely scratched the surface. Once you're comfortable with these basic ideas, a whole new world of automation opens up. You can:
Control Belts: Turn entire production lines on or off.
Create "Sushi" Belts: Carefully place a mix of different items onto a single belt using timed inserters.
Build Smart Train Stations: A train will only leave a station once it's full OR if the outpost it's going to sends a signal requesting supplies.
Make Programmable Speakers: Create custom alarms for when resources are low.
Build Digital Displays: Show your exact resource counts on massive, color-coded light displays.
The key is to start small. Pick one little problem in your factory, like limiting a chest or turning on a light, & solve it with a single wire. Then try another. Combine two ideas. Before you know it, you'll be looking at your factory not as a collection of machines, but as a giant, programmable organism that you can control with precision.
I hope this was helpful & that the circuit network feels a little less mysterious now. It really is one of the most rewarding parts of Factorio once you get the hang of it. Start with that one inserter & one chest. You'll be a logic wizard in no time. Let me know what you think, & happy building