Hello,
we are going to focus on the general improvements of the way circuit network is used in the game.

I wasn't using it often, because all the problems combined made it too big of a hassle most of the time, which was an indication of problems.
So we improved each part of the process of using it a little, from UI, to feedback of what is going on, to stronger/more accessible combinator functionality.
I can say that it worked, at least for me. Once these changes were available, I used the circuit network way more in my latest playthrough, and it felt good, so lets hope it won't be just me :)

Circuit GUIs rework

We learned over the years that it is always better to use disabled/enabled state on control elements which can be turned on or off, compared to making them just disappear.
Circuit control GUI was one of the last places in the game where we didn't apply it properly:

1.1 - Things magically popping out of thin air.

2.0 - All elements present and enabled/disabled when needed.

You can see the functionality even before connecting the wire or activating the individual modes.
With the current version in mind, it is hard to understand our previous design with the checkboxes being disconnected from their parameters, it makes the UI not only more chaotic, but also bigger.

Well, we learn from our mistakes!

Circuit slots show the values

This is one of those features that we just can't imagine living without anymore, and it is so simple we wonder why we never did it before.

In short, the signals in the slots of the Circuit GUIs, will show the current signal value directly in the slot.

The slots showing the values

This makes it super simple when setting up a condition to know what ballpark of value you need to set. It gives immediate feedback during the process of setting up the connection/condition without having to close the GUI and hunt for the information in a nearby power pole tooltip.

Decider combinator 2.0

The decider combinators function is to help make logical decisions, for instance if iron plate is greater than 10, turn on a lamp. It can only process a single condition, which is touted as a feature for the simplicity and eloquence of design, that you build up a complex machine from many simple parts.

However in practice, it made its use in even slightly more complex situations cumbersome. For example if you want to enable a lamp when your chest has 100 steel, 200 copper, 10 coal, you would need quite a few decider combinators. What was a funny realization, is that using train schedules with the circuit conditions, you could make yourself a much more powerful decider combinator.

So it felt that, while simplicity is good, it was too simple and was making basic setups more complicated than they needed to be. It was also awkward trying to troubleshoot some circuit setup, opening all the different deciders to see what is happening and where it went wrong.

So we decided on a few key features of what we called 'Decider combinator 2.0':

• Multiple conditions with and/or combinations.
• Quick visual representation of the signal state.
• Selection of input between red and green wires.
• Multiple outputs.

The GUI of the Decider combinator 2.0

With these changes, the usage of the combinator became so much easier, intuitive, and transparent. You can easily see by opening the GUI what is the state of the signals, how the logic is constructed, and what the end-goal of the decision is.

Description for all combinators

You may have noticed it in a few previous FFF images, we now added a custom description field to all the combinators. This will make it easy to remember what the combinator is doing, how it works, or such. It is stored in blueprints and so will be invaluable for copying in someone elses insane contraptions.

Input/Output on Arithmetic combinator

Once we got used to the input output slots of the new decider, we started to miss it when using the arithmetic combinator, so we added it there too, and made it a side-by-side layout.

The Selector combinator

We hinted a new combinator type few times before, and it was certainly interesting to read about the different guesses people made. This post from Kulinda from Reddit seems to be the closest guess, so congratulations to winning the guessing game :)

This is selector combinator. The primary function of it was motivated by a specific operation, which was very cumbersome to do, and practically impossible to do in a generic way.
The function is indexing signals to process them one by one in some additional logic.
For example if you have a list of needed materials, you can use the Selector combinator to index the 1st item, another to index the 2nd item, etc.

The new selector combinator

It has some specific uses and modes (which is still subject to change):

• Output the signal at the given index (sorted from biggest to smallest or vice versa).
• Output the count of input signals.
• Output a random signal from the inputs (with a custom update interval).
• Output the stack size of the input item.
• Output the rocket capacity of the input item (useful for Space Age logistics).
• Transfer the quality of an input signal (more on that another day perhaps).

Some of these could have been solved with custom signals in other places, like a 'stack size' signal for arithmetic combinator to output the stack size of items. But we decided to go this way for cleanliness of design and better discoverability.

Since the scope of the Selector combinator is quite broad, there is also room for further functions we could give it, if you have some ideas, we would welcome them.

This is not the last post about circuit network.
Since the decider combinators ability to specify from which wire(s) it should read is very nice, we plan to make more improvements in this direction also on other places.
There are new things entities do with circuit network, but it is for another time.

As always, let us know what you think at the usual places.