Every large Minecraft base eventually drowns in chests. You dig, you raid, you farm, and the loot piles up faster than you can file it. An item sorter fixes that: items flow in at one end, and each type lands in its own labeled chest with no input from you.

What makes sorters feel like magic is that they have no moving parts you ever touch. Once built, the whole thing runs on a single quiet redstone trick that exploits exactly how hoppers count their contents. Understand that one trick and you can build a sorter of any width.

This guide is pinned to Minecraft 1.21.4 Java Edition. Hopper transfer timing and comparator readouts behave the same way as they have since the 1.13 era, so the build is stable, but Bedrock hopper mechanics differ and this design does not port directly.

How a hopper actually moves items

Before any sorting, you need the base mechanic. A hopper pulls items from a container above it and pushes items into a container in front of its spout. It does both on a fixed schedule.

Key numbers for 1.21.4 Java:

  • A hopper transfers 1 item per transfer cycle.
  • A transfer cycle is 8 game ticks, which is 0.4 seconds (4 transfers per second).
  • A hopper stops pushing the instant it is powered by redstone. A powered hopper is frozen: it neither pulls nor pushes.

That last point is the entire foundation of sorting. We are going to leave one hopper powered (locked) almost all the time, and let it transfer only when it holds the right item.

Hoppers are "lazy." An unpowered hopper that has nothing to do still checks its neighbors on the 8-tick cycle, which costs a tiny bit of server performance. A large sorter wall is many hoppers ticking at once. It is fine for a survival base, but it is why huge auto-sorters can show up in lag reports.

The comparator reads container fullness

The second ingredient is the redstone comparator and its ability to measure how full a container is.

Point a comparator out of the back of a container (chest, hopper, barrel, dropper) and it outputs a signal strength proportional to how full that container is, on the 0 to 15 scale. An empty container outputs 0. A completely full container outputs 15.

The formula Minecraft uses, simplified, is: it sums the fraction of each slot that is filled, averages across all slots, scales to 14, and adds 1 if anything at all is present. The practical consequence for sorters is the part that matters:

  • A single hopper has 5 slots.
  • One full stack of 64 items spread across that hopper produces a low comparator reading.
  • To force a comparator on a hopper to read a clean signal strength of 1, you need a specific minimum quantity of items in it.

This is where the filter design comes from.

The overstack filter trick

Here is the core of every hopper sorter ever built.

Take the filter hopper, the one that decides whether a given item belongs in this slot, and pre-load it like this:

  1. Place 1 of your filter item in each of the first 4 slots of the hopper.
  2. Place a full stack (64) of an unstackable-with-anything-else "ballast" item in the 5th slot, OR, more commonly, place enough of the filter item itself so that the hopper holds a precise, near-full quantity.

The standard, most reliable recipe most builders use: place 1 item in slots 1 through 4, then top the 5th slot up so the hopper is sitting at exactly 41 items of the filter type, or use the classic "4 single items plus one stack of a renamed/non-mergeable item" layout. The goal is identical either way: the filter hopper is almost full but never completely full, and crucially, it can always accept exactly one more of the matching item.

When the matching item arrives:

  • It drops into the filter hopper and tops it off.
  • The hopper's comparator reading ticks up.
  • That extra single item is the one that gets pushed down into the storage chest below.
  • The hopper is now back to its baseline near-full state, ready for the next match.

When a non-matching item arrives, the filter hopper is already holding singles of the filter item in slots 1 to 4 and is full enough that the wrong item cannot find an empty slot to settle into. It slides past to the next sorter in the line.

The whole sorter is just a row of hoppers, each one rigged to be "starving for exactly one specific item and full of everything else."

Use items that do not stack with anything common as your filler when possible, or use the precise-count method. The failure people hit most often is filler items leaking into storage because the filter hopper was not loaded to the right quantity. Count twice.

Step-by-step: a two-channel sorter

Build one channel first, confirm it works, then tile it. Here is a clean single channel.

  1. Place a storage chest on the ground. This is where sorted items end up. A double chest is fine.
  2. Place a hopper on top of the chest, feeding down into it. This is the filter hopper.
  3. Behind the filter hopper, place a solid block. On the side of that block facing away from the chest, place a redstone comparator reading out of the filter hopper. Set it to the default compare mode (front torch unlit).
  4. Run the comparator output into a redstone line that powers the hopper directly above the filter hopper. This upper hopper is the item-stream hopper that carries items along the wall.

Wait. Reverse that logic carefully, because this is where most first builds fail. The standard reliable wiring is:

  • The item stream travels through a top row of hoppers, each pointing toward the next.
  • Below each stream hopper sits a filter hopper feeding into a chest.
  • The comparator reads the filter hopper and, when it detects the +1 match, sends power that locks the stream hopper above for long enough to let the matched item drop into the filter hopper instead of being carried onward.
  1. Pre-load the filter hopper using the overstack recipe above: singles of your target item in 4 slots, ballast in the 5th, leaving room for exactly one more of the target.
  2. Test it. Drop a stack of the target item plus a stack of junk into the start of the stream. The target should accumulate in the chest. The junk should pass through to the end.

A common mistake is making the stream hoppers point into the filter hoppers directly. If the stream hopper can freely dump into the filter hopper, wrong items get one tick to slip in before the lock fires, and your storage slowly contaminates. The lock has to hold the stream hopper closed by default and release only on a match. Build one channel and watch it for several minutes before tiling.

Tiling the wall and handling overflow

Once a single channel sorts cleanly, repeat it sideways. Each new channel is an identical chest plus filter hopper plus comparator, fed by the same continuous top stream of hoppers. Items that match nowhere ride the stream to the very end.

That end is the overflow. Always build one, because an unsorted item with no home will eventually back up the entire stream and jam the sorter. The simplest overflow is a final chest at the end of the line that catches everything unmatched. When you see items in the overflow, you add a new channel for that type.

For a smooth feed, items usually enter the sorter through a trash-can-style input: a chest or hopper that you dump loot into, which trickles items onto the stream at the hopper's natural 0.4 second rate. Feeding too fast does not break correctness, but it does create visible backlog because each hopper still only moves one item per cycle.

Throughput ceiling: a single hopper line moves 2.5 items per second on average once you account for the lock cycles. For a mob or item farm that produces faster than that, split the input across multiple parallel stream lines, or use water streams and dropper-based encoders to feed multiple sorter walls. Do not expect one hopper line to keep up with an industrial gold farm.

Common failure modes

These are the issues that turn up again and again. Check them in order when a sorter misbehaves.

  • Wrong items in a chest. The filter hopper was loaded incorrectly, usually too empty, so junk found a free slot. Empty it, reload with the exact overstack recipe, and confirm the comparator reads a steady low value at rest.
  • Target item rides past its chest. The comparator is not powering the lock, or the lock timing is too short. Verify the comparator is in compare mode and that the redstone reaches the correct stream hopper.
  • Everything jams. The overflow is full or missing. Items with no destination backed up the stream. Add or empty the overflow chest.
  • Sorter works, then fails after a reload. Hopper sorters are sensitive to chunk loading order. If the sorter sits on a chunk border, parts of it may tick before others on world load. Keep an entire sorter wall inside one chunk where possible, or /forceload the area.
  • Stackable mismatches. Some items look distinct but share behavior, and a few non-stackables (like potions, enchanted books, shulker boxes with contents) cannot be filtered by this method because they will not top off a hopper slot predictably. Sort those with dedicated single-item lines or accept them in overflow.

Why this design has lasted

The overstack sorter has survived a decade of Minecraft updates because it depends only on two stable facts: hoppers move one item every 8 ticks, and comparators read container fullness on the 0 to 15 scale. Neither has meaningfully changed through 1.21.4. There are flashier sorters that use droppers, observers, and bubble columns for speed or compactness, but every one of them is still, underneath, a comparator watching a hopper that is hungry for exactly one item.

Build the single channel until you understand precisely why the matched item drops and the others do not. After that, the wall is just copy and paste, and you will never lose a stack to the wrong chest again.

Sources & further reading: