# Satisfactory Conveyor Belt & Logistics Guide (Smart Belts, Balancers & Limiters) - **Game:** Satisfactory - **Category:** Automation - **Author:** LongBeam (https://guides-factory.com/about) - **Difficulty:** Beginner - **Reading time:** 9 min - **Published:** 2026-09-22 - **Updated:** 2026-09-22 - **Tags:** belt-balancer, load-balancer, ratio-splitter, smart-splitter - **Adapted from:** [Use Smart Belts For Easy Logistics in Satisfactory](https://www.youtube.com/watch?v=fBC9pQnvtLw) - **Canonical URL:** https://guides-factory.com/guides/satisfactory-conveyor-belt-logistics-guide-smart-belts-balancers-limiters --- ## 🎯 The core idea > Manifolds are the fast, easy way to feed a factory, but the moment a build needs an exact number of resources on a belt instead of "probably enough," it's time for a load balancer, a belt balancer, a limiter, or a ratio splitter -- four related but distinct pieces of belt logistics that this guide breaks down one at a time, following one creator's dedicated breakdown video and cross-checked against the current Satisfactory Wiki's splitter and merger mechanics. ## A load balancer splits one line into several equal ones ![A five-lane load balancer build, showing a splitter feeding a sixth recycled line back into the system through a priority merger](https://api.guides-factory.com/media/uploads/2026/08/final_0064_O5RENRo.jpg) A load balancer takes one dedicated resource line and splits its output equally across several destinations -- a full Mark 1 belt (60 items/min) through a three-way splitter gives 20 items/min down each output. That works cleanly whenever the target number of outputs divides evenly by two or three, since every Conveyor Splitter only ever has three outputs. A five-lane split doesn't divide evenly, so the workaround is to split into six lines instead, feed the sixth line back into the start through a **Priority Merger** with that returning line's input set to high priority, and let the system settle -- which is exactly what this guide's source video demonstrates, running five Mark 5 belts at a steady 130 items/min once the recycled sixth line is prioritized correctly. ## Odd numbers like seven need an extra layer of splitting ![A one-to-seven load balancer build, showing the input split into three lines that each split again to reach seven balanced outputs](https://api.guides-factory.com/media/uploads/2026/08/final_0106.jpg) A five-lane split isn't the only awkward number -- seven doesn't divide evenly by two or three either. The source video's fix follows the same principle at a larger scale: split the input into three lines instead of two, split each of those into three again to get nine, then merge two of the nine back into a priority input and let the remaining seven run forward. Because the per-minute number is small, the displayed rate flickers between six and seven on each line as the game's internal counting catches up, but the long-run average across all seven lines balances out evenly. ## Get the priority backwards and the balance falls apart ![A smart splitter set to overflow, positioned ahead of a load balancer to divert excess resources instead of letting the system back up](https://api.guides-factory.com/media/uploads/2026/08/final_0169.jpg) If the recycled line isn't the one set to high priority on the merger, the returning resources back up instead of feeding evenly back into the split, and the balancer becomes visibly lopsided -- some outputs pulling ahead while others starve. The fix demonstrated in the source video is a **Smart Splitter** placed before the imbalanced section, with its second output set to overflow, so any excess is diverted to another line or another facility instead of clogging the balancer. Getting the priority merger's input order right the first time avoids the stuttering start this workaround exists to fix. ## A belt balancer solves a different problem: merging without overloading ![A two-in, two-out belt balancer build, showing two input belts each split and cross-merged into two output belts](https://api.guides-factory.com/media/uploads/2026/08/final_0401.jpg) Where a load balancer starts from one line, a **belt balancer** starts from several. Merging multiple full belts directly can push the combined total past the belt's max throughput and throttle the whole line, so a belt balancer splits every incoming belt into as many parts as there are outgoing belts, then cross-merges one piece from each input into each output. A two-in/two-out balancer needs two splitters and two mergers; the source video also builds three-in/three-out and even a two-in/five-out version -- the same five-lane trick from the load balancer section, doubled up on the input side, using lifted belts to keep the crossing lines from turning into spaghetti. ## Limiters throttle a belt to a specific number, no splitting math required ![A belt limiter build showing a Mark 1 belt running at partial capacity alongside a Mark 3 belt to produce an exact combined throughput](https://api.guides-factory.com/media/uploads/2026/08/final_0755.jpg) A **belt limiter** (a smaller belt tier feeding into a larger one) is the simplest way to cap a line at a specific number of resources per minute -- run a Mark 1 belt (max 60/min) into a factory instead of a Mark 3, and the input is throttled to 60/min regardless of how much the source can supply. The source video shows several ways to combine limiting with splitting to hit oddly specific numbers, like reaching exactly 250 items/min by throttling a 270/min Mark 3 line down through a Mark 1 branch and recombining it with the untouched remainder. There's no single correct way to do this -- it's whichever combination of belt tiers and splits gets to the target number. ## Ratio splitters send a fraction forward and recycle the rest ![A ratio splitter build showing a splitter sending one-third of its output forward while merging the other two-thirds to recycle elsewhere](https://api.guides-factory.com/media/uploads/2026/08/final_0990.jpg) A **ratio splitter** flips the load balancer's structure: instead of merging outputs together to combine them, it merges two of a splitter's three outputs to recycle them, sending only the third fraction forward. A simple one-third ratio splitter needs one splitter and one merger; the source video builds down to a one-twelfth ratio splitter by chaining several ratio splits together, which on a full Mark 1 belt works out to just 5 resources per minute reaching the target facility -- useful for feeding a low-consumption recipe without wasting an entire dedicated line on it. ## Priority mergers and Smart Splitters do the actual balancing work ![A close-up of a priority merger receiving a recycled resource line, with a smart splitter set to overflow visible feeding into the main line](https://api.guides-factory.com/media/uploads/2026/08/final_1132.jpg) Every one of these builds -- load balancers, belt balancers, limiters, ratio splitters -- ultimately relies on the same two pieces of infrastructure: a **Priority Merger**, which always pulls from its designated high-priority input first so a recycled or returning line never gets starved, and a **Smart Splitter**, which can be set to send its overflow output only when the main line is already full. Learning these two building blocks well enough to combine on the fly is what makes the more complex compound builds -- like the two-in/five-out belt balancer this guide's source video finishes on -- approachable instead of intimidating. ## What this guide's source video doesn't cover: sushi belts and a bus layout Two related logistics terms come up often in the wider Satisfactory community that this guide's source video doesn't touch directly. A **sushi belt** carries multiple different item types mixed together on a single belt, sorted out downstream by Smart Splitters filtering on item type -- a genuinely different approach from the single-resource balancers covered here, and one that trades simplicity for compactness. A **bus system** is a factory layout built around one or more long trunk belts running the length of a base, with individual production lines tapping off it as needed, which is really an architectural choice about belt organization on a factory's floor at the whole-base level rather than a specific splitter build. Neither is demonstrated step by step in the source video, so treat this guide as the balancing toolkit and those two as the layout philosophies that toolkit gets used inside of. ## Manifold vs balancer: when the extra complexity is worth it ![A finished, compact belt logistics build compressed into a small footprint, illustrating how these builds can be turned into reusable blueprints](https://api.guides-factory.com/media/uploads/2026/08/final_1258.jpg) None of this replaces a manifold for most builds -- a manifold is faster to place and self-balances reasonably well as long as every connected machine can keep up with supply, which covers the majority of early and mid-game factories. Load balancers, belt balancers, limiters and ratio splitters earn their extra part count specifically when a build needs a *guaranteed* exact number on a belt: matching an odd-numbered machine count precisely, feeding two factories a fixed even split of a scarce resource, or throttling a byproduct line to exactly what a downstream recipe consumes. The source video's own advice is worth repeating: once one of these builds works, compress it and save it as a blueprint, since a working balancer design should only need to be solved once per ratio. ## How this guide was fact-checked The Conveyor Splitter and Conveyor Merger mechanics this guide relies on -- three outputs per splitter, priority input behavior on a Priority Merger, and the overflow-routing behavior of a Smart Splitter -- are confirmed on the current Satisfactory Wiki and unchanged by the belt-related fixes in recent patches, which addressed conveyor lift interactions rather than splitter or merger logic itself. All of the specific numeric examples (the 130/min five-lane balance, the 300/min and 250/min limiter combinations, the one-twelfth ratio splitter reaching 5/min) come directly from this guide's source video's own on-screen builds. The sushi belt and bus system definitions are general community terminology, included because they're closely related concepts the source video doesn't itself demonstrate. ## What this guide doesn't answer This guide doesn't walk through the specific one-to-twelve or one-to-thirteen load balancer designs the source video mentions but explicitly leaves for a future video -- those follow the same divide-by-two-or-three logic covered here, just with more splitting layers. It also doesn't cover belt compressors (combining several partially-full belts into fewer full ones), which the source video treats as a related but separate topic with its own dedicated video. Finally, it doesn't give a full walkthrough of building a sushi belt or a whole-base bus layout, since neither is demonstrated step by step in this guide's source material and each deserves its own dedicated guide.