Factorio is a game that is close to my heart. I’ve spent countless hours building, optimizing, and sometimes, fighting my own creations. Over the years, I’ve written a lot about my journey with logistic trains, detailing the complex circuit networks I’ve built to solve what seemed like fundamental problems.
Today, I want to take a moment to look back and appreciate how far the game has come. Many of the complex contraptions I built in the past are now elegantly solved by features integrated directly into the game. This post is a thank you to the developers at Wube Software for their incredible work on quality of life features that have made the game even more enjoyable.
I’ll be focusing on three key features that have had a massive impact on my logistic train designs:
Let’s dive in and see how things used to be, and how much better they are now.
The Old Way: Complex Indexer and Max-Value Circuits
If you’ve read my older posts, you’ll know the pain of trying to load a train with a variety of items. The problem was simple to state, but incredibly difficult to solve with circuits: how do you pick just one item type from a mixed signal of many requested items, load it onto the train, and then move to the next item?
My first attempts involved building what I called an “indexer” circuit. This was a state machine that would iterate through a duplicate list of manifest items, each with a unique index. Later I found a way to generate the index signal automatically but that required the physical items themselves to be inserted into a chest one by one. Both solutions were slow, cumbersome, and error prone.
Later, inspired by a comment from a reader, I used a max-value circuit to isolate item(s) with the max count. The great insight here is that items with the same count have the same hand size signal so I don’t care which of the same-count items are inserted and when. It was faster than the indexer, but still required a complex loop of combinators to isolate the max value. This also required several ticks to calculate the max item and would not be suited to the speed of quality inserters.
This was a fun challenge, but it was a workaround for a missing feature.
The New Way: A Simple Difference
Then came the Anything signal. This simple, elegant feature changed everything. Now, the entire complex dance of indexers and max-value finders can be replaced with a single combinator.
The logic is beautiful in its simplicity:
Anything > 0, output Anything (signal).That’s it. The Anything signal picks one of the positive signals and outputs it. The filter inserter can then be set to that item. On the next tick, a different item might be picked, or the same one. It doesn’t matter. The system just works.
This one feature removed dozens of combinators from my designs, making them smaller, faster, and much easier to understand.
The Old Way: Complex Global Networks and Dummy Stations
Before train limits, preventing train traffic jams was a major challenge. The most common solution was to disable a station when a train was on its way. However, this created a new, more insidious problem: what happens if a station is disabled after a train has been dispatched?
This was a frequent headache with my logistic trains. An outpost would request items, a train would be dispatched, and then, due to construction or deconstruction, the request would disappear and the station would disable itself. The result? A train stranded in the middle of the tracks, blocking all other traffic.
The workaround was simple, annoying and error prone. I had to build a global circuit network, connecting all my power poles, just to manage these orphaned trains. The network’s job was to detect when no logistic outpost stations were active and then enable a dummy station somewhere for them to rest.
The New Way: Set and Forget
Train limits solve this problem perfectly. Now, I can just set a limit on each station, say, to 1. The game will ensure that only one train is ever pathing to that station at a time. If the station’s request is satisfied and it turns off, no new trains will be dispatched, but the one already on its way can still complete its journey.
This single feature eliminated the need for a global circuit network, dummy stations, and all the complex logic that went with them. My train network is now more robust and easier to manage.
The Old Way: Manually Syncing Modules
My logistic train network relies on “modules” - constant combinators that define the items requested by a particular type of train (e.g., a “seed” train or a “wall” train).
To make a change, for example, to add a new item to the wall building module, I had to do it in multiple places: at the depot where the train is loaded, and at every outpost that might request that train. This was manual, tedious, and error-prone. I can’t count the number of times I forgot to update one of the modules, leading to subtle and frustrating bugs.
The New Way: A Single Source of Truth
The introduction of global and named signals in the Space Age expansion solved this problem once and for all. Instead of manually copying combinator settings, I can now define a single, global “wall building manifest” signal.
Anywhere I need that list of items, I can just use a single combinator to read that global signal. A change in one place instantly propagates to every part of my factory. This is a huge improvement, saving time and preventing countless headaches.
It’s amazing to see how Factorio has evolved. The developers have a deep understanding of the problems that players face, and they have consistently delivered elegant, well-designed solutions.
These quality of life features remove the tedious workarounds and let us focus on the fun parts of the game.
So, to the developers at Wube: thank you. The factory must grow, and thanks to you, it can grow in more wonderful ways than ever before.