Automation Guide: Conveyors, Sorters, Mass Drivers Tips

Automation in Mindustry ties together item/liquid/payload transport, crafting, unit production, power routing and logic to make bases run without micro-management. Good automation keeps production balanced, prevents clogs, isolates power, and lets factories and unit assemblers run at full throughput.

Core concepts

• Input vs output: any conveyor (or duct/conduit) pointing away from a block counts as that block’s output; any conveyor pointing into a block counts as its input. Touching blocks are treated the same as conveyors for input/output detection.
• Throughput and blocking: many blocks have internal item capacities (conveyors, routers, junctions, unloaders, factories) and will clog if they fill. Some transport blocks transfer items instantly (so they do not clog) — use them where you need infinite instantaneous throughput behavior.
• Overdrive and speed boosts: Overdrive Projectors (and other boost sources) multiply production/consumption/power rates of connected blocks. All inputs and outputs scale with boost; plan supply lines and power accordingly.

Item transport: conveyors and “light-speed” devices

Mindustry has multiple conveyor families with different behaviors and purposes. Choose based on throughput needs, routing flexibility, and whether you need batch/phase/payload transport.

Basics

• Standard Conveyors: cheapest, accept inputs from sides, output forward, limited throughput. Useful for simple uni-directional lines and to keep schematic cost low. Beware conveyors adjacent to crafters: they can unintentionally accept block outputs; use a junction or duct/router variant where needed.
• Junctions: store small amounts (6 items per line, 12 total) and split flows; useful as tiny buffers or to stop unwanted inputs when placed beside producers.
• Routers / Distributors: divide items evenly among outputs. Routers leak fractions when chained (every output receives a fraction of input), and their internal capacity means they can clog if placed directly adjacent to some factories. Use gates instead when you need non-clogging equal distribution.
• Sorters / Inverted Sorters: instant-transfer “light-speed” devices (no item capacity) that route items based on a selected filter. Sorter: matching items go forward; non-matching go to sides. Inverted Sorter flips that behavior. Because they instant-transfer, they cannot clog and are ideal for compact distribution to many crafters. Unconfigured sorters push to the sides; pairs of null sorters can act as infinite-throughput splitters.
• Overflow / Underflow Gates: instant-transfer devices that prioritize forward or side outputs depending on congestion. Use them to siphon excess items or to split flows without clog risk.
• Plastanium / Surge Conveyors (batch conveyors): build batches of the same item (max batch size, then move as a unit). They have three functional states: loading (accept inputs), transporting (move batch), unloading (unpack into three sides). Starting/loading segments only accept one item type at a time and have lower effective throughput than later segments; plan multiple starting segments for full line throughput and avoid mixing item types on a single starting segment — split mixed flows with Sorters.
  • Plastanium Conveyors: very high throughput; starting segments block if fed mixed items; transitions/bridges create new starting segments across gaps/obstacles.
  • Surge Conveyors: similar batch behavior to Plastanium but specific differences exist; they accept only batch inputs from other surge conveyors and output individual items when not chained.
• Phase / Bridge Conveyors and Duct Bridges: allow long-range or over-obstacle transport. They accept inputs from all sides except the connected side and can be manually linked to another Bridge/Phase (bridge: up to 3 tiles; phase: longer link range). Destinations distribute to open sides if they have no own destination. Planning/drag-placing tries to space them for cost efficiency.
• Duct family (Ducts, Duct Routers, Duct Unloaders, Duct Bridges): Erekir-style one-sided input devices. Duct Router only accepts from the back and evenly distributes or filters; Duct Unloaders pull only from the opposite block and are safe to use to unload blocks without clogging. Ducts accept a single item and are useful for directional runs.
• Payload conveyors and mass drivers: carry block/unit payloads (blocks or unspawned units). Payload Loaders/Unloaders and Reinforced Payload Conveyors handle payloads locally; Payload Mass Drivers and Large Mass Drivers link distant payload points. Payload loaders hold many items (e.g., 100) and will fill payloads based on the most populous contained item; payloads output when the payload’s own capacity is reached. Payload Routers sort payloads; Payload Unloaders wait until payload is empty before outputting on their facing side.
• Special unloaders and unloader behavior:
  • Unloader (Serpulo): matches throughput of Titanium Conveyors; it unloads equally in all directions and can equalize inventories between adjacent blocks (bi-directional). It will not unload from some blocks or turrets. Filters control what it outputs.
  • Duct Unloaders / Reinforced variants have their own rules (one-sided input behavior or inability to unload from core).
• Incinerators and Slag Incinerators: use to dispose of unwanted items to prevent clogs. Useful after separators or disassemblers that output mixed items.

Practical pipeline tips

• Never feed mixed item streams directly into Plastanium/Surge starting segments; split them first with Sorters or dedicated starting segments per item type.
• For very high throughput (e.g., compressed-plastanium factories, large reconstructors), use Plastanium Conveyors or batch conveyors and plan multiple starting segments; be mindful that starting segments provide only half throughput of later segments.
• Use Sorters, Inverted Sorters, Overflow/Underflow Gates, and Null Sorter patterns where you need instant, clog-free routing or compact filter networks.
• Place Junctions, Routers, or Duct Routers to prevent unwanted side-inputs from crafters or to split flows intentionally. Duct Router accepts inputs from only one side, making it ideal adjacent to producers to avoid accidental grabs.

Liquids and pumps

• Most pumps and conduits accept inputs from multiple sides; Bridge Conduits and Bridge Pumps allow linking across gaps (manual linking like Bridge Conveyors).
• Pumps have tile-based maximum rates; match pump types and counts to consumer demand. Reinforced Pumps, Rotary Pumps, Impulse Pumps and others have distinct rates — check a pump’s per-tile and max capacities when scaling.
• Liquid sharing: Liquid Containers, Junctions, and Tanks share contents with nearby blocks with effectively near-infinite throughput — use them as large shared buffers where many consumers need the same fluid.

Power networks and routing

• Power is transmitted instantaneously across networks of power nodes, beams, and conductors. Power deficits slow down all blocks in that network proportionally.
• Battery Diode (or Battery/Diode combined behavior) can move stored power from one network (upstream) into another (downstream) without allowing the networks to auto-connect; use it to isolate production-related grids from defense grids and to prevent base-wide brownouts.
• Beam Towers automatically connect to all blocks within range and can store power; Surge Towers and other directional transmitters have set ranges and can be planned at regular intervals for efficient layout.
• Overdrive/boosters increase power demand of affected blocks (they also increase item and liquid consumption proportionally). When you overdrive industrial blocks, plan for higher resource throughput and higher power draw.

Crafting blocks, factories and unit production

• Crafters, smelters, reconstructors and assemblers accept items from any input conveyors/touches that they see as inputs. They will not accept materials they cannot use.
• Unit assemblers and reconstructor families have complex inputs and large steady demands (e.g., higher-tier reconstructors need many Cryofluid Mixers, Compressors, Crucibles). Plan upstream supply of sand, titanium, cryofluid and silicon carefully; batch conveyors and high-throughput lines are often necessary.
• Refabricators can take longer or shorter than fabricators; recommended fabricator:refabricator ratios exist to avoid backlogs (examples: Ship refabricator continuous ratio around 4:5; Mech refab 8:9; Tank refab ~7:6 depending on tiers).
• Many unit assemblers expose construction boundaries where Assembler Modules must be placed to enable higher tiers. Basic Assembler Modules don’t need power to upgrade tier, but must be powered to act as secondary payload input points. Assemblers consume payload-form inputs (units/blocks) and clear their input payload capacity after the unit is produced.

Logic, processors and automation control

• Logic Processors (three main sizes) run instructions per second at different speeds and ranges:
  • Small: 120/s (2/tick), mid-range
  • Medium: 480/s (8/tick)
  • Large: 1500/s (25/tick), requires coolant
  • Editor-only extreme processors exist with much higher capacity
• Processors can:
  • Read sensors and block properties (health, item counts, first item, capacity, progress, rotation, coords, size, enabled state, etc.)
  • Control blocks (enable/disable, set filters, control doors and conveyors, write to memory cells, print messages)
  • Bind and command units
• Use logic to:
  • Toggle conveyors, gates and doors (via the enabled property) for routing, safety or bottleneck control.
  • Read inventories and sensor states to prevent overproduction, maintain buffers, or trigger imports/launches.
  • Control complex unit routing (e.g., Unit Cargo Loaders / Manifolds coordinate delivery to matching unload points).
• UI blocks:
  • Switches and levers provide booleans directly to processors.
  • Message blocks and Displays allow output and visual feedback; Print and Printflush send text to message blocks.
• Practical examples:
  • Use a processor to disable a conveyor when an item count exceeds a target (sensor + jump + control enabled).
  • Cycle Manifolds by placing filters on Unit Cargo Unload Points and let Manifolds deposit into matching filters; Manifolds will take up to 100 of the most abundant item from their loader and deliver to matching unload points.

Common design patterns and troubleshooting

• Buffers and balancing: use Containers and Unloaders (which can equalize inventories with connected containers/cores) to create shared inventory pools for multiple factories.
• Preventing brownouts: isolate heavy industrial loads (mixers, weavers, compressors) on separate power networks or use Battery Diodes so defense turrets cannot cause production slowdowns.
• Handling mixed outputs: Separators and Disassemblers output multiple item types randomly or in mixes — follow them with Sorters + Incinerators (or Overflow Gates to storage) to avoid long-term clogs.
• Avoid placing capacity-bearing distribution blocks (Routers, Distributors) directly adjacent to factory outputs unless you want a buffer; where clog-free behavior is needed use instant-transfer devices (Sorters, Gates).
• When using batch conveyors (Plastanium/Surge), ensure multiple starting/loading segments for peak throughput and avoid crossing obstacles that create new starting segments; bridges/transitions reduce throughput because they create new starting segments on the far side.
• Plan pump counts and liquid buffers to meet the sustained per-second consumption of large reconstructors or unit assemblers — many require large quantities of cryofluid or coolant that conduits alone may not be able to supply without liquid containers/tanks acting as shared buffers.

This overview provides the automation building blocks and patterns you’ll use to scale production reliably. Combine high-throughput transport (batch conveyors, bridge conveyors), instant-transfer routing (Sorters/Gates), logic control (processors + sensors), and isolated power networks to keep factories and defenses running at full speed without constant micromanagement.