diff --git a/src/main/java/cam72cam/immersiverailroading/IRItems.java b/src/main/java/cam72cam/immersiverailroading/IRItems.java
index 1629ed728..933fba42f 100644
--- a/src/main/java/cam72cam/immersiverailroading/IRItems.java
+++ b/src/main/java/cam72cam/immersiverailroading/IRItems.java
@@ -5,6 +5,7 @@
 
 public class IRItems {
 	public static ItemRollingStock ITEM_ROLLING_STOCK = new ItemRollingStock();
+	public static ItemConsistPlacer ITEM_CONSIST_PLACER = new ItemConsistPlacer();
 	public static ItemRollingStockComponent ITEM_ROLLING_STOCK_COMPONENT = new ItemRollingStockComponent();
 	public static ItemLargeWrench ITEM_LARGE_WRENCH = new ItemLargeWrench();
 	public static ItemHook ITEM_HOOK = new ItemHook();
diff --git a/src/main/java/cam72cam/immersiverailroading/ImmersiveRailroading.java b/src/main/java/cam72cam/immersiverailroading/ImmersiveRailroading.java
index fe120fa0a..93b2f0748 100644
--- a/src/main/java/cam72cam/immersiverailroading/ImmersiveRailroading.java
+++ b/src/main/java/cam72cam/immersiverailroading/ImmersiveRailroading.java
@@ -2,6 +2,7 @@
 
 import cam72cam.immersiverailroading.entity.*;
 import cam72cam.immersiverailroading.entity.physics.chrono.ServerChronoState;
+import cam72cam.immersiverailroading.gui.ConsistPlacerGui;
 import cam72cam.immersiverailroading.gui.overlay.GuiBuilder;
 import cam72cam.immersiverailroading.items.ItemPaintBrush;
 import cam72cam.immersiverailroading.library.GuiTypes;
@@ -13,6 +14,7 @@
 import cam72cam.immersiverailroading.net.*;
 import cam72cam.immersiverailroading.registry.DefinitionManager;
 import cam72cam.immersiverailroading.registry.EntityRollingStockDefinition;
+import cam72cam.immersiverailroading.registry.ConsistDefinitionManager;
 import cam72cam.immersiverailroading.render.SmokeParticle;
 import cam72cam.immersiverailroading.render.block.RailBaseModel;
 import cam72cam.immersiverailroading.render.item.*;
@@ -85,6 +87,8 @@ public void commonEvent(ModEvent event) {
 				Packet.register(ClientPartDragging.DragPacket::new, PacketDirection.ClientToServer);
 				Packet.register(ClientPartDragging.SeatPacket::new, PacketDirection.ClientToServer);
 				Packet.register(GuiBuilder.ControlChangePacket::new, PacketDirection.ClientToServer);
+				Packet.register(ConsistPlacerGui.ConsistItemChangePacket::new, PacketDirection.ClientToServer);
+				Packet.register(ConsistPlacePacket::new, PacketDirection.ClientToServer);
 				Packet.register(ItemPaintBrush.PaintBrushPacket::new, PacketDirection.ClientToServer);
 
 				ServerChronoState.register();
@@ -135,6 +139,7 @@ public void clientEvent(ModEvent event) {
 				ItemRender.register(IRItems.ITEM_TRACK_BLUEPRINT, new TrackBlueprintItemModel());
 				ItemRender.register(IRItems.ITEM_ROLLING_STOCK_COMPONENT, new StockItemComponentModel());
 				ItemRender.register(IRItems.ITEM_ROLLING_STOCK, new StockItemModel());
+				ItemRender.register(IRItems.ITEM_CONSIST_PLACER, new Identifier(MODID, "items/consist"));
 				ItemRender.register(IRItems.ITEM_LARGE_WRENCH, ObjItemRender.getModelFor(new Identifier(MODID, "models/item/wrench/wrench.obj"), new Vec3d(0.5, 0, 0.5), 2));
 				ItemRender.register(IRItems.ITEM_CONDUCTOR_WHISTLE, ObjItemRender.getModelFor(new Identifier(MODID, "models/item/whistle.obj"), new Vec3d(0.5, 0.75, 0.5), 0.1f));
 				ItemRender.register(IRItems.ITEM_GOLDEN_SPIKE, ObjItemRender.getModelFor(new Identifier(MODID, "models/item/goldenspike/goldenspike.obj"), new Vec3d(0.5, 0.5, 0.5), 0.1f));
@@ -228,6 +233,7 @@ public void postRender(EntityMoveableRollingStock entity, RenderState state, flo
 				Particles.SMOKE = Particle.register(SmokeParticle::new, SmokeParticle::renderAll);
 
 				ClientPartDragging.register();
+				ConsistDefinitionManager.load();
 				break;
 			case RELOAD:
 				DefinitionManager.initDefinitions();
diff --git a/src/main/java/cam72cam/immersiverailroading/gui/ConsistPlacerGui.java b/src/main/java/cam72cam/immersiverailroading/gui/ConsistPlacerGui.java
new file mode 100644
index 000000000..e89119b17
--- /dev/null
+++ b/src/main/java/cam72cam/immersiverailroading/gui/ConsistPlacerGui.java
@@ -0,0 +1,678 @@
+package cam72cam.immersiverailroading.gui;
+
+import cam72cam.immersiverailroading.IRItems;
+import cam72cam.immersiverailroading.gui.components.ListSelector;
+import cam72cam.immersiverailroading.library.GuiTypes;
+import cam72cam.immersiverailroading.registry.ConsistDefinition;
+import cam72cam.immersiverailroading.registry.ConsistDefinitionManager;
+import cam72cam.immersiverailroading.registry.DefinitionManager;
+import cam72cam.immersiverailroading.registry.EntityRollingStockDefinition;
+import cam72cam.mod.MinecraftClient;
+import cam72cam.mod.entity.Player;
+import cam72cam.mod.gui.helpers.GUIHelpers;
+import cam72cam.mod.gui.screen.Button;
+import cam72cam.mod.gui.screen.IScreen;
+import cam72cam.mod.gui.screen.IScreenBuilder;
+import cam72cam.mod.gui.screen.TextField;
+import cam72cam.mod.item.ItemStack;
+import cam72cam.mod.net.Packet;
+import cam72cam.mod.render.opengl.RenderState;
+import cam72cam.mod.serialization.TagField;
+
+import java.util.*;
+import java.util.stream.Collectors;
+
+public class ConsistPlacerGui implements IScreen {
+    public static Context context;
+    private ConsistDefinition current;
+
+    //Main Panel
+    private Button selection;
+    private Button newConsist;
+    private Button editCurrent;
+    private Button deleteCurrent;
+    private ListSelector<ConsistDefinition> definitionsSelector;
+
+    public ConsistPlacerGui() {
+        this(MinecraftClient.getPlayer().getHeldItem(Player.Hand.PRIMARY));
+    }
+
+    private ConsistPlacerGui(ItemStack stack) {
+        stack = stack.copy();
+        current = ConsistDefinitionManager.getConsistDefinition(stack.getTagCompound().getString("multi_unit"));
+        if (context == null) {
+            context = new Context();
+        }
+        context.currentEditing = -1;
+        context.player = MinecraftClient.getPlayer();
+    }
+
+    @Override
+    public void init(IScreenBuilder screen) {
+        context.target = Panel.MAIN;
+        int xtop = -GUIHelpers.getScreenWidth() / 2;
+        int ytop = -GUIHelpers.getScreenHeight() / 4;
+        if(context.panel == Panel.EDIT) {
+            current = context.current;
+            context.current = null;
+            context.currentName = null;
+            context.currentAdditionPage = 0;
+        }
+
+        selection = new Button(screen, xtop, ytop, 150, 20, "Select Unit Def") {
+            @Override
+            public void onClick(Player.Hand hand) {
+                definitionsSelector.setVisible(!definitionsSelector.isVisible());
+            }
+        };
+        ytop += 20;
+        newConsist = new Button(screen, xtop, ytop, 150, 20, "New MultiUnit") {
+            @Override
+            public void onClick(Player.Hand hand) {
+                context.currentPage = 0;
+                openEditPanel();
+            }
+        };
+        ytop += 20;
+        editCurrent = new Button(screen, xtop, ytop, 150, 20, "Edit Current") {
+            @Override
+            public void onClick(Player.Hand hand) {
+                context.current = current;
+                context.currentName = current.getName();
+                openEditPanel();
+            }
+        };
+        ytop += 20;
+        deleteCurrent = new Button(screen, xtop, ytop, 150, 20, "Delete Current") {
+            @Override
+            public void onClick(Player.Hand hand) {
+                if ("Confirm Deletion".equals(this.getText())){
+                    ConsistDefinitionManager.removeConsist(current);
+                    this.setText("Delete Current");
+                    current = null;
+                    boolean flag = false;
+                    if(definitionsSelector.isVisible()){
+                        definitionsSelector.setVisible(false);
+                        flag = true;
+                    }
+
+                    definitionsSelector = new ListSelector<ConsistDefinition>(screen, 150, 200, 20, null,
+                                                                              ConsistDefinitionManager.getValidConsists()) {
+                        @Override
+                        public void onClick(ConsistDefinition option) {
+                            current = option;
+                            if(current != null) {
+                                editCurrent.setVisible(true);
+                                deleteCurrent.setVisible(true);
+                                editCurrent.setEnabled(current.isEditable());
+                                deleteCurrent.setEnabled(current.isEditable());
+                                deleteCurrent.setText("Delete Current");
+                            }
+                        }
+                    };
+                    if(flag) {
+                        definitionsSelector.setVisible(true);
+                    }
+                    deleteCurrent.setVisible(false);
+                    editCurrent.setVisible(false);
+                } else {
+                    this.setText("Confirm Deletion");
+                }
+            }
+        };
+
+        definitionsSelector = new ListSelector<ConsistDefinition>(screen, 150, 200, 20, current,
+                                                                  ConsistDefinitionManager.getValidConsists()) {
+            @Override
+            public void onClick(ConsistDefinition option) {
+                current = option;
+                if(current != null) {
+                    editCurrent.setVisible(true);
+                    deleteCurrent.setVisible(true);
+                    editCurrent.setEnabled(current.isEditable());
+                    deleteCurrent.setEnabled(current.isEditable());
+                    deleteCurrent.setText("Delete Current");
+                }
+            }
+        };
+
+        definitionsSelector.setVisible(false);
+
+        if(context.panel == Panel.EDIT) {
+            definitionsSelector.search(context.mainSearchingName);
+            definitionsSelector.setPage(context.currentMainPage);
+            definitionsSelector.setVisible(true);
+        }
+
+        if(current == null){
+            editCurrent.setVisible(false);
+            deleteCurrent.setVisible(false);
+        }
+        context.panel = Panel.MAIN;
+    }
+
+    private void openEditPanel() {
+        context.target = Panel.EDIT;
+        context.currentMainPage = definitionsSelector.getPage();
+        context.mainSearchingName = definitionsSelector.getSearching();
+        GuiTypes.CONSIST_EDIT.open(context.player);
+    }
+
+    @Override
+    public void onEnterKey(IScreenBuilder iScreenBuilder) {
+        iScreenBuilder.close();
+    }
+
+    @Override
+    public void onClose() {
+        if (context.target != Panel.MAIN) {
+            return;
+        }
+        if (current != null){
+            new ConsistItemChangePacket(current.getName()).sendToServer();
+        }
+        context = null;
+    }
+
+    @Override
+    public void draw(IScreenBuilder builder, RenderState state) {
+        IScreen.super.draw(builder, state);
+        GUIHelpers.drawRect(0, 0, 150, GUIHelpers.getScreenHeight(), 0xEE000000);
+        GUIHelpers.drawRect(150, 0, GUIHelpers.getScreenWidth() - 150, GUIHelpers.getScreenHeight(), 0xCC000000);
+    }
+
+    public static class Context {
+        public int currentEditing;
+        public Panel panel;
+        public Panel target;
+        public Player player;
+        public List<ConsistDefinition.Stock> stockListBuilder;
+        public int currentPage = 0;
+        public ConsistDefinition.Stock building;
+        public ConsistDefinition current;
+        public String currentName;
+        public int currentMainPage;
+        public int currentAdditionPage;
+        public String mainSearchingName;
+        public String additionSearchingName;
+
+        public void swapFront(int index) {
+            if(index - 1 >= 0 && index < stockListBuilder.size()) {
+                ConsistDefinition.Stock s = stockListBuilder.get(index);
+                stockListBuilder.set(index, stockListBuilder.get(index - 1));
+                stockListBuilder.set(index - 1, s);
+            }
+        }
+
+        public void swapBack(int index) {
+            if(index >= 0 && index + 1 < stockListBuilder.size()) {
+                ConsistDefinition.Stock s = stockListBuilder.get(index);
+                stockListBuilder.set(index, stockListBuilder.get(index + 1));
+                stockListBuilder.set(index + 1, s);
+            }
+        }
+
+        public void duplicate(int index) {
+            ConsistDefinition.Stock s = stockListBuilder.get(index);
+            stockListBuilder.add(index, s.copy());
+        }
+
+        public int index(int i) {
+            return currentPage * 7 + i;
+        }
+
+        public Context() {
+            this.panel = Panel.MAIN;
+            this.stockListBuilder = new LinkedList<>();
+        }
+    }
+
+    public static class EditPanel implements IScreen {
+        private List<Button> num;
+        private List<Button> stockDef;
+        private List<Button> swapPrev;
+        private List<Button> swapNext;
+        private List<Button> copy;
+        private List<Button> delete;
+
+        private Button prevPage;
+        private Button nextPage;
+        private Button addStock;
+        private Button saveConsist;
+        private TextField name;
+
+        @Override
+        public void init(IScreenBuilder screen) {
+            context.target = Panel.EDIT;
+
+            num = new ArrayList<>(7);
+            stockDef = new ArrayList<>(7);
+            swapPrev = new ArrayList<>(7);
+            swapNext = new ArrayList<>(7);
+            copy = new ArrayList<>(7);
+            delete = new ArrayList<>(7);
+
+            int xtop = -170;
+            int ytop = GUIHelpers.getScreenHeight() / 4 - 70;
+            int currX = xtop;
+            int spacing = 4;
+            for (int i = 0; i < 7; i++) {
+                Button button = new Button(screen, currX, ytop, 25, 20, "No." + i) {
+                    @Override
+                    public void onClick(Player.Hand hand) {}
+                };
+                button.setEnabled(false);
+                num.add(button);
+                currX += 25 + spacing;
+                int finalI = i;
+                stockDef.add(new Button(screen, currX, ytop, 200, 20, "") {
+                    @Override
+                    public void onClick(Player.Hand hand) {
+                        openAdditionPanel(context.index(finalI));
+                    }
+                });
+                currX += 200 + spacing;
+                swapPrev.add(new Button(screen, currX, ytop, 20, 20, "↑") {
+                    @Override
+                    public void onClick(Player.Hand hand) {
+                        context.swapFront(context.index(finalI));
+                        updatePage();
+                    }
+                });
+                currX += 20 + spacing;
+                swapNext.add(new Button(screen, currX, ytop, 20, 20, "↓") {
+                    @Override
+                    public void onClick(Player.Hand hand) {
+                        context.swapBack(context.index(finalI));
+                        updatePage();
+                    }
+                });
+                currX += 20 + spacing;
+                copy.add(new Button(screen, currX, ytop, 30, 20, "Dup") {
+                    @Override
+                    public void onClick(Player.Hand hand) {
+                        context.duplicate(context.index(finalI));
+                        updatePage();
+                    }
+                });
+                currX += 30 + spacing;
+                delete.add(new Button(screen, currX, ytop, 30, 20, "Del") {
+                    @Override
+                    public void onClick(Player.Hand hand) {
+                        context.stockListBuilder.remove(context.index(finalI));
+                        updatePage();
+                    }
+                });
+                ytop += 20 + spacing;
+                currX = xtop;
+            }
+            currX = -120;
+            prevPage = new Button(screen, currX, ytop, 60, 20, "Prev Page") {
+                @Override
+                public void onClick(Player.Hand hand) {
+                    if(context.currentPage > 0) {
+                        context.currentPage -= 1;
+                        updatePage();
+                    }
+                }
+            };
+            currX += 80;
+            addStock = new Button(screen, currX, ytop, 100, 20, "Add Stock") {
+                @Override
+                public void onClick(Player.Hand hand) {
+                    openAdditionPanel();
+                }
+            };
+            currX += 120;
+            nextPage = new Button(screen, currX, ytop, 60, 20, "Next Page") {
+                @Override
+                public void onClick(Player.Hand hand) {
+                    if(context.currentPage < context.stockListBuilder.size() / 7) {
+                        context.currentPage += 1;
+                        updatePage();
+                    }
+                }
+            };
+            xtop = -GUIHelpers.getScreenWidth() / 2;
+            ytop = -GUIHelpers.getScreenHeight() / 4;
+            name = new TextField(screen, xtop, ytop, 199, 20);
+            name.setValidator(s -> {
+                if(s == null || s.isEmpty()) {
+                    saveConsist.setText("Set a name before save");
+                } else {
+                    saveConsist.setText("Save");
+                }
+                context.currentName = name.getText();
+                return true;
+            });
+            ytop += 24;
+            saveConsist = new Button(screen, xtop, ytop, 200, 20, "Save") {
+                @Override
+                public void onClick(Player.Hand hand) {
+                    if(name.getText().isEmpty()) {
+                        //Reject
+                        return;
+                    }
+                    ConsistDefinition.ConsistDefBuilder builder1 = ConsistDefinition.ConsistDefBuilder.of(name.getText());
+                    for (ConsistDefinition.Stock stock1 : context.stockListBuilder) {
+                        builder1.appendStock(stock1);
+                    }
+                    ConsistDefinition build = builder1.build();
+                    ConsistDefinitionManager.addConsist(build);
+                    context.stockListBuilder.clear();
+                    context.current = ConsistDefinitionManager.getConsistDefinition(build.getName());
+                    GuiTypes.CONSIST_PLACER_MAIN.open(context.player);
+                }
+            };
+
+            if(context.panel == Panel.MAIN){
+                if (context.current == null) {
+                    context.stockListBuilder = new ArrayList<>();
+                } else {
+                    context.stockListBuilder = new ArrayList<>(context.current.getStocks());
+                    name.setText(context.currentName);
+                }
+            }
+            if(context.panel == Panel.ADDITION) {
+                name.setText(context.currentName);
+            }
+            if(name.getText().isEmpty()) {
+                saveConsist.setText("Set a name before save");
+            }
+
+            updatePage();
+            context.panel = Panel.EDIT;
+        }
+
+        private void updatePage() {
+            if (context.stockListBuilder.isEmpty()) {
+                for (int i = 0; i < 7; i++) {
+                    this.num.get(i).setVisible(false);
+                    this.stockDef.get(i).setVisible(false);
+                    this.swapPrev.get(i).setVisible(false);
+                    this.swapNext.get(i).setVisible(false);
+                    this.copy.get(i).setVisible(false);
+                    this.delete.get(i).setVisible(false);
+                }
+            } else {
+                for (int i = 0; i < 7; i++) {
+                    if (context.index(i) < context.stockListBuilder.size()) {
+                        this.num.get(i).setVisible(true);
+                        this.stockDef.get(i).setVisible(true);
+                        this.stockDef.get(i).setText(
+                                context.stockListBuilder.get(context.index(i)).definition.name());
+                        this.num.get(i).setText("#" + context.index(i));
+                        this.swapPrev.get(i).setVisible(true);
+                        this.swapNext.get(i).setVisible(true);
+                        this.copy.get(i).setVisible(true);
+                        this.delete.get(i).setVisible(true);
+                    } else {
+                        this.num.get(i).setVisible(false);
+                        this.stockDef.get(i).setVisible(false);
+                        this.swapPrev.get(i).setVisible(false);
+                        this.swapNext.get(i).setVisible(false);
+                        this.copy.get(i).setVisible(false);
+                        this.delete.get(i).setVisible(false);
+                    }
+                    if (context.index(i) == 0) {
+                        this.swapPrev.get(i).setVisible(false);
+                    }
+                    if (context.index(i) == context.stockListBuilder.size() - 1) {
+                        this.swapNext.get(i).setVisible(false);
+                    }
+                }
+            }
+
+            prevPage.setEnabled(context.currentPage != 0);
+            nextPage.setEnabled(context.currentPage != ((context.stockListBuilder.size() - 1) / 7));
+        }
+
+        private void openAdditionPanel() {
+            context.currentEditing = -1;
+            context.target = Panel.ADDITION;
+            context.currentName = name.getText();
+            GuiTypes.CONSIST_ADD_STOCK.open(context.player);
+        }
+
+        private void openAdditionPanel(int num) {
+            context.currentEditing = num;
+            context.target = Panel.ADDITION;
+            GuiTypes.CONSIST_ADD_STOCK.open(context.player);
+        }
+
+        @Override
+        public void onEnterKey(IScreenBuilder builder) {
+            builder.close();
+        }
+
+        @Override
+        public void onClose() {
+            //Auto-save
+            if(!name.getText().isEmpty()) {
+                ConsistDefinition.ConsistDefBuilder builder1 = ConsistDefinition.ConsistDefBuilder.of(name.getText());
+                for (ConsistDefinition.Stock stock1 : context.stockListBuilder) {
+                    builder1.appendStock(stock1);
+                }
+                ConsistDefinition build = builder1.build();
+                ConsistDefinitionManager.addConsist(build);
+                context.stockListBuilder.clear();
+                context.current = ConsistDefinitionManager.getConsistDefinition(build.getName());
+            }
+            GuiTypes.CONSIST_PLACER_MAIN.open(context.player);
+        }
+
+        @Override
+        public void draw(IScreenBuilder builder, RenderState state) {
+            IScreen.super.draw(builder, state);
+            GUIHelpers.drawRect(0, 0, GUIHelpers.getScreenWidth(), GUIHelpers.getScreenHeight(), 0xCC000000);
+        }
+    }
+
+    public static class AdditionPanel implements IScreen {
+        //Stock Addition Panel
+        private Button stock;
+        private ListSelector<EntityRollingStockDefinition> stockSelector;
+        private Button texture;
+        private ListSelector<String> textureSelector;
+        private Button direction;
+        private Button finish;
+
+        @Override
+        public void init(IScreenBuilder screen) {
+            context.target = Panel.ADDITION;
+
+            String finishStr = "Select a Stock Before Save";
+            EntityRollingStockDefinition def1 = null;
+            if (context.currentEditing != -1) {
+                context.building = context.stockListBuilder.get(context.currentEditing);
+                finishStr = "Finish";
+                def1 = context.building.definition;
+            } else {
+                context.building = new ConsistDefinition.Stock();
+                context.building.direction = ConsistDefinition.Direction.FORWARD;
+            }
+
+
+            int xtop = -GUIHelpers.getScreenWidth() / 2;
+            int ytop = -GUIHelpers.getScreenHeight() / 4;
+            stock = new Button(screen, xtop, ytop, 200, 20, def1 == null ? "Select Stock" : def1.name()) {
+                @Override
+                public void onClick(Player.Hand hand) {
+                    if(textureSelector != null && textureSelector.isVisible()){
+                        stockSelector.setVisible(true);
+                        textureSelector.setVisible(false);
+                    }else{
+                        stockSelector.setVisible(!stockSelector.isVisible());
+                    }
+                }
+            };
+            //We should have a better way to do this...
+            HashSet<String> deduplicate = new HashSet<>();
+            HashSet<String> d = new HashSet<>();
+            for(EntityRollingStockDefinition definition : DefinitionManager.getDefinitions()){
+                if(deduplicate.contains(definition.name())) {
+                    d.add(definition.name());
+                }
+                deduplicate.add(definition.name());
+            }
+            Map<String, EntityRollingStockDefinition> definitionMap = DefinitionManager.getDefinitions().stream().collect(
+                    Collectors.toMap(definition -> {
+                        if(d.contains(definition.name())) {
+                            return String.format("%s(%s)", definition.name(), definition.defID.split("/")[2].replace(".json", ""));
+                        }
+                        return definition.name();
+                    }, def -> def, (old, new1) -> old, TreeMap::new));
+            stockSelector = new ListSelector<EntityRollingStockDefinition>(screen, 200, 200, 20, def1, definitionMap) {
+                @Override
+                public void onClick(EntityRollingStockDefinition option) {
+                    finish.setText("Finish");
+                    if (context.building != null) {
+                        context.building.defID = option.defID;
+                        context.building.definition = option;
+                        stock.setText(option.name());
+                        textureSelector = new ListSelector<String>(screen, 200, 200, 20, context.building.texture,
+                                                                   context.building.definition.textureNames.entrySet().stream()
+                                                                                                           .collect(Collectors.toMap(
+                                                                                                           Map.Entry::getValue, Map.Entry::getKey,
+                                                                                                           (u, v) -> u, LinkedHashMap::new))
+                        ) {
+                            @Override
+                            public void onClick(String option) {
+                                context.building.texture = option;
+                                if(option.isEmpty()) {
+                                    texture.setText("Tex Variant:" + "default");
+                                } else {
+                                    texture.setText("Tex Variant:" + option);
+                                }
+                            }
+                        };
+                        if(context.building.definition.textureNames.keySet().stream().findFirst().isPresent()){
+                            context.building.texture = context.building.definition.textureNames.keySet().stream().findFirst().get();
+                        } else {
+                            context.building.texture = null;
+                        }
+                    }
+                }
+            };
+            if(context.additionSearchingName != null) {
+                stockSelector.search(context.additionSearchingName);
+            }
+
+            stockSelector.setPage(context.currentAdditionPage);
+            stockSelector.setVisible(true);
+            ytop += 25;
+            texture = new Button(screen, xtop, ytop, 200, 20, "Tex Variant:default") {
+                @Override
+                public void onClick(Player.Hand hand) {
+                    if(textureSelector == null) {
+                        return;
+                    }
+
+                    if(stockSelector.isVisible()) {
+                        stockSelector.setVisible(false);
+                        textureSelector.setVisible(true);
+                    } else {
+                        textureSelector.setVisible(!textureSelector.isVisible());
+                    }
+                }
+            };
+            if(context.building.definition != null){
+                textureSelector = new ListSelector<String>(screen, 200, 200, 20, context.building.texture,
+                                                           context.building.definition.textureNames.entrySet().stream()
+                                                                                                   .collect(
+                                                                                                                        Collectors.toMap(
+                                                                                                                                Map.Entry::getValue,
+                                                                                                                                Map.Entry::getKey,
+                                                                                                                                (u, v) -> u,
+                                                                                                                                LinkedHashMap::new))
+                ) {
+                    @Override
+                    public void onClick(String option) {
+                        context.building.texture = option;
+                        if (option.isEmpty()) {
+                            texture.setText("Tex Variant:" + "default");
+                        } else {
+                            texture.setText("Tex Variant:" + option);
+                        }
+                    }
+                };
+            }
+            ytop += 25;
+            direction = new Button(screen, xtop, ytop, 200, 20, "") {
+                @Override
+                public void onClick(Player.Hand hand) {
+                    context.building.direction = ClickListHelper.next(context.building.direction, hand);
+                    this.setText("Direction:"+ context.building.direction);
+                }
+            };
+            ytop += 25;
+            finish = new Button(screen, xtop, ytop, 200, 20, finishStr) {
+                @Override
+                public void onClick(Player.Hand hand) {
+                    if (context.building != null && context.building.definition != null) {
+                        if (context.currentEditing == -1) {
+                            context.stockListBuilder.add(context.building);
+                        } else {
+                            context.stockListBuilder.set(context.currentEditing, context.building);
+                            context.currentEditing = -1;
+                        }
+                        context.building = null;
+                        context.currentAdditionPage = stockSelector.getPage();
+                        context.additionSearchingName = stockSelector.getSearching();
+                        GuiTypes.CONSIST_EDIT.open(context.player);
+                    }
+                }
+            };
+            direction.setText("Direction:"+ context.building.direction);
+            if(context.building.texture != null && !context.building.texture.isEmpty()){
+                texture.setText("Tex Variant:" + context.building.texture);
+            }
+            context.panel = Panel.ADDITION;
+        }
+
+        @Override
+        public void onEnterKey(IScreenBuilder builder) {
+            builder.close();
+        }
+
+        @Override
+        public void onClose() {
+            context.currentAdditionPage = stockSelector.getPage();
+            context.additionSearchingName = stockSelector.getSearching();
+            GuiTypes.CONSIST_EDIT.open(context.player);
+        }
+
+        @Override
+        public void draw(IScreenBuilder builder, RenderState state) {
+            IScreen.super.draw(builder, state);
+            GUIHelpers.drawRect(0, 0, 200, GUIHelpers.getScreenHeight(), 0xEE000000);
+            GUIHelpers.drawRect(200, 0, GUIHelpers.getScreenWidth() - 150, GUIHelpers.getScreenHeight(), 0xCC000000);
+        }
+    }
+
+    public enum Panel {
+        MAIN, EDIT, ADDITION
+    }
+
+    public static class ConsistItemChangePacket extends Packet {
+        @TagField
+        private String def;
+
+        public ConsistItemChangePacket() {
+        }
+
+        public ConsistItemChangePacket(String def) {
+            this.def = def;
+        }
+
+        @Override
+        protected void handle() {
+            Player player = this.getPlayer();
+            ItemStack stack = player.getHeldItem(Player.Hand.PRIMARY);
+            if(stack.is(IRItems.ITEM_CONSIST_PLACER)) {
+                stack.setTagCompound(stack.getTagCompound().setString("multi_unit", def));
+            }
+            player.setHeldItem(Player.Hand.PRIMARY, stack);
+        }
+    }
+}
diff --git a/src/main/java/cam72cam/immersiverailroading/gui/components/ListSelector.java b/src/main/java/cam72cam/immersiverailroading/gui/components/ListSelector.java
index 894e486d7..c5ab2365b 100644
--- a/src/main/java/cam72cam/immersiverailroading/gui/components/ListSelector.java
+++ b/src/main/java/cam72cam/immersiverailroading/gui/components/ListSelector.java
@@ -147,6 +147,23 @@ public void render(ButtonRenderer<T> renderer) {
         }
     }
 
+    public void search(String s) {
+        search.setText(s);
+    }
+
+    public String getSearching() {
+        return search.getText();
+    }
+
+    public void setPage(int page) {
+        this.page = page;
+        updateSearch(search.getText());
+    }
+
+    public int getPage() {
+        return page;
+    }
+
     @FunctionalInterface
     public interface ButtonRenderer<T> {
         void render(Button button, int x, int y, T value);
diff --git a/src/main/java/cam72cam/immersiverailroading/items/ItemConsistPlacer.java b/src/main/java/cam72cam/immersiverailroading/items/ItemConsistPlacer.java
new file mode 100644
index 000000000..360a3488c
--- /dev/null
+++ b/src/main/java/cam72cam/immersiverailroading/items/ItemConsistPlacer.java
@@ -0,0 +1,64 @@
+package cam72cam.immersiverailroading.items;
+
+import cam72cam.immersiverailroading.ImmersiveRailroading;
+import cam72cam.immersiverailroading.library.GuiTypes;
+import cam72cam.immersiverailroading.library.Permissions;
+import cam72cam.immersiverailroading.net.ConsistPlacePacket;
+import cam72cam.immersiverailroading.registry.ConsistDefinition;
+import cam72cam.immersiverailroading.registry.ConsistDefinitionManager;
+import cam72cam.mod.entity.Player;
+import cam72cam.mod.item.ClickResult;
+import cam72cam.mod.item.CreativeTab;
+import cam72cam.mod.item.CustomItem;
+import cam72cam.mod.item.ItemStack;
+import cam72cam.mod.math.Vec3d;
+import cam72cam.mod.math.Vec3i;
+import cam72cam.mod.text.PlayerMessage;
+import cam72cam.mod.util.Facing;
+import cam72cam.mod.world.World;
+
+import java.util.*;
+import java.util.List;
+
+public class ItemConsistPlacer extends CustomItem {
+    public ItemConsistPlacer() {
+        super(ImmersiveRailroading.MODID, "item_consist_placer");
+    }
+
+    @Override
+    public List<CreativeTab> getCreativeTabs() {
+        return Collections.singletonList(ItemTabs.MAIN_TAB);
+    }
+
+    @Override
+    public ClickResult onClickBlock(Player player, World world, Vec3i pos, Player.Hand hand, Facing facing, Vec3d hit) {
+        //We handle it at client
+        if (world.isServer) {
+            return ClickResult.ACCEPTED;
+        }
+
+        if (!player.hasPermission(Permissions.STOCK_ASSEMBLY)) {
+            return ClickResult.REJECTED;
+        }
+
+        ItemStack stack = player.getHeldItem(hand);
+
+        ConsistDefinition def = ConsistDefinitionManager.getConsistDefinition(stack.getTagCompound().getString("multi_unit"));
+        if (def == null) {
+            player.sendMessage(PlayerMessage.direct("Invalid consist"));
+            return ClickResult.REJECTED;
+        }
+
+        new ConsistPlacePacket(def, pos).sendToServer();
+
+        return ClickResult.ACCEPTED;
+    }
+
+    @Override
+    public void onClickAir(Player player, World world, Player.Hand hand) {
+        super.onClickAir(player, world, hand);
+        if (world.isClient) {
+            GuiTypes.CONSIST_PLACER_MAIN.open(player);
+        }
+    }
+}
diff --git a/src/main/java/cam72cam/immersiverailroading/library/GuiText.java b/src/main/java/cam72cam/immersiverailroading/library/GuiText.java
index f46552ead..82c59b667 100644
--- a/src/main/java/cam72cam/immersiverailroading/library/GuiText.java
+++ b/src/main/java/cam72cam/immersiverailroading/library/GuiText.java
@@ -26,9 +26,18 @@ public enum GuiText {
 	SELECTOR_PLATE_BOILER("selector.plate_boiler"),
 	SELECTOR_CAST_SINGLE("selector.cast_single"),
 	SELECTOR_CAST_REPEAT("selector.cast_repeat"),
-	SELECTOR_PAINTBRUSH_RANDOM("selector.paintbrush_random"),
-	SELECTOR_PAINTBRUSH_TO_STOCK("selector.paintbrush_apply_to_stock"),
-	SELECTOR_PAINTBRUSH_TO_TRAIN("selector.paintbrush_apply_to_train"),
+    SELECTOR_PAINTBRUSH_RANDOM("selector.paintbrush_random"),
+    SELECTOR_PAINTBRUSH_TO_STOCK("selector.paintbrush_apply_to_stock"),
+    SELECTOR_PAINTBRUSH_TO_TRAIN("selector.paintbrush_apply_to_train"),
+
+    SELECTOR_ALIGNMENT("selector.alignment"),
+	SELECTOR_TEXTFIELD("selector.textfield"),
+	SELECTOR_FONT("selector.font"),
+
+	SLIDER_OFFSET("slider.offset"),
+	SLIDER_LINE_SPACING("slider.line_spacing"),
+
+	CHECKBOX_GLOBAL("checkbox.global"),
 
 	TRACK_TYPE("track.type"),
 	TRACK_LENGTH("track.length"),
@@ -42,7 +51,7 @@ public enum GuiText {
 	TRACK_DIRECTION("track.direction"),
 	TRACK_PLACE_BLUEPRINT_TRUE("track.place_blueprint_true"),
 	TRACK_PLACE_BLUEPRINT_FALSE("track.place_blueprint_false"),
-	
+
 	LOCO_WORKS("loco.works"),
 //	LOCO_HORSE_POWER("loco.horse_power"),
 	LOCO_POWER("loco.power"),
diff --git a/src/main/java/cam72cam/immersiverailroading/library/GuiTypes.java b/src/main/java/cam72cam/immersiverailroading/library/GuiTypes.java
index a9f2a0e0e..9a7fedde8 100644
--- a/src/main/java/cam72cam/immersiverailroading/library/GuiTypes.java
+++ b/src/main/java/cam72cam/immersiverailroading/library/GuiTypes.java
@@ -27,6 +27,9 @@ public class GuiTypes {
     public static final BlockGUI RAIL_PREVIEW = GuiRegistry.registerBlock(TileRailPreview.class, TrackGui::new);
     public static final GUI TRACK_EXCHANGER = GuiRegistry.register(new Identifier(ImmersiveRailroading.MODID, "TRACK_EXCHANGER"), TrackExchangerGui::new);
     public static final GUI PAINT_BRUSH = GuiRegistry.register(new Identifier(ImmersiveRailroading.MODID, "PAINT_BRUSH"), PaintBrushPicker::new);
+    public static final GUI CONSIST_PLACER_MAIN = GuiRegistry.register(new Identifier(ImmersiveRailroading.MODID, "consist"), ConsistPlacerGui::new);
+    public static final GUI CONSIST_EDIT = GuiRegistry.register(new Identifier(ImmersiveRailroading.MODID, "consist_edit"), ConsistPlacerGui.EditPanel::new);
+    public static final GUI CONSIST_ADD_STOCK = GuiRegistry.register(new Identifier(ImmersiveRailroading.MODID, "consist_add"), ConsistPlacerGui.AdditionPanel::new);
 
     public static final BlockGUI STEAM_HAMMER = GuiRegistry.registerBlockContainer(TileMultiblock.class, SteamHammerContainer::new);
     public static final BlockGUI CASTING = GuiRegistry.registerBlock(TileMultiblock.class, GuiTypes::createMultiblockScreen);
diff --git a/src/main/java/cam72cam/immersiverailroading/net/ConsistPlacePacket.java b/src/main/java/cam72cam/immersiverailroading/net/ConsistPlacePacket.java
new file mode 100644
index 000000000..6853be355
--- /dev/null
+++ b/src/main/java/cam72cam/immersiverailroading/net/ConsistPlacePacket.java
@@ -0,0 +1,80 @@
+package cam72cam.immersiverailroading.net;
+
+import cam72cam.immersiverailroading.library.ChatText;
+import cam72cam.immersiverailroading.registry.ConsistDefinition;
+import cam72cam.immersiverailroading.registry.DefinitionManager;
+import cam72cam.immersiverailroading.util.SpawnUtil;
+import cam72cam.mod.math.Vec3i;
+import cam72cam.mod.net.Packet;
+import cam72cam.mod.serialization.SerializationException;
+import cam72cam.mod.serialization.TagCompound;
+import cam72cam.mod.serialization.TagField;
+import cam72cam.mod.serialization.TagMapper;
+import cam72cam.mod.text.PlayerMessage;
+
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+public class ConsistPlacePacket extends Packet {
+    @TagField(mapper = StockListMapper.class)
+    public List<ConsistDefinition.Stock> stocks;
+
+    @TagField
+    public Vec3i clicking;
+
+    @TagField(mapper = StringFloatMapMapper.class)
+    public Map<String, Float> defaultCGs;
+
+    public ConsistPlacePacket() {
+    }
+
+    public ConsistPlacePacket(ConsistDefinition def, Vec3i clicking) {
+        this.stocks = def.getStocks();
+        this.clicking = clicking;
+        this.defaultCGs = def.getDefaultCGs();
+    }
+
+    @Override
+    protected void handle() {
+        if (stocks.stream()
+                  .anyMatch(stock -> (stock.definition = DefinitionManager.getDefinition(stock.defID)) == null)
+        ) {
+            //Some stock don't exist on server
+            getPlayer().sendMessage(PlayerMessage.translate(ChatText.STOCK_INVALID.toString()));
+        } else {
+            SpawnUtil.placeConsist(getPlayer(), getWorld(), clicking, stocks, defaultCGs == null ? new HashMap<>() : defaultCGs);
+        }
+    }
+
+    public static class StockListMapper implements TagMapper<List<ConsistDefinition.Stock>> {
+        @Override
+        public TagAccessor<List<ConsistDefinition.Stock>> apply(Class<List<ConsistDefinition.Stock>> type, String fieldName, TagField tag) throws SerializationException {
+            return new TagAccessor<>(
+                    (compound, stocks) -> compound.setList("stocks", stocks, stock ->
+                                                                   new TagCompound().setString("defID", stock.defID)
+                                                                                    .setEnum("direction", stock.direction)
+                                                                                    .setString("tex", stock.texture)),
+                    (compound) -> compound.getList("stocks", compound1 -> {
+                        ConsistDefinition.Stock stock = new ConsistDefinition.Stock();
+                        stock.defID = compound1.getString("defID");
+                        stock.direction = compound1.getEnum("direction", ConsistDefinition.Direction.class);
+                        stock.texture = compound1.getString("tex");
+                        return stock;
+                    }));
+        }
+    }
+
+    public static class StringFloatMapMapper implements TagMapper<Map<String, Float>> {
+        @Override
+        public TagAccessor<Map<String, Float>> apply(Class<Map<String, Float>> aClass, String s, TagField tagField) throws SerializationException {
+            return new TagAccessor<>(
+                    (compound, data) -> compound.setMap("default_cg", data,
+                                                        k -> k,
+                                                        v -> new TagCompound().setFloat("val", v)),
+                    (compound) -> compound.getMap("default_cg",
+                                                  k -> k,
+                                                  v -> v.getFloat("val")));
+        }
+    }
+}
diff --git a/src/main/java/cam72cam/immersiverailroading/registry/ConsistDefinition.java b/src/main/java/cam72cam/immersiverailroading/registry/ConsistDefinition.java
new file mode 100644
index 000000000..9a49fb3b6
--- /dev/null
+++ b/src/main/java/cam72cam/immersiverailroading/registry/ConsistDefinition.java
@@ -0,0 +1,177 @@
+package cam72cam.immersiverailroading.registry;
+
+import it.unimi.dsi.fastutil.objects.Object2FloatArrayMap;
+
+import javax.annotation.Nullable;
+import java.util.*;
+
+//Client only
+public class ConsistDefinition {
+    private final String name;
+    private final List<Stock> stocks;
+    private final boolean editable;
+    private final Map<String, Float> defaultCGs;
+    //TODO Additional tooltip
+
+    ConsistDefinition(String name, List<Stock> stocks, boolean editable, Map<String, Float> defaultCGs) {
+        this.name = name;
+        this.stocks = stocks;
+        this.editable = editable;
+        this.defaultCGs = defaultCGs;
+    }
+
+    public String getName() {
+        return name;
+    }
+
+    public List<Stock> getStocks() {
+        return stocks;
+    }
+
+    public boolean isEditable() {
+        return editable;
+    }
+
+    public Map<String, Float> getDefaultCGs() {
+        return defaultCGs;
+    }
+
+    public boolean valid() {
+        return stocks.stream().noneMatch(stock -> stock.error);
+    }
+
+    public static class ConsistDefBuilder {
+        private String name;
+        private List<Stock> stocks;
+        private Map<String, Float> defaultCGs;
+        private boolean editable = true;
+
+        private boolean isBuilt = false;
+
+        private ConsistDefBuilder(){}
+
+        public static ConsistDefBuilder of(String name) {
+            ConsistDefBuilder builder = new ConsistDefBuilder();
+            builder.name = name;
+            builder.stocks = new ArrayList<>();
+            builder.defaultCGs = new Object2FloatArrayMap<>();
+            return builder;
+        }
+
+        public void appendStock(String defID, Direction direction, String tex, Map<String, Float> defaultCGs){
+            if(isBuilt){
+                throw new UnsupportedOperationException();
+            }
+            this.appendStock(new Stock(defID, direction, tex, defaultCGs));
+        }
+
+        public void appendStock(Stock stock){
+            if(isBuilt){
+                throw new UnsupportedOperationException();
+            }
+
+            if(!stock.error){
+                if (stock.texture == null) {
+                    if (!stock.definition.textureNames.keySet().isEmpty()) {
+                        stock.texture = stock.definition.textureNames.keySet().stream().findFirst().get();
+                    }
+                } else if (!stock.definition.textureNames.containsKey(stock.texture)) {
+                    stock.texture = stock.definition.textureNames.keySet().stream().findFirst().orElse(null);
+                }
+            }
+            if(stock.controlGroup == null) {
+                stock.controlGroup = new LinkedHashMap<>();
+            }
+            if(stock.direction == null){
+                stock.direction = Direction.FORWARD;
+            }
+
+            stocks.add(stock);
+        }
+
+        public void addDefaultCG(String name, float val) {
+            defaultCGs.put(name, val);
+        }
+
+        public void setEditable(boolean editable) {
+            this.editable = editable;
+        }
+
+        public ConsistDefinition build() {
+            if(isBuilt){
+                throw new UnsupportedOperationException();
+            }
+            isBuilt = true;
+            stocks.forEach(stock -> {
+                if (stock.defID == null && stock.definition != null) {
+                    stock.defID = stock.definition.defID;
+                }
+            });
+            return new ConsistDefinition(name, stocks, editable, defaultCGs);
+        }
+    }
+
+    public static class Stock {
+        public String defID;
+        public EntityRollingStockDefinition definition;
+        public Direction direction;
+        public String texture;
+        public Map<String, Float> controlGroup;
+
+        public boolean error = false;
+
+        public Stock() {
+        }
+
+        public Stock(String defID, Direction direction, @Nullable String texture, Map<String, Float> controlGroup) {
+            this.defID = defID;
+            //Used to preserve unit def in case used stock is uninstalled
+            if (DefinitionManager.getDefinition(defID) == null) {
+                error = true;
+            } else {
+                this.definition = DefinitionManager.getDefinition(defID);
+            }
+            this.direction = direction;
+            this.texture = texture;
+            this.controlGroup = controlGroup;
+        }
+
+        public Stock copy() {
+            return new Stock(defID, direction, texture, controlGroup);
+        }
+    }
+
+    public enum Direction{
+        FORWARD,
+        REVERSE,
+        RANDOM;
+
+        private static final Random random = new Random();
+
+        public static Direction of(String direction) {
+            switch (direction) {
+                case "FLIPPED":
+                case "REVERSE":
+                    return REVERSE;
+                case "RANDOM":
+                    return RANDOM;
+                case "DEFAULT":
+                case "FORWARD":
+                default:
+                    return FORWARD;
+            }
+        }
+
+        public boolean shouldFlip() {
+            switch (this) {
+                case REVERSE:
+                    return true;
+                case RANDOM:
+                    return random.nextBoolean();
+                case FORWARD:
+                default:
+                    return false;
+            }
+        }
+    }
+}
diff --git a/src/main/java/cam72cam/immersiverailroading/registry/ConsistDefinitionManager.java b/src/main/java/cam72cam/immersiverailroading/registry/ConsistDefinitionManager.java
new file mode 100644
index 000000000..284be19fe
--- /dev/null
+++ b/src/main/java/cam72cam/immersiverailroading/registry/ConsistDefinitionManager.java
@@ -0,0 +1,134 @@
+package cam72cam.immersiverailroading.registry;
+
+import cam72cam.immersiverailroading.util.DataBlock;
+import cam72cam.mod.util.MinecraftFiles;
+
+import java.io.*;
+import java.nio.file.Files;
+import java.util.*;
+import java.util.stream.Collectors;
+
+//Client-sided
+public class ConsistDefinitionManager {
+    private static final Map<String, ConsistDefinition> display;
+
+    private static final Map<String, ConsistDefinition> playerMadeConsist;
+    private static final Map<String, ConsistDefinition> unmodifiableConsist;
+    private static final File save;
+
+    static {
+        save = new File(MinecraftFiles.getConfigDir(), "immersiverailroading_consist.cfg");
+        if (!save.exists()) {
+            try {
+                save.createNewFile();
+            } catch (IOException e) {
+                throw new RuntimeException(e);
+            }
+        }
+        playerMadeConsist = new TreeMap<>(String::compareToIgnoreCase);
+        display = new TreeMap<>(String::compareToIgnoreCase);
+        unmodifiableConsist = new HashMap<>();
+    }
+
+    public static void save() {
+        try {
+            // Structure:
+            // multi_unit [name]
+            // stock [stockName] [direction] [text variant] TODO optional: [cg:value]
+            List<String> list = new LinkedList<>();
+            list.add("//DO NOT TOUCH UNLESS YOU KNOW WHAT ARE YOU DOING");
+            for (Map.Entry<String, ConsistDefinition> entry : playerMadeConsist.entrySet()) {
+                list.add("consist "+entry.getKey().replace(" ", "^"));
+                for (ConsistDefinition.Stock stock : entry.getValue().getStocks()) {
+                    String texture = (stock.texture == null||stock.texture.isEmpty()) ? "default" : stock.texture;
+                    list.add("stock "+stock.defID+" "+stock.direction+" "+texture);
+                }
+            }
+            Files.write(save.toPath(), list);
+        } catch (IOException e) {
+            throw new RuntimeException(e);
+        }
+    }
+
+    public static void load() {
+        try {
+            // Structure:
+            // multi_unit [name]
+            // stock [stockName] [direction] [text variant] TODO optional: [cg:value]
+            List<String> lines = Files.readAllLines(save.toPath());
+            playerMadeConsist.clear();
+            display.clear();
+            ConsistDefinition.ConsistDefBuilder builder = null;
+            for (String line : lines) {
+                if (line.startsWith("consist")) {
+                    String[] split = line.split(" ");
+                    if(builder != null) {
+                        ConsistDefinition built = builder.build();
+                        playerMadeConsist.put(built.getName(), built);
+                        if (built.valid()) {
+                            display.put(built.getName(), built);
+                        }
+                    }
+                    builder = ConsistDefinition.ConsistDefBuilder.of(split[1].replace("^", " "));
+                } else if (line.startsWith("stock")) {
+                    String[] split = line.split(" ");
+                    if (builder != null) {
+                        builder.appendStock(split[1], ConsistDefinition.Direction.valueOf(split[2]), split[3], Collections.emptyMap());
+                    }
+                }
+            }
+            if(builder != null) {
+                ConsistDefinition built = builder.build();
+                playerMadeConsist.put(built.getName(), built);
+                if (built.valid()) {
+                    display.put(built.getName(), built);
+                }
+            }
+        } catch (IOException e) {
+            throw new RuntimeException(e);
+        }
+        display.putAll(unmodifiableConsist);
+    }
+
+    public static void loadUnmodifiable(DataBlock block) {
+        String name = block.getValue("name").asString();
+        ConsistDefinition.ConsistDefBuilder builder = ConsistDefinition.ConsistDefBuilder.of(name);
+        block.getBlock("default_CG").getValueMap().forEach((s, val) ->
+                                                                   builder.addDefaultCG(s, val.asFloat()));
+        block.getValues("add_tooltip").stream().map(DataBlock.Value::asString).collect(Collectors.toList()); //TODO
+        block.getBlocks("consist").stream()
+             .map(b -> {
+                 ConsistDefinition.Stock stock = new ConsistDefinition.Stock();
+                stock.defID = b.getValue("stock").asString();
+                stock.texture = b.getValue("stock").asString();
+                stock.direction = ConsistDefinition.Direction.of(b.getValue("direction").asString());
+                return stock;
+             })
+             .forEach(builder::appendStock);
+        builder.setEditable(false);
+        unmodifiableConsist.put(name, builder.build());
+    }
+
+    public static void addConsist(ConsistDefinition build) {
+        playerMadeConsist.put(build.getName(), build);
+        save();
+        load();
+    }
+
+    public static void removeConsist(ConsistDefinition current) {
+        playerMadeConsist.remove(current.getName(), current);
+        save();
+        load();
+    }
+
+    public static Map<String, ConsistDefinition> getValidConsists() {
+        return display;
+    }
+
+    public static ConsistDefinition getConsistDefinition(String name) {
+        if (name == null) {
+            return null;
+        }
+        return playerMadeConsist.get(name);
+    }
+}
diff --git a/src/main/java/cam72cam/immersiverailroading/registry/DefinitionManager.java b/src/main/java/cam72cam/immersiverailroading/registry/DefinitionManager.java
index 05dc91ccd..9d4e51892 100644
--- a/src/main/java/cam72cam/immersiverailroading/registry/DefinitionManager.java
+++ b/src/main/java/cam72cam/immersiverailroading/registry/DefinitionManager.java
@@ -9,10 +9,10 @@
 import cam72cam.immersiverailroading.util.JSON;
 import cam72cam.mod.gui.Progress;
 import cam72cam.mod.resource.Identifier;
+import com.sun.management.OperatingSystemMXBean;
 import org.apache.commons.lang3.tuple.Pair;
 
-import java.io.IOException;
-import java.io.InputStream;
+import java.io.*;
 import java.lang.management.ManagementFactory;
 import java.util.*;
 import java.util.concurrent.ExecutionException;
@@ -124,7 +124,7 @@ public static void initDefinitions() {
         }
         ImmersiveRailroading.info("Detected %sMB of memory free", maxMemory/1024/1024);
         try {
-            com.sun.management.OperatingSystemMXBean os = (com.sun.management.OperatingSystemMXBean) ManagementFactory.getOperatingSystemMXBean();
+            OperatingSystemMXBean os = (OperatingSystemMXBean) ManagementFactory.getOperatingSystemMXBean();
             maxMemory = Math.min(os.getFreePhysicalMemorySize() + runtime.totalMemory(), maxMemory);
             ImmersiveRailroading.info("Adjusted to %sMB of memory free", maxMemory/1024/1024);
         } catch (UnsatisfiedLinkError | Exception ex) {
@@ -210,7 +210,7 @@ private static void initModels() throws IOException {
 
         Progress.Bar bar = Progress.push("Loading Models", definitionIDMap.size());
 
-        Map<String, EntityRollingStockDefinition> loaded = getStockLoadingStream(definitionIDMap.entrySet()).map(tuple -> {
+        Map<String, Object> loaded = getStockLoadingStream(definitionIDMap.entrySet()).map(tuple -> {
             String defID = tuple.getKey();
             String defType = tuple.getValue();
 
@@ -228,12 +228,18 @@ private static void initModels() throws IOException {
 
                 DataBlock block = DataBlock.load(resource);
 
+                //Compatibility with poizzy v0.12.0
+                if ("multiple_unit".equals(defType)) {
+                    ConsistDefinitionManager.loadUnmodifiable(block);
+                    return null;
+                }
+
                 if (definitionIDPacks.containsKey(defID) && block.getValue("pack").asString() == null) {
                     // This is kind of a nasty hack...
                     block.getValueMap().put("pack", definitionIDPacks.get(defID));
                 }
 
-                EntityRollingStockDefinition stockDefinition = stockLoaders.get(defType).apply(defID, block);
+                Object definition = stockLoaders.get(defType).apply(defID, block);
 
                 Runtime runtime = Runtime.getRuntime();
                 if (runtime.freeMemory() < runtime.maxMemory() * 0.25) {
@@ -241,7 +247,7 @@ private static void initModels() throws IOException {
                     System.gc();
                 }
 
-                return Pair.of(stockDefinition.defID, stockDefinition);
+                return Pair.of(((EntityRollingStockDefinition) definition).defID, definition);
             } catch (Exception e) {
                 ImmersiveRailroading.error("Error loading model %s of type %s", defID, defType);
                 ImmersiveRailroading.catching(e);
@@ -254,8 +260,14 @@ private static void initModels() throws IOException {
             }
         }).filter(Objects::nonNull).collect(Collectors.toMap(Pair::getKey, Pair::getValue));
 
+
         definitions = new LinkedHashMap<>();
-        definitionIDMap.keySet().stream().filter(loaded::containsKey).forEach(x -> definitions.put(x, loaded.get(x)));
+        definitionIDMap.keySet().stream().filter(loaded::containsKey).forEach(x -> {
+            Object def = loaded.get(x);
+            if (def instanceof EntityRollingStockDefinition) {
+                definitions.put(x, ((EntityRollingStockDefinition) def));
+            }
+        });
 
         Progress.pop(bar);
     }
@@ -394,7 +406,7 @@ public static TrackDefinition getTrack(String track) {
 
     @FunctionalInterface
     private interface StockLoader {
-        EntityRollingStockDefinition apply(String defID, DataBlock data) throws Exception;
+        Object apply(String defID, DataBlock data) throws Exception;
     }
 
 }
diff --git a/src/main/java/cam72cam/immersiverailroading/registry/EntityRollingStockDefinition.java b/src/main/java/cam72cam/immersiverailroading/registry/EntityRollingStockDefinition.java
index b6132e2f8..f4b96a11f 100644
--- a/src/main/java/cam72cam/immersiverailroading/registry/EntityRollingStockDefinition.java
+++ b/src/main/java/cam72cam/immersiverailroading/registry/EntityRollingStockDefinition.java
@@ -817,6 +817,13 @@ public List<String> getTooltip(Gauge gauge) {
         return tips;
     }
 
+    public List<String> getModelerTooltip() {
+        List<String> tips = new ArrayList<>();
+        tips.add(GuiText.MODELER_TOOLTIP.toString(modelerName));
+        tips.add(GuiText.PACK_TOOLTIP.toString(packName));
+        return tips;
+    }
+
     protected StockModel<?, ?> createModel() throws Exception {
         return new StockModel<>(this);
     }
diff --git a/src/main/java/cam72cam/immersiverailroading/registry/LocomotiveDefinition.java b/src/main/java/cam72cam/immersiverailroading/registry/LocomotiveDefinition.java
index 514899fe7..279c82b13 100644
--- a/src/main/java/cam72cam/immersiverailroading/registry/LocomotiveDefinition.java
+++ b/src/main/java/cam72cam/immersiverailroading/registry/LocomotiveDefinition.java
@@ -18,7 +18,7 @@
 public abstract class LocomotiveDefinition extends FreightDefinition {
     public boolean toggleBell;
     public SoundDefinition bell;
-    private String works;
+    public String works;
     private double power_kW;
     private double traction_N;
     private Speed maxSpeed;
diff --git a/src/main/java/cam72cam/immersiverailroading/util/SpawnUtil.java b/src/main/java/cam72cam/immersiverailroading/util/SpawnUtil.java
index afeb1b1bb..1d09d2d51 100644
--- a/src/main/java/cam72cam/immersiverailroading/util/SpawnUtil.java
+++ b/src/main/java/cam72cam/immersiverailroading/util/SpawnUtil.java
@@ -1,13 +1,9 @@
 package cam72cam.immersiverailroading.util;
 
-import java.util.ArrayList;
-import java.util.Collections;
-import java.util.List;
+import java.util.*;
 
-import cam72cam.immersiverailroading.entity.EntityCoupleableRollingStock;
 import cam72cam.immersiverailroading.entity.EntityMoveableRollingStock;
 import cam72cam.immersiverailroading.entity.EntityRollingStock;
-import cam72cam.immersiverailroading.entity.physics.SimulationState;
 import cam72cam.immersiverailroading.items.ItemRollingStock;
 import cam72cam.immersiverailroading.library.ChatText;
 import cam72cam.immersiverailroading.library.Gauge;
@@ -15,9 +11,12 @@
 import cam72cam.immersiverailroading.Config.ConfigDebug;
 import cam72cam.immersiverailroading.entity.EntityBuildableRollingStock;
 import cam72cam.immersiverailroading.entity.EntityCoupleableRollingStock.CouplerType;
+import cam72cam.immersiverailroading.registry.ConsistDefinition;
 import cam72cam.immersiverailroading.registry.EntityRollingStockDefinition;
+import cam72cam.mod.entity.Entity;
 import cam72cam.mod.entity.Player;
 import cam72cam.immersiverailroading.thirdparty.trackapi.ITrack;
+import cam72cam.mod.text.PlayerMessage;
 import cam72cam.mod.util.DegreeFuncs;
 import cam72cam.mod.world.World;
 import cam72cam.mod.item.ClickResult;
@@ -102,4 +101,100 @@ public static ClickResult placeStock(Player player, Player.Hand hand, World worl
 		}
 		return ClickResult.ACCEPTED;
 	}
+
+	public static ClickResult placeConsist(Player player, World worldIn, Vec3i pos, List<ConsistDefinition.Stock> stocks, Map<String, Float> defaultCGs) {
+		if(worldIn.isClient) {
+			return ClickResult.REJECTED;
+		}
+
+		Vec3d spawnPos = new Vec3d(pos);
+		ITrack initTE = ITrack.get(worldIn, spawnPos.add(0, 0.7, 0), true);
+		if (initTE == null || !player.isCreative()) {
+			return ClickResult.REJECTED;
+		}
+		double trackGauge = initTE.getTrackGauge();
+		Gauge gauge = Gauge.from(trackGauge);
+
+		double offset;
+		float yaw = player.getYawHead();
+		List<EntityRollingStock> shutdown = new LinkedList<>();
+
+		for (int i = stocks.size() - 1; i >= 0; i--){
+			ConsistDefinition.Stock s = stocks.get(i);
+			EntityRollingStockDefinition def = s.definition;
+			initTE = ITrack.get(worldIn, spawnPos.add(0, 0.7, 0), true);
+
+			if(initTE == null) {
+				player.sendMessage(PlayerMessage.direct("Invalid position for consist detected, this consist creation is stopped!"));
+				shutdown.forEach(Entity::kill);
+				return ClickResult.REJECTED;
+			}
+
+			offset = def.getCouplerPosition(s.direction.shouldFlip() ? CouplerType.FRONT : CouplerType.BACK, gauge) - ConfigDebug.couplerRange;
+			float originalRot = yaw;
+			if (s.direction.shouldFlip()) {
+				// Flip rotation
+				yaw = (originalRot + 180);
+			}
+			EntityRollingStock stock = def.spawn(worldIn, spawnPos.add(0.5, 0.1, 0.5), yaw, gauge, s.texture);
+
+			Vec3d center = stock.getPosition();
+			center = initTE.getNextPosition(center, VecUtil.fromWrongYaw(-0.1, originalRot));
+			center = initTE.getNextPosition(center, VecUtil.fromWrongYaw(0.1, originalRot));
+			center = initTE.getNextPosition(center, VecUtil.fromWrongYaw(offset, originalRot));
+			stock.setPosition(center);
+
+			if (stock instanceof EntityMoveableRollingStock) {
+				EntityMoveableRollingStock moveable = (EntityMoveableRollingStock) stock;
+				ITrack centerte = ITrack.get(worldIn, center, true);
+				if (centerte != null) {
+					float frontDistance = moveable.getDefinition().getBogeyFront(gauge);
+					float rearDistance = moveable.getDefinition().getBogeyRear(gauge);
+					Vec3d front = centerte.getNextPosition(center, VecUtil.fromWrongYaw(frontDistance, yaw));
+					Vec3d rear = centerte.getNextPosition(center, VecUtil.fromWrongYaw(rearDistance, yaw));
+
+					moveable.setRotationYaw(VecUtil.toWrongYaw(front.subtract(rear)));
+					float pitch = (-VecUtil.toPitch(front.subtract(rear)) - 90);
+					if (DegreeFuncs.delta(pitch, 0) > 90) {
+						pitch = 180 - pitch;
+					}
+					moveable.setRotationPitch(pitch);
+
+					moveable.setPosition(
+							rear.add(front.subtract(rear).scale(frontDistance / (frontDistance - rearDistance))));
+
+					ITrack frontte = ITrack.get(worldIn, front, true);
+					if (frontte != null) {
+						Vec3d frontNext = frontte.getNextPosition(front, VecUtil.fromWrongYaw(0.1 * gauge.scale(),
+																							  moveable.getRotationYaw()));
+						moveable.setFrontYaw(VecUtil.toWrongYaw(frontNext.subtract(front)));
+					}
+
+					ITrack rearte = ITrack.get(worldIn, rear, true);
+					if (rearte != null) {
+						Vec3d rearNext = rearte.getNextPosition(rear, VecUtil.fromWrongYaw(0.1 * gauge.scale(),
+																						   moveable.getRotationYaw()));
+						moveable.setRearYaw(VecUtil.toWrongYaw(rearNext.subtract(rear)));
+					}
+				}
+				moveable.newlyPlaced = true;
+			}
+
+			if (stock instanceof EntityBuildableRollingStock) {
+				((EntityBuildableRollingStock)stock).setComponents(def.getItemComponents());
+			}
+			worldIn.spawnEntity(stock);
+			shutdown.add(stock);
+			defaultCGs.forEach(stock::setControlPosition);
+
+			Vec3d length = VecUtil.fromWrongYaw(def.getCouplerPosition(s.direction.shouldFlip()
+																	   ? CouplerType.FRONT
+																	   : CouplerType.BACK, stock.gauge), originalRot);
+
+			spawnPos = center.add(length);
+			yaw = originalRot;
+		}
+
+		return ClickResult.ACCEPTED;
+	}
 }
diff --git a/src/main/resources/assets/immersiverailroading/lang/de_de.lang b/src/main/resources/assets/immersiverailroading/lang/de_de.lang
index 61b338345..a613a7d73 100644
--- a/src/main/resources/assets/immersiverailroading/lang/de_de.lang
+++ b/src/main/resources/assets/immersiverailroading/lang/de_de.lang
@@ -16,10 +16,10 @@ item.immersiverailroading:item_cast_rail.name=Schienenguss
 item.immersiverailroading:item_manual.name=Immersive Railroading Handbuch
 item.immersiverailroading:item_rail.name=Schienenplan
 item.immersiverailroading:item_conductor_whistle.name=Pfeife
-item.immersiverailroading:item_golden_spike.name=[Need translate]
-item.immersiverailroading:item_radio_control_card.name=[Need translate]
-item.immersiverailroading:item_switch_key.name=[Need translate]
-item.immersiverailroading:item_track_exchanger.name=[Need translate]
+item.immersiverailroading:item_golden_spike.name=Golden Spike
+item.immersiverailroading:item_radio_control_card.name=Zug-Funksteuerungs-Chip
+item.immersiverailroading:item_switch_key.name=Weichenschlüssel
+item.immersiverailroading:item_track_exchanger.name=Schienenaustausch Werkzeug
 
 tile.immersiverailroading:block_rail.name=Schiene
 tile.immersiverailroading:block_rail_gag.name=Schiene (Gag)
diff --git a/src/main/resources/assets/immersiverailroading/lang/en_us.lang b/src/main/resources/assets/immersiverailroading/lang/en_us.lang
index 4fea764f4..930f87f31 100644
--- a/src/main/resources/assets/immersiverailroading/lang/en_us.lang
+++ b/src/main/resources/assets/immersiverailroading/lang/en_us.lang
@@ -20,6 +20,7 @@ item.immersiverailroading:item_golden_spike.name=Golden Spike
 item.immersiverailroading:item_radio_control_card.name=Train Radio-control Card
 item.immersiverailroading:item_switch_key.name=Switch Key
 item.immersiverailroading:item_track_exchanger.name=Track Exchanger
+item.immersiverailroading:item_consist_placer.name=Consist Placer
 
 tile.immersiverailroading:block_rail.name=Rail
 tile.immersiverailroading:block_rail_gag.name=Rail (Gag)
@@ -115,6 +116,8 @@ gui.immersiverailroading:track.rail_bed_fill=Bed Fill:    %s
 gui.immersiverailroading:track.place_blueprint_true=Place:      Blueprint
 gui.immersiverailroading:track.place_blueprint_false=Place:      Track
 
+
+gui.immersiverailroading:unit.count=Stocks:         %s
 gui.immersiverailroading:loco.works=Works:          %s
 gui.immersiverailroading:loco.power=Power:          %s
 gui.immersiverailroading:loco.tractive_effort=Tractive Eff:  %s
@@ -246,6 +249,7 @@ itemGroup.immersiverailroading.locomotive=Immersive Railroading Locomotives
 itemGroup.immersiverailroading.stock=Immersive Railroading Stock
 itemGroup.immersiverailroading.passenger=Immersive Railroading Passenger
 itemGroup.immersiverailroading.components=Immersive Railroading Components
+itemGroup.immersiverailroading.unit=Immersive Railroading Units
 
 death.attack.immersiverailroading:casting=%s discovered that molten metal does not make a good swimming pool
 death.attack.immersiverailroading:hitByTrain=%s failed to outrun a train
diff --git a/src/main/resources/assets/immersiverailroading/lang/fr_fr.lang b/src/main/resources/assets/immersiverailroading/lang/fr_fr.lang
index 0e7ce9bb7..8a233e1a0 100644
--- a/src/main/resources/assets/immersiverailroading/lang/fr_fr.lang
+++ b/src/main/resources/assets/immersiverailroading/lang/fr_fr.lang
@@ -20,6 +20,7 @@ item.immersiverailroading:item_golden_spike.name=Clou dorée (Golden Spike)
 item.immersiverailroading:item_radio_control_card.name=Carte de radiocommande
 item.immersiverailroading:item_switch_key.name=Clef d'aiguillage
 item.immersiverailroading:item_track_exchanger.name=Echangeur de voie
+item.immersiverailroading:item_consist_placer=[Need translate]
 
 tile.immersiverailroading:block_rail.name=Rail
 tile.immersiverailroading:block_rail_gag.name=Rail (Gag)
diff --git a/src/main/resources/assets/immersiverailroading/lang/ja_jp.lang b/src/main/resources/assets/immersiverailroading/lang/ja_jp.lang
index eafa019cf..825f20268 100644
--- a/src/main/resources/assets/immersiverailroading/lang/ja_jp.lang
+++ b/src/main/resources/assets/immersiverailroading/lang/ja_jp.lang
@@ -20,6 +20,7 @@ item.immersiverailroading:item_golden_spike.name=ゴールデン・スパイク
 item.immersiverailroading:item_radio_control_card.name=無線コントローラ
 item.immersiverailroading:item_switch_key.name=スイッチキー
 item.immersiverailroading:item_track_exchanger.name=レール変換装置
+item.immersiverailroading:item_consist_placer=[Need translate]
 
 tile.immersiverailroading:block_rail.name=レール
 tile.immersiverailroading:block_rail_gag.name=レール（ダミー）
diff --git a/src/main/resources/assets/immersiverailroading/lang/ru_ru.lang b/src/main/resources/assets/immersiverailroading/lang/ru_ru.lang
index d4595052b..8fe7ffd8d 100644
--- a/src/main/resources/assets/immersiverailroading/lang/ru_ru.lang
+++ b/src/main/resources/assets/immersiverailroading/lang/ru_ru.lang
@@ -20,6 +20,7 @@ item.immersiverailroading:item_golden_spike.name=Штырь
 item.immersiverailroading:item_radio_control_card.name=Радиоконтроллер для поездов
 item.immersiverailroading:item_switch_key.name=Служебный ключ
 item.immersiverailroading:item_track_exchanger.name=Реконструктор рельс
+item.immersiverailroading:item_consist_placer=[Need translate]
 
 tile.immersiverailroading:block_rail.name=Железнодорожный путь
 tile.immersiverailroading:block_rail_gag.name=Балласт
diff --git a/src/main/resources/assets/immersiverailroading/lang/zh_cn.lang b/src/main/resources/assets/immersiverailroading/lang/zh_cn.lang
index f8f246abb..2cc0084f6 100644
--- a/src/main/resources/assets/immersiverailroading/lang/zh_cn.lang
+++ b/src/main/resources/assets/immersiverailroading/lang/zh_cn.lang
@@ -20,6 +20,7 @@ item.immersiverailroading:item_golden_spike.name=金道钉
 item.immersiverailroading:item_radio_control_card.name=列车无线遥控卡
 item.immersiverailroading:item_switch_key.name=道岔钥匙
 item.immersiverailroading:item_track_exchanger.name=轨道样式更换器
+item.immersiverailroading:item_consist_placer=[Need translate]
 
 tile.immersiverailroading:block_rail.name=轨道
 tile.immersiverailroading:block_rail_gag.name=轨道（占位）
diff --git a/src/main/resources/assets/immersiverailroading/textures/items/consist.png b/src/main/resources/assets/immersiverailroading/textures/items/consist.png
new file mode 100644
index 000000000..a2d17a113
Binary files /dev/null and b/src/main/resources/assets/immersiverailroading/textures/items/consist.png differ