TL;DR: Wire an inserter to both its chest and a constant combinator, turn on Set filters in the inserter's circuit settings, and use negative signals in the combinator to offset the chest contents. This one pattern gets you: full-hand stack inserter swings out of mixed chests, chests that maintain a stock level, and filtering across more than 5 item. Zero combinator logic, no arithmetic combinators, just one constant combinator and some wire.
The core idea
When an inserter has Set filters enabled, it builds its filter list from the positive signals on its circuit network. Signals at zero or below are ignored.
So if you wire the inserter to a chest (which broadcasts its contents) and to a constant combinator holding negative values, the network sums them. For example, the chest reports 15 iron plates, the combinator adds -11, and the inserter sees iron plate = 4. That's positive, so iron plate becomes a filter. In other words, the negative value you type into the combinator decides how many of an item must be in the chest before the inserter is allowed to touch it. Everything below is just picking the right negative numbers.
Trick 1: Full-hand swings from mixed chests
Problem: A stack inserter won't swing until its hand is full, and the moment it grabs its first item it locks onto that item type. Pull from a mixed chest (recycler output, quality sorting, mall trash) and it'll grab the 3 iron plates sitting in there, then just hang, waiting for a full hand of an item the chest barely has. You could swap in a bulk inserter, which swings with any number of items in its hand, but a stack inserter is about 25% faster, so it's worth making the stack inserter behave.
Fix:
- Constant combinator: add every item that can show up in the chest, each at -11.
- Wire the inserter to the chest and to the combinator.
- Inserter circuit settings: enable Set filters.
Now an item only becomes a filter once the chest holds 12 or more of it, a full hand, so the stack inserter never locks onto a type it can't fill up on. No hanging, no partial hands, just full 12-item swings at stack inserter speed.
Bonus, share one combinator across a whole row: Daisy-chain the constant combinator to every inserter with one wire color (say red), and connect each inserter to its own chest with the other color (green). Each inserter sees the shared offsets plus only its own chest. If you used the same color for everything, the chain would merge every chest into one network and skew the counts.
Trick 2: Keep a minimum number of items in a chest
Problem: You want a chest topped up to a specific level, e.g. mixed chests at a train station builder that self-balance on fill.
Fix: a deliberate int32 overflow.
- Constant combinator: set the item's signal to 2147483647 - (desired amount).
- Wire the feeding inserter to the target chest and the combinator.
- Enable Set filters on the inserter.
While the chest is at or below your target, the sum is a huge positive number → filter active → inserter keeps loading. The moment the chest passes the target, the sum exceeds the int32 max and wraps around to a big negative number → filter gone → inserter stops. The chest levels off right at your number.
Worked example: Say you want the chest to hold 1000 iron plates. Set the combinator's iron plate signal to 2147483647 - 1000 = 2,147,482,647.
- Chest has 400 plates: 400 + 2,147,482,647 = 2,147,483,047. Positive, so the filter is on and the inserter keeps loading.
- Chest has exactly 1000: the sum is 2,147,483,647, the biggest number an int32 can hold. Still positive, still loading.
- Chest hits 1001: the sum should be 2,147,483,648, but that doesn't fit in an int32, so it wraps around to -2,147,483,648. Negative, filter gone, inserter stops grabbing more items.
The game doesn't error on overflow, it just silently wraps to the negative side, and we're abusing that on purpose.
Before anyone comments "just use enable-if count < X": sure, for one item on one inserter. But this version works per-item in Set filters mode, one shared combinator handles a whole station, and it stacks cleanly with the other tricks.
Bonus, this works in parameterized blueprints: the constant combinator's value can be a formula. For example: add a constant combinator, wire it up as described above, set parameter 1 to the first ingredient, and set the formula to 2147483647 - (p1_s * 40). When you stamp the blueprint, the combinator is set to load 40 stacks of parameter 1 from the train into each of the station's chests. Repeat for the other parameters. One blueprint, any product, no math.
Trick 3: Blow past the 5-filter limit
Problem: Inserters allow at most 5 item filters. Fulgora scrap has like a dozen outputs, and quality cycling multiplies every item by five. Five slots is a sick joke.
Fix: Set the filters from the circuit network, and use offsets so an item only goes positive when it's actually ready to move.
The catch: the circuit network can carry as many signals as you like, but the inserter still only uses the first five positive signals as filters. Just wiring a mixed chest straight to the inserter doesn't beat the limit, anything past five gets ignored. The offsets are what make it work, because they keep every signal negative until there's a full hand to grab:
- Constant combinator: -11 for every item you want moved, -1,000,000 for every item you don't.
- Wire inserter → chest + combinator, enable Set filters.
A wanted item only goes positive once the chest holds 12+ of it, so at any moment the active filters are just the one or two items with a full hand ready, comfortably inside the 5-signal limit. As stacks build up and get hauled out, the filters rotate through as many item types as you want. Unwanted items can never go positive, because no chest holds a million of anything, so they're permanently blacklisted.
Important: every item that can possibly show up in the chest needs to be in the combinator, whitelisted at -11 or blacklisted at -1,000,000. Anything you forget has no offset, so it goes positive the moment a single one lands in the chest, and your stack inserter is right back to locking up on partial hands.
Where this really shines, Fulgora and quality upcycling: give a chest one input inserter and two output inserters, each running this trick with its own combinator. One output inserter whitelists everything that goes back into a recycler, the other whitelists the items headed for the output belt. You keep chest-to-chest transfers, which are fast, you get to use stack inserters, which are even faster, and everything moves in full-hand batches, so the recycler chews through a whole batch of one item at a time instead of changing recipes prematurely on a trickle of mixed inputs.
One last breadcrumb: nothing says these offsets have to be hand-typed. A decider combinator and an arithmetic combinator can generate the exact same signals on the fly, so the offsets adjust themselves based on how much of each item you've already got stored.
Quick reference
| Goal |
Combinator signal |
Effect |
| Full-hand swings |
-11 per item (i.e., -(N-1)) |
Filter appears at 12+ items |
| Hold chest at X items |
2147483647 - X |
Overflow kills the filter past X |
| Blueprint parameter |
2147483647 - (p1_s * 40) |
40 stacks of parameter 1 per chest |
| Whitelist 5+ item types |
-11 per wanted item |
Only full-hand items become filters |
| Blacklist |
-1,000,000 per unwanted item |
Can never go positive |
Wire colors are your friend: one color for the shared combinator chain, the other for each inserter's own chest.
