diff --git a/dependencies.gradle b/dependencies.gradle
index e908852c3e6..394dd851284 100644
--- a/dependencies.gradle
+++ b/dependencies.gradle
@@ -10,6 +10,12 @@ dependencies {
     // Configuration
     jarJar(modApi(forge.configuration.get()))
 
+    // Math Parser
+    compileOnly(libs.evalEx.get())
+
+    // MUI
+    jarJar(modImplementation(forge.mui.get()))
+
     // Mixin (& Extras)
     annotationProcessor(variantOf(libs.mixin) { classifier("processor") })
     compileOnly(annotationProcessor(forge.mixinExtras.common.get()))
@@ -119,4 +125,8 @@ dependencies {
     modExtraLocalRuntime(forge.ponder)
     modExtraLocalRuntime(variantOf(forge.create) { classifier("slim") })
     modExtraLocalRuntime(forge.flywheel.forge)
+
+    modLocalRuntime(forge.curios)
+
+
 }
diff --git a/docs/content/Development/MUI2/Layout_MainAxisAlignments.png b/docs/content/Development/MUI2/Layout_MainAxisAlignments.png
new file mode 100644
index 00000000000..308916e9eb6
Binary files /dev/null and b/docs/content/Development/MUI2/Layout_MainAxisAlignments.png differ
diff --git a/docs/content/Development/MUI2/Syncing/Sync-Basics.md b/docs/content/Development/MUI2/Syncing/Sync-Basics.md
new file mode 100644
index 00000000000..12cd19e6337
--- /dev/null
+++ b/docs/content/Development/MUI2/Syncing/Sync-Basics.md
@@ -0,0 +1,268 @@
+# Sync Basics
+
+## Basics of Syncing
+To display dynamic values on the client, you have to send the data from the server to the client. When making UIs, it is very important to keep track of if and how your data is being synced to the client. There are a few ways to do so, which will be discussed below.  
+
+When opening a UI, a copy of the UI is created both on the server and on the client. It is important to note here that the server's copy will have access to most everything about e.g. the machine, block state, the world etc., but the client's copy will not.  
+
+To sync this data back and forth, you need to use `SyncHandler`s. These will send your data from the server to the client when it updates.  
+
+Because of this, you cannot just use values you create SyncHandlers for directly in the client. An example:
+
+```java
+
+var tickSyncValue = new IntSyncValue(() -> this.ticks, (newValue) -> this.ticks = newValue);
+for(int i=0;i<tickSyncValue.getValue(); i++){ 
+    //...
+}
+```
+This would not work, intSyncValue hasn't had time to send data over yet and thus int is still 0 on the client side.
+
+If you try to access values on the client that aren't synced or don't have a `SyncValue` or `SyncHandler`, they will have a default value, but they will not reflect the values or changes happening on the server.
+
+
+
+## Method 1: Dynamic Widgets
+The first method is using dynamic widgets, which update every frame regardless of what happens.
+This method is easiest if you just need to sync some data over and display or edit it in a single widget. 
+Some examples are:
+
+- `IKey.dynamic(Supplier<Component>)` - Queries the supplier every frame to retrieve the component to display  
+- `new DynamicDrawable(Supplier<IDrawable>)` - Queries the supplier every frame to retrieve the drawable to display  
+
+
+!!! Note
+    To convert IKeys or Drawables to Widgets, you need to chain `.asWidget()`
+
+```java
+public class MuiTestMachine extends MetaMachine implements IMuiMachine {
+
+    public int ticks = 0;
+
+    public MuiTestMachine(BlockEntityCreationInfo info) {
+        super(info);
+        this.subscribeServerTick(() -> ticks++);
+    }
+
+    @Override
+    public ModularPanel buildUI(PosGuiData data, PanelSyncManager syncManager, UISettings settings) {
+        var panel = GTGuis.createPanel(this, 176, 168);
+        var tickSyncValue = new IntSyncValue(() -> this.ticks, (newValue) -> this.ticks = newValue);
+        syncManager.syncValue("tickSyncValue", tickSyncValue);
+
+        var column = Flow.column();
+
+        column.child(IKey.dynamic(() -> Component.literal("Ticks: " + this.ticks)) // note that this is a Supplier<Component> instead of a Component
+                .asWidget()
+                .margin(4));
+
+        column.child(
+                new DynamicDrawable(() -> { // note that this is a Supplier<IDrawable> instead of an IDrawable
+                    if (ticks % 40 < 20) { // flip every second
+                        return GTGuiTextures.BUTTON_FLUID_OUTPUT;
+                    } else {
+                        return GTGuiTextures.BUTTON_ITEM_OUTPUT;
+                    }
+                })
+                .asWidget()
+                .background(GTGuiTextures.BACKGROUND_STEEL)
+        );
+
+        panel.child(column);
+
+        return panel;
+    }
+}
+```
+
+Here, we create a basic `SyncValue` for an integer. This takes a `Supplier<Integer>` and a `Consumer<Integer>`, more commonly known as a getter and a setter. Generally speaking, `SyncValue`s will take a `Supplier` and `Consumer` of the type of value they are syncing.  
+
+If the value returned by the getter changed on the server, the value gets serialized and sent to the client by the `SyncManager`. The `SyncHandler`'s value can always be manually updated, for example to do client-to-server syncing.
+
+Then, the value on the client (being set every time the server sends an update) is retrieved every frame by the lambdas used in the dynamic widgets.
+
+If you want to update the value from the client, you can call `syncValue.setValue()` on the client. This will also update the value on the server side.
+
+## Method 2: DynamicLinkedSyncHandler
+
+This method is great for widgets whose structure and layout can change depending on your synced values.
+
+```java
+public class MuiTestMachine extends MetaMachine implements IMuiMachine {
+
+    public int ticks = 0;
+
+    public MuiTestMachine(BlockEntityCreationInfo info) {
+        super(info);
+        this.subscribeServerTick(() -> ticks++);
+    }
+
+    @Override
+    public ModularPanel buildUI(PosGuiData data, PanelSyncManager syncManager, UISettings settings) {
+        var panel = GTGuis.createPanel(this, 176, 168);
+        var tickSyncValue = new IntSyncValue(() -> this.ticks, (newValue) -> this.ticks = newValue);
+        syncManager.syncValue("tickSyncValue", tickSyncValue);
+
+        DynamicLinkedSyncHandler<IntSyncValue> dynamicLinkedSyncHandler = new DynamicLinkedSyncHandler<>(tickSyncValue)
+                .widgetProvider((widgetSyncManager, intSyncHandler) -> {
+                    var list = new ListWidget<>()
+                            .widthRel(1)
+                            .coverChildrenHeight()
+                            .crossAxisAlignment(Alignment.CrossAxis.START);
+                    int tickValue = intSyncHandler.getValue(); // It is also possible to just reference this.ticks directly
+                    int amountOfItems = 1 + (tickValue % 200) / 20;
+                    for (int i = 0; i < amountOfItems; i++) {
+                        list.child(IKey.str("Value nr. " + (i + 1)).asWidget()); // No need for IKey.dynamic since we have the value as a variable here, inside the lambda
+                    }
+                    return list;
+                });
+
+        panel.child(new DynamicSyncedWidget<>()
+                .widthRel(1)
+                .coverChildrenHeight()
+                .syncHandler(dynamicLinkedSyncHandler)
+                .padding(3));
+
+        return panel;
+    }
+}
+```
+
+This method works in three steps:
+
+The first step is creating a `SyncHandler` and registering it to the `PanelSyncManager`.  
+The second step is creating a `DynamicLinkedSyncHandler` based on the first `SyncHandler`. This is effectively a wrapper class to provide your widget whenever your initial `SyncHandler` updates.  
+The third step is creating a `DynamicSyncedWidget` with that `DynamicLinkedSyncHandler` as its `SyncHandler`.  
+
+This effectively lets us create a new "version" of the widget whenever our value (in this case the `ticks` int) changes. Furthermore, in this example we have the actual values of the things we want to sync when constructing our widget tree on the client, allowing for much greater customization.
+
+
+!!! note
+    For even more complex systems where you need to dynamically register sync handlers within the `DynamicLinkedSyncHandler`'s `.widgetProvider(...)`, this can be done by calling `.getOrCreateSyncHandler(...)` on the `widgetSyncManager` parameter of the lambda.
+
+## Method 3: Types that take SyncHandlers
+There are some widgets that have built in support for working directly with SyncHandlers.
+
+```java
+public class MuiTestMachine extends MetaMachine implements IMuiMachine {
+
+    public boolean buttonPressed = false;
+
+    public MuiTestMachine(BlockEntityCreationInfo info) {
+        super(info);
+    }
+
+    @Override
+    public ModularPanel buildUI(PosGuiData data, PanelSyncManager syncManager, UISettings settings) {
+        var panel = GTGuis.createPanel(this, 176, 168);
+
+        var column = Flow.column().paddingTop(3);
+
+        column.child(
+                IKey.dynamic(() -> Component.literal("Pressed: " + this.buttonPressed))
+                    .asWidget());
+
+        var buttonSyncValue = new BooleanSyncValue(() -> this.buttonPressed, (newValue) -> this.buttonPressed = newValue);
+        column.child(new ToggleButton().value(buttonSyncValue));
+
+        panel.child(column);
+
+        return panel;
+    }
+}
+```
+
+Note that in this case, the ToggleButton takes care of registering the SyncValue for us, so we do not register it to the syncManager ourselves. This method is great for simple functions using widgets that support it.
+
+A few examples of this would be:
+
+- `new ToggleButton().value(BooleanSyncValue)` - A ToggleButton that affects the Boolean sync value
+- `new TextFieldWidget().value(StringSyncValue)` - A TextField that updates the String sync value
+- `new ProgressWidget().value(DoubleSyncValue)` - A ProgressWidget (e.g. bar) that shows progress, can also be constructed with `new ProgressWidget().progress(() -> this.progress)`
+- `new SliderWidget().value(DoubleSyncValue)` - A SliderWidget that updates the Double sync value
+
+## Method 4: Manually notifying DynamicSyncHandlers
+This method is useful when your custom widget needs complex data coming in, like through multiple sync handlers.
+
+```java
+public class MuiTestMachine extends MetaMachine implements IMuiMachine {
+
+    public int rows = 0;
+    public int columns = 0;
+    public int counter = 0;
+
+    public MuiTestMachine(BlockEntityCreationInfo info) {
+        super(info);
+        this.subscribeServerTick(() -> {
+            counter += 1;
+            if (counter % 20 == 0) {
+                rows = (rows + 1) % 10;
+            }
+            if (counter % 15 == 0) {
+                columns = (columns + 1) % 10;
+            }
+        });
+    }
+
+    @Override
+    public ModularPanel buildUI(PosGuiData data, PanelSyncManager syncManager, UISettings settings) {
+        var panel = GTGuis.createPanel(this, 200, 200);
+
+        var rowsSyncValue = new IntSyncValue(() -> this.rows, (newValue) -> this.rows = newValue);
+        syncManager.syncValue("rows", rowsSyncValue);
+
+        var columnsSyncValue = new IntSyncValue(() -> this.columns, (newValue) -> this.columns = newValue);
+        syncManager.syncValue("columns", columnsSyncValue);
+
+        DynamicSyncHandler gridWidgetHandler = new DynamicSyncHandler().widgetProvider((slotsSyncManger, buffer) -> {
+
+            Flow grid = Flow.column().width(200);
+            for (int rowNr = 0; rowNr < this.rows; rowNr++) {
+                Flow row = Flow.row();
+                for (int columnNr = 0; columnNr < this.columns; columnNr++) {
+                    row.child(IKey.str(rowNr + ", " + columnNr).asWidget().width(20));
+                }
+                grid.child(row);
+            }
+            return grid;
+        });
+
+        rowsSyncValue.setChangeListener(() -> {
+            gridWidgetHandler.notifyUpdate(buffer -> {});
+        });
+        columnsSyncValue.setChangeListener(() -> {
+            gridWidgetHandler.notifyUpdate(buffer -> {});
+        });
+
+        panel.child(new DynamicSyncedWidget<>().syncHandler(gridWidgetHandler));
+        return panel;
+    }
+}
+```
+
+This is very similar to method 2, but instead of a `DynamicLinkedSyncHandler` we use a normal `DynamicSyncHandler` where we have to manually let it know when to update. We do this in the change listener of our two `SyncValue`s by calling notifyUpdate. 
+
+Do note there's also a buffer where you can serialize data to, to be consumed in the `.widgetProvider(...)` in the spot where in a `DynamicLinkedSyncHandler` our syncValue would be. It is usually not needed to put anything in this buffer.
+
+## Other sync information
+
+### SyncHandler panel separation
+
+SyncValues are separated across panels. So if you do `mainPanelSyncManager.syncValue("rows", rowsSyncValue);` in one panel, you can't just call `popupSyncManager.getSyncHandlerFromMapKey("rows:0")`.   
+You can, however, call `syncManager.getModularSyncManager().getPanelSyncManager("panel name here").getSyncHandlerFromMapKey("rows:0");`.  
+
+### Value.Dynamic
+Sometimes you need to quickly create a Value for something that already exists client side. For this you can use `new [Type]Value.Dynamic(...)`.  
+For example, if you have a client-only value that's affected by a button, you could do   
+`panel.child(new ToggleButton().value(new BoolValue.Dynamic(() -> this.toggled, (newValue) -> this.toggled = newValue)));`  
+
+Another reason to use a dynamic value is if you want to change the type of a variable, e.g. `.value(new DoubleValue.Dynamic(() -> (double) this.x, val -> this.x = (double) val)` where x is an int.  
+
+The third reason is if you want to use a `SyncHandler` in two separate widgets that would both auto-register it.  
+```
+        var boolSyncValue = new BooleanSyncValue(() -> this.toggled, (newValue) -> this.toggled = newValue);
+        panel.child(new ToggleButton().value(boolSyncValue));
+        panel.child(new ToggleButton().value(BoolValue.wrap(boolSyncValue)).left(32));
+```
+Without the wrap around the second boolSyncValue call, it would complain of registration of an already registered SyncValue.
+
diff --git a/docs/content/Development/MUI2/Syncing/Synced-Actions.md b/docs/content/Development/MUI2/Syncing/Synced-Actions.md
new file mode 100644
index 00000000000..f774ffd201a
--- /dev/null
+++ b/docs/content/Development/MUI2/Syncing/Synced-Actions.md
@@ -0,0 +1,48 @@
+# Synced Actions
+
+```java
+public class MuiTestMachine extends MetaMachine implements IMuiMachine {
+
+    public MuiTestMachine(BlockEntityCreationInfo info) {
+        super(info);
+    }
+
+    public int number = 0;
+
+    @Override
+    public ModularPanel buildUI(PosGuiData data, PanelSyncManager syncManager, UISettings settings) {
+        var panel = GTGuis.createPanel(this, 176, 168);
+
+        var numberSyncValue = new IntSyncValue(() -> this.number, (newValue) -> this.number = newValue);
+        syncManager.syncValue("number", numberSyncValue);
+
+        syncManager.registerServerSyncedAction("randomButtonPressed", (packet) -> {
+            this.number = getLevel().getRandom().nextInt();
+        });
+
+        Column contents = new Column();
+        contents.child(IKey.dynamic(() -> Component.literal("Number: " + number))
+                .asWidget()
+                .width(100)
+                .height(16)
+                .margin(4));
+
+        contents.child(new ButtonWidget<>()
+                .onMousePressed((x, y, button) -> {
+                    if (button == 0) {
+                        syncManager.callSyncedAction("randomButtonPressed");
+                    }
+                    return true;
+                })
+                .size(16));
+        return panel.child(contents);
+    }
+}
+
+```
+
+Synced actions are useful when you need a client-side input (e.g. a button press) to trigger an action on the server.  
+
+In this case we create a synced action called `randomButtonPressed`, and when the button is pressed on the client, the `randomButtonPressed` signal is sent to the server and the relevant action is executed.
+
+If you need to pass other data with your action, you can pass a `(packet) -> {...}` as second argument to `callSyncedAction` and serialize your data there, and then deserialize it from the `packet` argument in the synced action definition.
\ No newline at end of file
diff --git a/docs/content/Development/MUI2/Syncing/index.md b/docs/content/Development/MUI2/Syncing/index.md
new file mode 100644
index 00000000000..ed0a1fb6e5f
--- /dev/null
+++ b/docs/content/Development/MUI2/Syncing/index.md
@@ -0,0 +1 @@
+Syncing is the concept of synchronising data between client and server. This folder will contain files relevant to setting up syncing on your UIs.
\ No newline at end of file
diff --git a/docs/content/Development/MUI2/Test-Machine.md b/docs/content/Development/MUI2/Test-Machine.md
new file mode 100644
index 00000000000..63d3a9135c5
--- /dev/null
+++ b/docs/content/Development/MUI2/Test-Machine.md
@@ -0,0 +1,35 @@
+# Making a MUI2 Test Machine
+To make a basic machine to test your UI, simply create the following class:
+
+```java title="MultiMachines.java"
+public class MuiTestMachine extends MetaMachine implements IMuiMachine {
+
+    public MuiTestMachine(BlockEntityCreationInfo info) {
+        super(info);
+    }
+
+    @Override
+    public ModularPanel buildUI(PosGuiData data, PanelSyncManager syncManager, UISettings settings) {
+        var panel = GTGuis.createPanel(this, 176, 168);
+        // Do stuff with your panel here, add children, etc.
+        // For example:
+        panel.child(IKey.str("Test machine")
+                .asWidget()
+                .margin(4));
+
+        return panel;
+    }
+}
+```
+
+and in your machines definitions class, add the following entry:
+
+```java
+    public static final MachineDefinition MUI_TEST_MACHINE = REGISTRATE
+            .machine("mui_test", MuiTestMachine::new)
+            .model(createOverlayCasingMachineModel(GTCEu.id("block/casings/solid/machine_casing_clean_stainless_steel"),
+                    GTCEu.id("block/machine/part/computer_monitor")))
+            .register();
+```
+
+Make sure to run datagen after making the initial machine to register the lang keys, model, etc. Running datagen afterward for UI changes is not required.
\ No newline at end of file
diff --git a/docs/content/Development/MUI2/Widget-Layout.md b/docs/content/Development/MUI2/Widget-Layout.md
new file mode 100644
index 00000000000..17bed127395
--- /dev/null
+++ b/docs/content/Development/MUI2/Widget-Layout.md
@@ -0,0 +1,189 @@
+# Widget Layout, Sizing and Positioning
+
+Each widget has several builder setter methods for position and size. They all come from the `IPositioned` interface.
+
+
+## Coordinate system
+- Widget coordinates are local to the widget; (0, 0) is the top-left corner of the widget.
+- Positions are relative to the parent by default.
+
+## Sizing
+
+- `width(int)` sets the widget width in pixels
+- `widthRel(float)` sets the widget width relative to its parent (e.g. if the parent is 120 px wide and we
+  call `widthRel(0.5f)`, our widget will be 60 px wide)
+- `height(int)` and `heightRel(float)` work analogous to previous methods
+- `size(int width, int height)` is equivalent to `.width(width).height(height)`
+- `size(int val)` is equivalent to `.width(val).height(val)`
+- `sizeRel(float width, float height)` and `sizeRel(float val)` work analogous to previous methods
+- `fullWidth()` and `fullHeight()` are shortcuts for `widthRel(1f)` and `heightRel(1f)` respectively
+- `full()` combines the previous two methods
+- `coverChildrenWidth()` makes the widget width wrap tightly around its children
+- `coverChildrenHeight()` works analogous to previous method
+- `coverChildren()` wraps width and height tightly
+- `expanded()` is only useful for children of `Row` and `Column` widgets. It will make the widget expand as much as
+  possible in the widgets axis (width in row and height in column)
+
+## Positioning
+
+We can set position on four different points, two for each axis. `left()`, `right()`, `top()` and `bottom()`.
+To understand what they are doing take a look at the following picture:
+
+![grafik](https://github.com/CleanroomMC/ModularUI/assets/45517902/ab173431-1509-414c-8db4-4545c985a9bd)
+
+As you can see the methods are fairly self-explanatory. Each of those methods has multiple variants much like `width()`
+and `widthRel()`. Only methods for `left()` will be listed here.
+
+- `left(int x)` sets the x position in pixels relative to its parent
+- `leftRel(float x)` sets the x position relative to its parent (f.e. 0.5f will center the widget) 
+- `leftRelOffset(float val, int offset)` is the same as `leftRel(float x)`, but also adds an `offset` in pixels after the calculation
+- `leftRelAnchor(float val, float anchor)` is the same as `leftRel(float x)`, but with a different anchor
+  (see [Anchor](#anchor))
+- `leftRel(float val, int offset, float anchor)` combines `leftRelOffset()` and `leftRelAnchor()`
+- `left(DoubleSupplier val, Measure measure)` is like `left()` and `leftRel()`, but with a dynamic value. Note that the
+  supplier is only evaluated during resizing. You can't use it for animating widgets.
+- `leftRelOffset(DoubleSupplier val, int offset)` is like `leftRelOffset(float val, int offset)` with a dynamic value
+- `leftRelAnchor(DoubleSupplier val, float anchor)` is like `leftRelAnchor(float val, float anchor)` with a dynamic
+  value
+- `leftRel(DoubleSupplier val, int offset, float anchor)` combines the two methods above
+
+All the above variants also exist for `right()`, `top()` and `bottom()`.
+Additionally, there is
+
+- `pos(int x, int y)` combines `left(int x)` and `top(int y)`
+- `posRel(float x, float y)` combines `leftRel(float x)` and `topRel(float y)`
+- `posRel(Alignment a)` calls `posRel(float x, float y)` using a specific alignment enum value
+- `horizontalCenter()` is short for `leftRel(0.5f)`
+- `verticalCenter()` is short for `topRel(0.5f)`
+- `center()` is short for `posRel(Alignment.Center)`
+## Anchor
+
+The anchor is the point of the widget at which the widget will be positioned with the relative value. The following
+picture should make this clear. In the picture `leftRelAnchor(0.5f, 0.3f)` is called.
+
+![anchor.png](https://raw.githubusercontent.com/CleanroomMC/Website/refs/heads/main/docs/wiki/modularui/anchor.png)
+
+Here the anchor is placed at `0.3f`, which is about a third of the widget.
+And that anchor is positioned at `0.5f` of the parent widget (the center).
+Try imagining what happens with different anchor values and play around with it by yourself.
+
+If we had called `leftRel(float val, int offset, float anchor)`, then the offset would be added after the anchor
+and relative position calculation.
+
+## Combining Size and Position
+
+You can call multiple different position and size methods, but you should be aware of its effects and limitations.
+
+Each axis (x and y) has three setters (x has `left()`, `right()` and `width()`, y has `top()`, `bottom()` and `height()`)
+without including all the variations.
+
+!!! Note
+    You can call at most two setters for each axis, since with two properties set the last one can always be calculated.
+
+For example of you call `left()` and `right()` then the width can be calculated with `right - left`.
+Setting all three properties for an axis will remove one of the other properties and log an info message.
+
+!!! Note 
+    By default, the position is (0, 0) and the size is 18x18 in pixels for most widgets.
+
+## Changing the relative Parent
+
+By default, the size and position are calculated relative to the widget's parent, but that can be changed with
+`relative(Area)`, `relative(IGuiElement)` and `relativeToScreen()`.
+The parent of all panels is by default the screen.
+
+!!! Warning
+    Changing the relative widget might cause some unexpected results in some edge cases. Please notify us if you run
+    into one of those.
+
+
+## Flow layout (Row / Column)
+`Flow` is the core layout widget for arranging children along one axis.
+
+- `Flow.row()` lays out children **left-to-right** (X axis).
+- `Flow.column()` lays out children **top-to-bottom** (Y axis).
+- `mainAxisAlignment(...)` controls how children are distributed on the main axis:
+    - `START`, `CENTER`, `END`, `SPACE_BETWEEN`, `SPACE_AROUND`
+    - e.g. `Flow.row().mainAxisAlignment(Alignment.MainAxis.CENTER)` centers the row's children horizontally, given that it has a set width
+- `crossAxisAlignment(...)` controls alignment on the perpendicular axis:
+    - `START`, `CENTER`, `END`
+    - e.g. `Flow.row().crossAxisAlignment(Alignment.CrossAxis.CENTER)` centers the row's children vertically, given that it has a set height
+- `childPadding(int)` adds fixed spacing between children.
+- `coverChildren()` / `coverChildrenWidth()` / `coverChildrenHeight()` sizes the flow to fit its children.
+- `collapseDisabledChild()` does not consider disabled children during position calculations.
+    - This is useful when the enabled state of children changes dynamically.
+- `reverseLayout(bool)` reverses the order that children are drawn.
+
+Notes:
+
+- Centering (main or cross axis) requires the flow to have a known size on that axis. If you want a row to center its children horizontally, give it a width (e.g. `widthRel(1f)` or `width(120)`).  
+- By default, a `Flow` is `full()`, which means they take up as much space as their parents size.
+
+Here is how all the MainAxisAlignments apply to widgets:
+
+![MainAxisAlignments](./Layout_MainAxisAlignments.png)
+
+
+## Centering widgets
+There are two common ways to center things:
+
+1) Center a widget within its parent (positioning)
+
+- `widget.center()` or `widget.posRel(Alignment.Center)`
+- `widget.horizontalCenter()` or `widget.verticalCenter()`
+
+2) Center children inside a Row/Column (layout)
+
+- `Flow.row().mainAxisAlignment(Alignment.MainAxis.CENTER)` centers children along the flow's direction.
+- `Flow.column().crossAxisAlignment(Alignment.CrossAxis.CENTER)` centers children perpendicular to the flow's direction.
+- Remember to give the row/column a size on that axis (e.g. `widthRel(1f)` for a row).
+
+## Margin vs padding
+Spacing is handled via two different concepts:
+
+- Margin: space outside a widget. Layouts (like `Flow`) include margins when positioning children.
+    - `marginTop(px)`, `marginBottom(px)`, `marginLeft(px)`, `marginRight(px)` set the padding in pixels for the directions
+    - `margin(all)`, `margin(horizontal, vertical)`, `margin(left, right, top, bottom)` are shortcuts for the respective methods
+- Padding: space inside a widget. It reduces the content area and affects how children are placed.
+    - `paddingTop(px)`, `paddingBottom(px)`, `paddingLeft(px)`, `paddingRight(px)` sets the margin in pixels for the directions
+    - `padding(all)`, `padding(horizontal, vertical)`, `padding(left, right, top, bottom)` are shortcuts for the respective methods
+
+## Examples
+
+### Simple centered panel with a row of buttons
+```java
+ModularPanel panel = new ModularPanel("example")
+        .size(176, 168);
+
+panel.child(new ParentWidget<>()
+        .size(90, 63)
+        .align(Alignment.CENTER)
+        .child(Flow.row()
+                .coverChildren()
+                .childPadding(4)
+                .child(new ButtonWidget<>().size(16))
+                .child(new ButtonWidget<>().size(16))
+                .child(new ButtonWidget<>().size(16))));
+```
+
+### Column with padding and left-aligned content
+```java
+Flow column = Flow.column()
+        .widthRel(1f)
+        .padding(10)
+        .crossAxisAlignment(Alignment.CrossAxis.START)
+        .child(new TextWidget<>(IKey.str("Title")).marginBottom(4))
+        .child(new TextWidget<>(IKey.str("Body")));
+```
+
+### Slot grid using absolute positioning
+```java
+ParentWidget<?> slots = new ParentWidget<>();
+for (int y = 0; y < rows; y++) {
+    for (int x = 0; x < cols; x++) {
+        slots.child(new ItemSlot()
+                .left(18 * x)
+                .top(18 * y));
+    }
+}
+```
diff --git a/docs/content/Development/MUI2/index.md b/docs/content/Development/MUI2/index.md
new file mode 100644
index 00000000000..f06372b41a0
--- /dev/null
+++ b/docs/content/Development/MUI2/index.md
@@ -0,0 +1,5 @@
+# ModularUI 2
+ModularUI 2 is the UI library used in GTM starting from 8.0.0, and is the successor to LDLib UI.
+From ModularUI 1.12's github:
+
+With ModularUI you can build GUIs fast by adding Widgets to panels with layout widgets, so you don't have to calculate positions and sizes yourself. ModularUI is very dynamic and allows for very complicated client-server synced GUIs.
\ No newline at end of file
diff --git a/docs/content/Modpacks/Examples/Example_Coil_Multiblock.md b/docs/content/Modpacks/Examples/Example_Coil_Multiblock.md
new file mode 100644
index 00000000000..09fa577b996
--- /dev/null
+++ b/docs/content/Modpacks/Examples/Example_Coil_Multiblock.md
@@ -0,0 +1,102 @@
+---
+title: "Example Coil Multiblock"
+---
+
+### Superheated Pyrolyzing Oven Multiblock (by Phoenixvine)
+
+
+Below is an example of a multiblock using the CoilWorkableElectricMultiblockMachine class and the pyrolyseOvenOverclock machine logic.
+
+### Multiblock
+=== "JavaScript"
+    ```js title="superheated_pyrolyzing_oven_multiblock.js"
+    // In order to use multiblock logic extending beyond the normal WorkableElectricMultiblockMachine, (This is the multiblock type used by default for kubejs) you need to load a class. Coil multiblocks such as the Electric Blast Furnace, Pyrolyse Oven, and the Cracker use this class.
+    const CoilWorkableElectricMultiblockMachine = Java.loadClass("com.gregtechceu.gtceu.api.machine.multiblock.CoilWorkableElectricMultiblockMachine")
+    
+    GTCEuStartupEvents.registry('gtceu:machine', event => {
+        event.create("superheated_pyrolyzing_oven", "multiblock")
+            .machine((holder) => new CoilWorkableElectricMultiblockMachine(holder))
+            .rotationState(RotationState.NON_Y_AXIS)
+            .recipeTypes('pyrolyse_oven')
+            .recipeModifiers(
+                [
+                    GTRecipeModifiers.PARALLEL_HATCH,  
+                    (machine, recipe) => GTRecipeModifiers.pyrolyseOvenOverclock(machine, recipe)
+                ]
+            )
+            .appearanceBlock(GTBlocks.CASING_STEEL_SOLID)
+            .pattern(definition => FactoryBlockPattern.start()
+                .aisle("BBCCCBB", "BBCDCBB", "BBCCCBB", "BBCCCBB", "BBEEEBB", "BBEEEBB")
+                .aisle("BCCCCCB", "BCAFACB", "BCAFACB", "BCGGGCB", "BEAAAEB", "BEHHHEB")
+                .aisle("CCCCCCC", "CAAFAAC", "CAAFAAC", "CGGGGGC", "EAAAAAE", "EHHHHHE")
+                .aisle("CCCCCCC", "DFFFFFD", "CFFFFFC", "CGGGGGC", "EAAAAAE", "EHHMHHE")
+                .aisle("CCCCCCC", "CAAFAAC", "CAAFAAC", "CGGGGGC", "EAAAAAE", "EHHHHHE")
+                .aisle("BCCCCCB", "BCAFACB", "BCAFACB", "BCGGGCB", "BEAAAEB", "BEHHHEB")
+                .aisle("BBCCCBB", "BBCICBB", "BBCCCBB", "BBCCCBB", "BBEEEBB", "BBEEEBB")
+                .where('A', Predicates.blocks("minecraft:air"))
+                .where('B', Predicates.any())
+                .where('C', Predicates.blocks('gtceu:solid_machine_casing').setMinGlobalLimited(10) 
+                    .or(Predicates.abilities(PartAbility.MAINTENANCE).setExactLimit(1))
+                    .or(Predicates.abilities(PartAbility.PARALLEL_HATCH).setMaxGlobalLimited(1))
+                    .or(Predicates.autoAbilities(definition.getRecipeTypes())))
+                .where('D', Predicates.blocks("gtceu:steel_firebox_casing"))
+                .where('E', Predicates.blocks("gtceu:laminated_glass"))
+                .where('F', Predicates.blocks("gtceu:ptfe_pipe_casing"))
+                .where('G', Predicates.heatingCoils())
+                .where('H', Predicates.blocks("gtceu:high_temperature_smelting_casing"))
+                .where('M', Predicates.abilities(PartAbility.MUFFLER).setExactLimit(1))
+                .where('I', Predicates.controller(Predicates.blocks(definition.get())))
+                .build())
+            .workableCasingModel("gtceu:block/casings/solid/machine_casing_solid_steel",
+                "gtceu:block/multiblock/pyrolyse_oven");
+    
+    })
+    ```
+
+
+=== "Java"
+    ```java title="MultiMachines.java"
+
+    public static final MultiblockMachineDefinition SUPERHEATED_PYROLYZING_OVEN = REGISTRATE
+            .multiblock("superheated_pyrolyzing_oven", (holder) -> new CoilWorkableElectricMultiblockMachine(holder))
+            .rotationState(RotationState.NON_Y_AXIS)
+            .recipeType(GTRecipeTypes.PYROLYSE_RECIPES)
+            .recipeModifiers(GTRecipeModifiers.PARALLEL_HATCH,
+                (machine, recipe) -> GTRecipeModifiers.pyrolyseOvenOverclock(machine, recipe))
+            .appearanceBlock(GTBlocks.CASING_STEEL_SOLID)
+            .pattern(definition -> FactoryBlockPattern.start()
+                .aisle("BBCCCBB", "BBCDCBB", "BBCCCBB", "BBCCCBB", "BBEEEBB", "BBEEEBB")
+                .aisle("BCCCCCB", "BCAFACB", "BCAFACB", "BCGGGCB", "BEAAAEB", "BEHHHEB")
+                .aisle("CCCCCCC", "CAAFAAC", "CAAFAAC", "CGGGGGC", "EAAAAAE", "EHHHHHE")
+                .aisle("CCCCCCC", "DFFFFFD", "CFFFFFC", "CGGGGGC", "EAAAAAE", "EHHMHHE")
+                .aisle("CCCCCCC", "CAAFAAC", "CAAFAAC", "CGGGGGC", "EAAAAAE", "EHHHHHE")
+                .aisle("BCCCCCB", "BCAFACB", "BCAFACB", "BCGGGCB", "BEAAAEB", "BEHHHEB")
+                .aisle("BBCCCBB", "BBCICBB", "BBCCCBB", "BBCCCBB", "BBEEEBB", "BBEEEBB")
+                .where('A', Predicates.air())
+                .where('B', Predicates.any())
+                .where('C', Predicates.blocks(GTBlocks.CASING_STEEL_SOLID.get()).setMinGlobalLimited(10)
+                    .or(Predicates.abilities(PartAbility.MAINTENANCE).setExactLimit(1))
+                    .or(Predicates.abilities(PartAbility.PARALLEL_HATCH).setMaxGlobalLimited(1))
+                    .or(Predicates.autoAbilities(definition.getRecipeTypes())))
+                .where('D', Predicates.blocks(GTBlocks.FIREBOX_STEEL.get()))
+                .where('E', Predicates.blocks(CASING_LAMINATED_GLASS.get()))
+                .where('F', Predicates.blocks(GTBlocks.CASING_POLYTETRAFLUOROETHYLENE_PIPE.get()))
+                .where('G', Predicates.heatingCoils())
+                .where('H', Predicates.blocks(GCYMBlocks.CASING_HIGH_TEMPERATURE_SMELTING.get()))
+                .where('M', Predicates.abilities(PartAbility.MUFFLER).setExactLimit(1))
+                .where('I', Predicates.controller(Predicates.blocks(definition.get())))
+                .build())
+            .workableCasingModel(GTCEu.id("block/casings/solid/machine_casing_solid_steel"),
+                 GTCEu.id("block/multiblock/pyrolyse_oven"))
+            .register();
+    ```
+
+### Lang
+
+```json title="en_us.json"
+{
+    "block.gtceu.superheated_pyrolyzing_oven": "Superheated Pyrolyzing Oven",
+}
+```
+
+
diff --git a/docs/content/Modpacks/Examples/Example_Steam_Multiblock.md b/docs/content/Modpacks/Examples/Example_Steam_Multiblock.md
new file mode 100644
index 00000000000..57b06f47885
--- /dev/null
+++ b/docs/content/Modpacks/Examples/Example_Steam_Multiblock.md
@@ -0,0 +1,87 @@
+---
+title: "Example Steam Multiblock"
+---
+
+### Large Steam Compressor Multiblock 
+
+Below is an example of a multiblock using the SteamParallelMultiblockMachine class.
+Steam multiblocks such as the Steam Grinder and Steam Oven use this class.
+
+### Multiblock
+
+=== "JavaScript"
+    ```js title="example_steam_multiblock_multiblock.js"
+    
+    // In order to use multiblock logic extending beyond the default multiblock type for KJS (WorkableElectricMultiblockMachine), you need to load a class.
+    const $SteamMulti = Java.loadClass('com.gregtechceu.gtceu.common.machine.multiblock.steam.SteamParallelMultiblockMachine');
+
+    GTCEuStartupEvents.registry('gtceu:machine', event => {
+        event.create('large_steam_compressor', 'multiblock')
+            .machine((holder) => new $SteamMulti(holder, 4))
+            // The number in holder is the max amount of parallel it can use.
+            .rotationState(RotationState.NON_Y_AXIS)
+            .recipeType('compressor')
+            .recipeModifier((machine, recipe) => $SteamMulti.recipeModifier(machine, recipe), true)
+            .pattern(definition => FactoryBlockPattern.start()
+                .aisle("BCCCB", "BBCBB", "BBCBB", "BBBBB", "BBBBB")
+                .aisle("CDDDC", "BDBDB", "BDEDB", "BBDBB", "BBBBB")
+                .aisle("CDDDC", "CBBBC", "CEFEC", "BDDDB", "BBGBB")
+                .aisle("CDDDC", "BDBDB", "BDEDB", "BBDBB", "BBBBB")
+                .aisle("BCCCB", "BBHBB", "BBCBB", "BBBBB", "BBBBB")
+                .where('B', Predicates.any())
+                .where('C', Predicates.blocks('gtceu:steam_machine_casing').setMinGlobalLimited(10)
+                   .or(Predicates.abilities(PartAbility.STEAM_IMPORT_ITEMS).setMaxGlobalLimited(1))
+                   .or(Predicates.abilities(PartAbility.STEAM).setMaxGlobalLimited(1))
+                   .or(Predicates.abilities(PartAbility.STEAM_EXPORT_ITEMS).setMaxGlobalLimited(1)))
+                .where('D', Predicates.blocks("gtceu:industrial_steam_casing"))
+                .where('E', Predicates.blocks("gtceu:bronze_brick_casing"))
+                .where('F', Predicates.blocks("gtceu:bronze_firebox_casing"))
+                .where('G', Predicates.blocks("gtceu:bronze_machine_casing"))
+                .where('H', Predicates.controller(Predicates.blocks(definition.get())))
+                .build())
+            .workableCasingModel("gtceu:block/casings/steam/bronze/bottom",
+                "gtceu:block/machines/compressor")
+    })
+    ```
+
+=== "Java"
+    ```java title="MultiMachines.java"
+    public static final MultiblockMachineDefinition LARGE_STEAM_COMPRESSOR = REGISTRATE
+            .multiblock("large_steam_compressor", (holder) -> new SteamParallelMultiblockMachine(holder, 4))
+            .rotationState(RotationState.NON_Y_AXIS)
+            .recipeType(COMPRESSOR_RECIPES)
+            .recipeModifier((machine, recipe) -> SteamParallelMultiblockMachine.recipeModifier(machine, recipe), true)
+            .pattern(definition -> FactoryBlockPattern.start()
+                    .aisle("BCCCB", "BBCBB", "BBCBB", "BBBBB", "BBBBB")
+                    .aisle("CDDDC", "BDBDB", "BDEDB", "BBDBB", "BBBBB")
+                    .aisle("CDDDC", "CBBBC", "CEFEC", "BDDDB", "BBGBB")
+                    .aisle("CDDDC", "BDBDB", "BDEDB", "BBDBB", "BBBBB")
+                    .aisle("BCCCB", "BBHBB", "BBCBB", "BBBBB", "BBBBB")
+                    .where('B', Predicates.any())
+                    .where('C', Predicates.blocks(GTBlocks.CASING_BRONZE_BRICKS.get()).setMinGlobalLimited(10)
+                            .or(Predicates.abilities(PartAbility.STEAM_IMPORT_ITEMS).setMaxGlobalLimited(1))
+                            .or(Predicates.abilities(PartAbility.STEAM).setMaxGlobalLimited(1))
+                            .or(Predicates.abilities(PartAbility.STEAM_EXPORT_ITEMS).setMaxGlobalLimited(1)))
+                    .where('D', Predicates.blocks(GCYMBlocks.CASING_INDUSTRIAL_STEAM.get()))
+                    .where('E', Predicates.blocks(GTBlocks.BRONZE_BRICKS_HULL.get()))
+                    .where('F', Predicates.blocks(GTBlocks.FIREBOX_BRONZE.get()))
+                    .where('G', Predicates.blocks(GTBlocks.BRONZE_HULL.get()))
+                    .where('H', Predicates.controller(Predicates.blocks(definition.get())))
+                    .build())
+            .workableCasingModel(GTCEu.id("block/casings/steam/bronze/bottom"),
+                    GTCEu.id("block/machines/compressor"))
+            .register();
+    ```
+
+### Lang
+
+```json title="en_us.json"
+{
+    "block.gtceu.large_steam_compressor": "Large Steam Compressor",
+}
+```
+
+
+
+
+
diff --git a/docs/content/Modpacks/Examples/Example_Turbine.md b/docs/content/Modpacks/Examples/Example_Turbine.md
new file mode 100644
index 00000000000..4abdeefe1d5
--- /dev/null
+++ b/docs/content/Modpacks/Examples/Example_Turbine.md
@@ -0,0 +1,94 @@
+---
+title: "Example Turbine"
+---
+
+### Example Turbine
+
+Below is an example of a multiblock using the LargeTurbineMachine class for making custom large turbines.
+
+### Multiblock
+
+=== "JavaScript"
+    ```js title="hyper_gas_turbine.js"
+    // In order to use multiblock logic extending beyond the normal WorkableElectricMultiblockMachine, (This is the multiblock type used by default for kubejs) you need to load a class. LargeTurbineMachines such as the gas, steam, and plasma turbines use this class.
+    const $LargeTurbineMachine = Java.loadClass("com.gregtechceu.gtceu.common.machine.multiblock.generator.LargeTurbineMachine")
+    
+    GTCEuStartupEvents.registry('gtceu:machine', event => {
+        event.create('hyper_gas_turbine', 'multiblock')
+            .machine((holder) => new $LargeTurbineMachine(holder, GTValues.LuV)) // The value shows one rotor holder tier above the recommended minimum rotor holder. The tier of rotor holder provides a boost based on the efficiency stat.
+            .rotationState(RotationState.NON_Y_AXIS)
+            .recipeTypes("gas_turbine")
+            .recipeModifiers([GTRecipeModifiers.OC_NON_PERFECT_SUBTICK, GTRecipeModifiers.BATCH_MODE, (machine, recipe) => GTRecipeModifiers.LargeTurbineMachine(machine, recipe)])
+            .appearanceBlock(GTBlocks.CASING_TITANIUM_STABLE)
+            .pattern(definition => FactoryBlockPattern.start()
+                    .aisle("BBBBBBB", "BBBCBBB", "BBBDBBB", "BBBCBBB", "BBBBBBB")
+                    .aisle("BBBCBBB", "BBCACBB", "BBCFCBB", "BBCACBB", "BBBCBBB")
+                    .aisle("BBCCCBB", "BCAAACB", "BCAFACB", "BCAFACB", "BBCCCBB")
+                    .aisle("BCCCCCB", "CAAFAAC", "CFFFFFC", "CAFFFAC", "BCCECCB")
+                    .aisle("BBCCCBB", "BCAAACB", "BCAFACB", "BCAFACB", "BBCCCBB")
+                    .aisle("BBBCBBB", "BBCACBB", "BBCFCBB", "BBCACBB", "BBBCBBB")
+                    .aisle("BBBBBBB", "BBBCBBB", "BBBGBBB", "BBBCBBB", "BBBBBBB")
+                .where("A", Predicates.blocks("minecraft:air"))
+                .where("B", Predicates.any())
+                .where("C", Predicates.blocks("gtceu:stainless_steel_turbine_casing")
+                    .or(Predicates.autoAbilities(definition.getRecipeTypes()))
+                    .or(Predicates.abilities(PartAbility.MAINTENANCE).setExactLimit(1)))
+                .where("D", Predicates.ability(PartAbility.MUFFLER).setExactLimit(1))
+                .where("E", Predicates.ability(PartAbility.ROTOR_HOLDER).setExactLimit(1))
+                .where("F", Predicates.blocks("gtceu:stainless_steel_frame"))
+                .where("G", Predicates.controller(Predicates.blocks(definition.get())))
+                .build())
+            .workableCasingModel("gtceu:block/casings/mechanic/machine_casing_turbine_stainless_steel",
+                "gtceu:block/multiblock/generator/large_gas_turbine")
+    });
+    ```
+
+=== "Java"
+    ```java title="MultiMachines.java"
+    public static final MultiblockMachineDefinition HYPER_GAS_TURBINE = REGISTRATE
+            .multiblock("hyper_gas_turbine", (holder) -> new LargeTurbineMachine(holder, GTValues.LuV, 4)) // The value shows one rotor holder tier above the recommended minimum rotor holder. The tier of rotor holder provides a boost based on the efficiency stat.
+            .rotationState(RotationState.NON_Y_AXIS)
+            .recipeType(GTRecipeTypes.GAS_TURBINE_FUELS)
+            .recipeModifiers(GTRecipeModifiers.OC_NON_PERFECT_SUBTICK, GTRecipeModifiers.BATCH_MODE, LargeTurbineMachine::recipeModifier)
+            .pattern(definition -> FactoryBlockPattern.start()
+                .aisle("BBBBBBB", "BBBCBBB", "BBBDBBB", "BBBCBBB", "BBBBBBB")
+                .aisle("BBBCBBB", "BBCACBB", "BBCECBB", "BBCACBB", "BBBCBBB")
+                .aisle("BBCCCBB", "BCAAACB", "BCAEACB", "BCAEACB", "BBCCCBB")
+                .aisle("BCCCCCB", "CAAEAAC", "CEEEEEC", "CAEEEAC", "BCCFCCB")
+                .aisle("BBCCCBB", "BCAAACB", "BCAEACB", "BCAEACB", "BBCCCBB")
+                .aisle("BBBCBBB", "BBCACBB", "BBCECBB", "BBCACBB", "BBBCBBB")
+                .aisle("BBBBBBB", "BBBCBBB", "BBBGBBB", "BBBCBBB", "BBBBBBB")
+                .where("A", Predicates.blocks("minecraft:air"))
+                .where("B", Predicates.any())
+                .where("C", Predicates.blocks("gtceu:stainless_steel_turbine_casing")
+                    .or(Predicates.autoAbilities(definition.getRecipeTypes()))
+                    .or(Predicates.abilities(PartAbility.MAINTENANCE).setExactLimit(1)))
+                .where("D", Predicates.ability(PartAbility.MUFFLER).setExactLimit(1))
+                .where("F", Predicates.ability(PartAbility.ROTOR_HOLDER).setExactLimit(1))
+                .where("E", Predicates.blocks("gtceu:stainless_steel_frame"))
+                .where("G", Predicates.controller(Predicates.blocks(definition.get())))
+                    .build())
+            .workableCasingModel(GTCEu.id("block/casings/steam/bronze/bottom"),
+                    GTCEu.id("block/machines/compressor"))
+            .register();
+    ```
+
+
+### Lang
+
+```json title="en_us.json"
+{
+    "block.gtceu.hyper_gas_turbine": "Hyper Gas Turbine",
+}
+```
+
+
+
+
+
+
+
+
+
+
+
diff --git a/docs/content/Modpacks/Examples/Greenhouse.md b/docs/content/Modpacks/Examples/Greenhouse.md
new file mode 100644
index 00000000000..e69de29bb2d
diff --git a/docs/content/Modpacks/Other-Topics/Modular-Items.md b/docs/content/Modpacks/Other-Topics/Modular-Items.md
new file mode 100644
index 00000000000..8d83390c21c
--- /dev/null
+++ b/docs/content/Modpacks/Other-Topics/Modular-Items.md
@@ -0,0 +1,154 @@
+---
+title: Modular Items
+---
+
+# Modular Items
+
+### IModularItem
+
+`IModularItem` is a capability that can be attached to item stacks.
+Its recommended implementation is `ModularItemStack`, which can be attached to a stack
+in an `AttachCapabilitiesEvent<ItemStack>` listener, or attached as an item component
+to a `ComponentItem` using `ModularItemComponent`. Note that if it is attached not as
+a component, module-related tooltips won't be displayed, and `onUse` and related methods won't work.
+
+!!! example "Attaching a `ModularItemStack` using an event"
+    ```java
+    @Mod.EventBusSubscriber(modid = "your_mod_id", bus = Mod.EventBusSubscriber.Bus.FORGE)
+    public static class ExampleEventListener {
+        @SubscribeEvent
+        public static void onAttachCapabilities(AttachCapabilitiesEvent<ItemStack> event) {
+            ItemStack stack = event.getObject();
+            if (stack.is(Items.DIAMOND_CHESTPLATE)) {
+                int slots = 5, maxTier = GTValues.HV;
+                List<ItemModuleSlot> defaultSlots = new ArrayList<>();
+                for (int i = 0; i < slots; i++) defaultSlots.add(GTItemModules.TIERED_SLOTS[maxTier]);
+                // ModularItemStack accepts a Function<ItemStack, List<ItemModuleSlot>> in the constructor
+                // The stack provided to that function is the same stack as here, so we can ignore it
+                event.addCapability(GTCEu.id("modular"), new ModularItemStack(stack, ignored -> defaultSlots));
+            }
+        }
+    }
+    ```
+
+!!! example "Attaching a `ModularItemComponent` to a `ComponentItem`"
+    ```java
+    public void attachModularComponent() {
+        // fertilizer will now have 3 MV module slots
+        GTItems.FERTILIZER.get().attachComponents(new ModularItemComponent(3, GTValues.MV));
+    }
+    ```
+
+### ItemModuleSlot
+
+An `ItemModuleSlot` is basically a `Predicate<ItemModule>` (a function that accepts an `ItemModule` and returns a `boolean`) with some other methods.
+It has 2 abstract methods for your subclasses to implement:
+
+- `acceptsModule(ItemModule)` -> `boolean`
+    returns whether the provided module can be put into this slot
+- `getDisplayName()` -> `Component`
+    returns the text to be displayed as part of the tooltip
+- `getSlotTexture()` -> `IDrawable` (returns `null` by default)
+    returns the texture to use for this slot in the equipment foundry UI, `null` means to use the default
+
+!!! example "Tiered slot implementation"
+    ```java
+    public class TieredItemModuleSlot extends ItemModuleSlot {
+    
+        @Getter
+        private final int tier;
+    
+        public TieredItemModuleSlot(ResourceLocation id, int tier) {
+            super(id);
+            this.tier = tier;
+        }
+    
+        @Override
+        public boolean acceptsModule(ItemModule module) {
+            return !(module instanceof ITieredItemModule tieredModule) || tieredModule.getTier() <= getTier();
+        }
+    
+        @Override
+        public Component getDisplayName() {
+            return Component.translatable("metaarmor.tooltip.modifier_slot.tiered", GTValues.VNF[getTier()]);
+        }
+    }
+    ```
+
+### ItemModule
+
+`ItemModule` is an NBT-serializable object that can be attached to modular items.<br>
+`AppliedItemModule` is an object that contains info about the module itself, the item
+it is applied to, and the module's NBT.
+
+??? info "List of all overridable methods in `ItemModule`"
+    - `getInfo()` -> `Component` (override required)<br>
+      returns the info about this module to display in XEI
+    - `onAttach(AppliedItemModule)` -> `void`<br>
+      called when this module is attached to a modular item
+    - `onRemove(AppliedItemModule)` -> `void`<br>
+      called when this module is removed from a modular item
+    - `onEquip(LivingEntity, AppliedItemModule)` -> `void`<br>
+      called when the armor piece this module is attached to is equipped
+    - `onUnequip(LivingEntity, AppliedItemModule)` -> `void`<br>
+      called when the armor piece this module is attached to is unequipped
+    - `onArmorTick(LivingEntity, AppliedItemModule)` -> `void`<br>
+      called each tick while the armor piece this module is attached to is equipped
+    - `onInventoryTick(Player, AppliedItemModule)` -> `void`<br>
+      called each tick while the item this module is attached to is in a player's inventory
+    - `appendHoverText(Level, TooltipFlag, List<Component>, AppliedItemModule)` -> `void`<br>
+      called to insert lines into the modular item's tooltip
+    - `useEnergyInInventory(LivingEntity, AppliedItemModule)` -> `boolean` (default `true`)<br>
+      returns whether to consume energy while the item is in a player's inventory, if `false`, the item
+      consumes energy only in armor slots
+    - `energyUsagePerTick(LivingEntity, AppliedItemModule)` -> `long` (default `0`)<br>
+      returns the amount of energy to consume this tick (called every tick)
+    - `changeDamage(LivingEntity, AppliedItemModule, float damage, DamageSource)`-> `float` (returns `damage` by default)<br>
+      returns the amount of damage to actually inflict, called each time the entity wearing the armor piece is damaged
+    - `canRemove(AppliedItemModule)` -> `boolean` (default `true`)<br>
+      returns whether this module can be removed from the item in an equipment foundry
+    - `isPPE(AppliedItemModule)` -> `boolean` (default `false`)<br>
+      returns whether armor pieces with this module should be considered personal protection equipment (hazmat)
+    - `canApplyTo(ItemStack)` -> `boolean`<br>
+      returns whether this module can be attached to the provided stack, by default returns whether a module of this type
+      is already attached to the stack (blocking more than one module of the same type)
+    - `isEnabled(AppliedItemModule)` -> `boolean` (default `true`)<br>
+      returns whether this module is enabled (all other methods, such as `onInventoryTick` won't be calld if it's disabled)
+    - `setEnabled(AppliedItemModule, boolean)` -> `void`<br>
+      by default, sets the return value of `isEnabled` by modifying this module's NBT; this method is not required to actually enable/disable this module
+    - `use(AppliedItemModule, Level, Player, InteractionHand)` -> `InteractionResultHolder<ItemStack>`<br>
+      called when the item this module is attached to is used
+    - `useOn(AppliedItemModule, UseOnContext)` -> `InteractionResult`<br>
+      called when the item this module is attached to is used on a block
+
+!!! example "Example of an energy shield module"
+    ```java
+    public class EnergyShieldItemModule extends TieredItemModule {
+    
+        public EnergyShieldItemModule(ResourceLocation id, int tier) {
+            super(id, tier);
+        }
+    
+        @Override
+        public Component getInfo() {
+            return Component.literal("Makes you invulnerable and consumes 1A " + GTValues.VNF[getTier()]);
+        }
+        
+        @Override
+        public long energyUsagePerTick(LivingEntity entity, AppliedItemModule module) {
+            return GTValues.V[getTier()];
+        }
+    
+        @Override
+        public float changeDamage(LivingEntity entity, AppliedItemModule module, float amount, DamageSource source) {
+            return 0;
+        }
+    
+        @Override
+        public void appendHoverText(Level level, TooltipFlag isAdvanced, List<Component> tooltips,
+                                    AppliedItemModule module) {
+            super.appendHoverText(level, isAdvanced, tooltips, module);
+            tooltips.add(Component.literal("Energy shield (" + GTValues.VNF[getTier()] + ")"));
+        }
+    }
+    ```
\ No newline at end of file
diff --git a/gradle/forge.versions.toml b/gradle/forge.versions.toml
index 51f1f825a7a..0dbbe67ff0f 100644
--- a/gradle/forge.versions.toml
+++ b/gradle/forge.versions.toml
@@ -8,9 +8,11 @@ jei = "15.20.0.115"
 rei = "12.1.785"
 emi = "1.1.13+1.20.1"
 ae2 = "15.0.18"
+mui = "3.1.5"
 kubejs = "2001.6.5-build.16"
 rhino = "2001.2.3-build.10"
 architectury = "9.2.14"
+clothmath = "+"
 clothconfig = "11.1.136"
 curios = "5.9.1+1.20.1"
 kotlinforforge = "4.11.0"
@@ -60,6 +62,8 @@ configuration       = { module = "dev.toma.configuration:configuration-forge-1.2
 mixinExtras-common  = { module = "io.github.llamalad7:mixinextras-common", version.ref = "mixinExtras" }
 mixinExtras-forge   = { module = "io.github.llamalad7:mixinextras-forge", version.ref = "mixinExtras" }
 
+mui = { module = "brachy.modularui:modularui-mc1.20.1", version.ref = "mui" }
+
 jei-common-api      = { module = "mezz.jei:jei-1.20.1-common-api", version.ref = "jei" }
 jei-forge-api       = { module = "mezz.jei:jei-1.20.1-forge-api", version.ref = "jei" }
 jei-forge-impl      = { module = "mezz.jei:jei-1.20.1-forge", version.ref = "jei" }
@@ -76,6 +80,7 @@ flywheel-forge      = { module = "dev.engine-room.flywheel:flywheel-forge-1.20.1
 kubejs              = { module = "dev.latvian.mods:kubejs-forge", version.ref = "kubejs" }
 rhino               = { module = "dev.latvian.mods:rhino-forge", version.ref = "rhino" }
 architectury        = { module = "dev.architectury:architectury-forge", version.ref = "architectury" }
+clothmath           = { module = "me.shedaniel.cloth:basic-math", version.ref = "clothmath" }
 clothconfig         = { module = "me.shedaniel.cloth:cloth-config-forge", version.ref = "clothconfig" }
 curios              = { module = "top.theillusivec4.curios:curios-forge", version.ref = "curios" }
 kotlinforforge      = { module = "thedarkcolour:kotlinforforge", version.ref = "kotlinforforge" }
@@ -118,7 +123,7 @@ ftbchunks-cm        = { module = "curse.maven:ftb-chunks-forge-314906", version.
 
 [bundles]
 jei = ["jei-common-api", "jei-forge-api", "jei-forge-impl"]
-rei = ["rei-plugin", "rei-forge"]
+rei = ["rei-plugin", "rei-forge", "clothmath"]
 rei-runtime = ["rei-forge", "architectury", "clothconfig"]
 kjs = ["kubejs", "rhino", "architectury"]
 
diff --git a/gradle/libs.versions.toml b/gradle/libs.versions.toml
index 96029a58b06..880fc1a6e45 100644
--- a/gradle/libs.versions.toml
+++ b/gradle/libs.versions.toml
@@ -10,6 +10,7 @@ lombok = "8.14"
 jetbrains-annotations = "26.0.1"
 renderNurse = "0.0.12"
 mixin = "0.8.7"
+evalEx = "3.6.0"
 
 [libraries]
 minecraft               = { module = "com.mojang:minecraft", version.ref = "minecraft" }
@@ -17,6 +18,7 @@ minecraftForge          = { module = "net.minecraftforge:forge", version.ref = "
 jetbrains-annotations   = { module = "org.jetbrains:annotations", version.ref = "jetbrains-annotations" }
 renderNurse             = { module = "net.neoforged:render-nurse", version.ref = "renderNurse" }
 mixin                   = { module = "org.spongepowered:mixin", version.ref = "mixin" }
+evalEx                  = { module = "com.ezylang:EvalEx", version.ref = "evalEx" }
 
 [plugins]
 modDevGradle            = { id = "net.neoforged.moddev.legacyforge", version.ref = "modDevGradle" }
diff --git a/gradle/scripts/repositories.gradle b/gradle/scripts/repositories.gradle
index 1b4d59ec81c..79543347d21 100644
--- a/gradle/scripts/repositories.gradle
+++ b/gradle/scripts/repositories.gradle
@@ -1,17 +1,23 @@
 repositories {
     mavenLocal()
     mavenCentral()
-    // force gradle to download FastUtil & LWJGL from the central maven so we can get source artifacts
+    // force gradle to download FastUtil and LWJGL from the central maven so we can get source artifacts
     exclusiveContent { // Force
         forRepository { mavenCentral() }
         filter {
             includeGroup("it.unimi.dsi")
             includeGroup("org.lwjgl")
+            includeGroupAndSubgroups("io.netty")
             includeGroup("com.google.guava")
             includeGroup("io.netty")
         }
     }
 
+    maven {
+        name 'GTCEu Maven'
+        url 'https://maven.gtceu.com'
+    }
+
     maven { // JEI
         name = "Jared's Maven"
         url = "https://maven.blamejared.com/"
diff --git a/src/generated/resources/assets/gtceu/blockstates/equipment_foundry.json b/src/generated/resources/assets/gtceu/blockstates/equipment_foundry.json
new file mode 100644
index 00000000000..54d31f3ed4a
--- /dev/null
+++ b/src/generated/resources/assets/gtceu/blockstates/equipment_foundry.json
@@ -0,0 +1,7 @@
+{
+  "variants": {
+    "": {
+      "model": "gtceu:block/equipment_foundry"
+    }
+  }
+}
\ No newline at end of file
diff --git a/src/generated/resources/assets/gtceu/blockstates/test_mui.json b/src/generated/resources/assets/gtceu/blockstates/test_mui.json
new file mode 100644
index 00000000000..c96e32638d9
--- /dev/null
+++ b/src/generated/resources/assets/gtceu/blockstates/test_mui.json
@@ -0,0 +1,28 @@
+{
+  "variants": {
+    "facing=down": {
+      "model": "gtceu:block/machine/test_mui",
+      "x": 90
+    },
+    "facing=east": {
+      "model": "gtceu:block/machine/test_mui",
+      "y": 90
+    },
+    "facing=north": {
+      "model": "gtceu:block/machine/test_mui"
+    },
+    "facing=south": {
+      "model": "gtceu:block/machine/test_mui",
+      "y": 180
+    },
+    "facing=up": {
+      "gtceu:z": 180,
+      "model": "gtceu:block/machine/test_mui",
+      "x": 270
+    },
+    "facing=west": {
+      "model": "gtceu:block/machine/test_mui",
+      "y": 270
+    }
+  }
+}
\ No newline at end of file
diff --git a/src/generated/resources/assets/gtceu/blockstates/test_mui_new.json b/src/generated/resources/assets/gtceu/blockstates/test_mui_new.json
new file mode 100644
index 00000000000..41ab9b075f2
--- /dev/null
+++ b/src/generated/resources/assets/gtceu/blockstates/test_mui_new.json
@@ -0,0 +1,28 @@
+{
+  "variants": {
+    "facing=down": {
+      "model": "gtceu:block/machine/test_mui_new",
+      "x": 90
+    },
+    "facing=east": {
+      "model": "gtceu:block/machine/test_mui_new",
+      "y": 90
+    },
+    "facing=north": {
+      "model": "gtceu:block/machine/test_mui_new"
+    },
+    "facing=south": {
+      "model": "gtceu:block/machine/test_mui_new",
+      "y": 180
+    },
+    "facing=up": {
+      "gtceu:z": 180,
+      "model": "gtceu:block/machine/test_mui_new",
+      "x": 270
+    },
+    "facing=west": {
+      "model": "gtceu:block/machine/test_mui_new",
+      "y": 270
+    }
+  }
+}
\ No newline at end of file
diff --git a/src/generated/resources/assets/gtceu/lang/en_ud.json b/src/generated/resources/assets/gtceu/lang/en_ud.json
index 53efcdcd9bf..954f793a4ff 100644
--- a/src/generated/resources/assets/gtceu/lang/en_ud.json
+++ b/src/generated/resources/assets/gtceu/lang/en_ud.json
@@ -58,6 +58,7 @@
   "behavior.prospector.not_enough_energy": "¡ʎbɹǝuƎ ɥbnouƎ ʇoN",
   "behavior.toggle_energy_consumer.tooltip": "ǝpoɯ ǝןbboʇ oʇ ǝs∩",
   "behaviour.boor.by": "%s ʎq",
+  "behaviour.charger_linked": "ɹǝbɹɐɥɔ pǝʞuıꞀ",
   "behaviour.hammer": ")ɯǝɥʇ buıʇʇıɥ ʎq( sǝuıɥɔɐW ɹoɟ buıןɟɟnW ɟɟo puɐ uo suɹn⟘",
   "behaviour.hoe": "ʇɹıp ןןıʇ uɐƆ",
   "behaviour.lighter.fluid.tooltip": "ǝuɐdoɹԀ ɹo ǝuɐʇnᗺ ɥʇıʍ ǝɹıɟ uo sbuıɥʇ ʇɥbıן uɐƆ",
@@ -211,6 +212,7 @@
   "block.gtceu.empty_tier_ii_battery": "ɹoʇıɔɐdɐƆ II ɹǝı⟘ ʎʇdɯƎ",
   "block.gtceu.empty_tier_iii_battery": "ɹoʇıɔɐdɐƆ III ɹǝı⟘ ʎʇdɯƎ",
   "block.gtceu.engine_intake_casing": "buısɐƆ ǝʞɐʇuI ǝuıbuƎ",
+  "block.gtceu.equipment_foundry": "ʎɹpunoℲ ʇuǝɯdınbƎ",
   "block.gtceu.ev_16a_energy_converter": "ɹǝʇɹǝʌuoƆ ʎbɹǝuƎ ɹ§Ɐǝ§9Ɩ ɹ§ΛƎϛ§",
   "block.gtceu.ev_1a_energy_converter": "ɹǝʇɹǝʌuoƆ ʎbɹǝuƎ ɹ§Ɐǝ§Ɩ ɹ§ΛƎϛ§",
   "block.gtceu.ev_4a_energy_converter": "ɹǝʇɹǝʌuoƆ ʎbɹǝuƎ ɹ§Ɐǝ§ㄣ ɹ§ΛƎϛ§",
@@ -1133,6 +1135,8 @@
   "block.gtceu.substation_capacitor.tooltip_filled": "∩Ǝ %dɟ§ :ʎʇıɔɐdɐƆ ʎbɹǝuƎɔ§",
   "block.gtceu.superconducting_coil": "ʞɔoןᗺ ןıoƆ buıʇɔnpuoɔɹǝdnS",
   "block.gtceu.tempered_glass": "ssɐן⅁ pǝɹǝdɯǝ⟘",
+  "block.gtceu.test_mui": "ınW ʇsǝ⟘",
+  "block.gtceu.test_mui_new": "ʍǝN ınW ʇsǝ⟘",
   "block.gtceu.the_end_marker": "puƎ ǝɥ⟘",
   "block.gtceu.the_nether_marker": "ɹǝɥʇǝN ǝɥ⟘",
   "block.gtceu.titanium_crate": "ǝʇɐɹƆ ɯnıuɐʇı⟘",
@@ -1777,7 +1781,9 @@
   "config.gtceu.option.coloredWireOutline": "ǝuıןʇnOǝɹıMpǝɹoןoɔ",
   "config.gtceu.option.compat": "ʇɐdɯoɔ",
   "config.gtceu.option.createCompat": "ʇɐdɯoƆǝʇɐǝɹɔ",
+  "config.gtceu.option.cursorColor": "ɹoןoƆɹosɹnɔ",
   "config.gtceu.option.debug": "bnqǝp",
+  "config.gtceu.option.debugUI": "I∩bnqǝp",
   "config.gtceu.option.debugWorldgen": "uǝbpןɹoMbnqǝp",
   "config.gtceu.option.defaultPaintingColor": "ɹoןoƆbuıʇuıɐԀʇןnɐɟǝp",
   "config.gtceu.option.defaultUIColor": "ɹoןoƆI∩ʇןnɐɟǝp",
@@ -1805,6 +1811,7 @@
   "config.gtceu.option.energyUsageMultiplier": "ɹǝıןdıʇןnWǝbɐs∩ʎbɹǝuǝ",
   "config.gtceu.option.environmentalHazardDecayRate": "ǝʇɐᴚʎɐɔǝᗡpɹɐzɐHןɐʇuǝɯuoɹıʌuǝ",
   "config.gtceu.option.environmentalHazards": "spɹɐzɐHןɐʇuǝɯuoɹıʌuǝ",
+  "config.gtceu.option.escRestoresLastText": "ʇxǝ⟘ʇsɐꞀsǝɹoʇsǝᴚɔsǝ",
   "config.gtceu.option.euToFeRatio": "oıʇɐᴚǝℲo⟘nǝ",
   "config.gtceu.option.extractorRecyclingYield": "pןǝıʎbuıןɔʎɔǝᴚɹoʇɔɐɹʇxǝ",
   "config.gtceu.option.feToEuRatio": "oıʇɐᴚnƎo⟘ǝɟ",
@@ -1856,6 +1863,7 @@
   "config.gtceu.option.meHatchEnergyUsage": "ǝbɐs∩ʎbɹǝuƎɥɔʇɐHǝɯ",
   "config.gtceu.option.minerSpeed": "pǝǝdSɹǝuıɯ",
   "config.gtceu.option.minimap": "dɐɯıuıɯ",
+  "config.gtceu.option.mui": "ınɯ",
   "config.gtceu.option.nanoSaber": "ɹǝqɐSouɐu",
   "config.gtceu.option.nanoSaberBaseDamage": "ǝbɐɯɐᗡǝsɐᗺɹǝqɐSouɐu",
   "config.gtceu.option.nanoSaberDamageBoost": "ʇsooᗺǝbɐɯɐᗡɹǝqɐSouɐu",
@@ -1876,6 +1884,7 @@
   "config.gtceu.option.oreVeinGridSize": "ǝzıSpıɹ⅁uıǝΛǝɹo",
   "config.gtceu.option.oreVeinRandomOffset": "ʇǝsɟɟOɯopuɐᴚuıǝΛǝɹo",
   "config.gtceu.option.oreVeins": "suıǝΛǝɹo",
+  "config.gtceu.option.outlineColor": "ɹoןoƆǝuıןʇno",
   "config.gtceu.option.ownerOPBypass": "ssɐdʎᗺԀOɹǝuʍo",
   "config.gtceu.option.prospectorEnergyUseMultiplier": "ɹǝıןdıʇןnWǝs∩ʎbɹǝuƎɹoʇɔǝdsoɹd",
   "config.gtceu.option.quantumTank": "ʞuɐ⟘ɯnʇuɐnb",
@@ -1889,14 +1898,28 @@
   "config.gtceu.option.renderGrowingPlants": "sʇuɐןԀbuıʍoɹ⅁ɹǝpuǝɹ",
   "config.gtceu.option.renderer": "ɹǝɹǝpuǝɹ",
   "config.gtceu.option.replaceMinedBlocksWith": "ɥʇıMsʞɔoןᗺpǝuıWǝɔɐןdǝɹ",
+  "config.gtceu.option.replaceVanillaTooltips": "sdıʇןoo⟘ɐןןıuɐΛǝɔɐןdǝɹ",
   "config.gtceu.option.replaceWithCobbleVersion": "uoısɹǝΛǝןqqoƆɥʇıMǝɔɐןdǝɹ",
   "config.gtceu.option.requireGTToolsForBlocks": "sʞɔoןᗺɹoℲsןoo⟘⟘⅁ǝɹınbǝɹ",
   "config.gtceu.option.rngDamageElectricTools": "sןoo⟘ɔıɹʇɔǝןƎǝbɐɯɐᗡbuɹ",
   "config.gtceu.option.rubberTreeSpawnChance": "ǝɔuɐɥƆuʍɐdSǝǝɹ⟘ɹǝqqnɹ",
   "config.gtceu.option.sandOresFall": "ןןɐℲsǝɹOpuɐs",
+  "config.gtceu.option.scale": "ǝןɐɔs",
   "config.gtceu.option.shouldWeatherOrTerrainExplosion": "uoısoןdxƎuıɐɹɹǝ⟘ɹOɹǝɥʇɐǝMpןnoɥs",
   "config.gtceu.option.showDimensionTier": "ɹǝı⟘uoısuǝɯıᗡʍoɥs",
+  "config.gtceu.option.showExtra": "ɐɹʇxƎʍoɥs",
+  "config.gtceu.option.showHovered": "pǝɹǝʌoHʍoɥs",
+  "config.gtceu.option.showOutline": "ǝuıןʇnOʍoɥs",
+  "config.gtceu.option.showParent": "ʇuǝɹɐԀʍoɥs",
+  "config.gtceu.option.showParentOutline": "ǝuıןʇnOʇuǝɹɐԀʍoɥs",
+  "config.gtceu.option.showParentPos": "soԀʇuǝɹɐԀʍoɥs",
+  "config.gtceu.option.showParentSize": "ǝzıSʇuǝɹɐԀʍoɥs",
+  "config.gtceu.option.showParentWidgetTheme": "ǝɯǝɥ⟘ʇǝbpıMʇuǝɹɐԀʍoɥs",
+  "config.gtceu.option.showPos": "soԀʍoɥs",
+  "config.gtceu.option.showSize": "ǝzıSʍoɥs",
+  "config.gtceu.option.showWidgetTheme": "ǝɯǝɥ⟘ʇǝbpıMʍoɥs",
   "config.gtceu.option.smallBoilers": "sɹǝןıoᗺןןɐɯs",
+  "config.gtceu.option.smoothProgressBar": "ɹɐᗺssǝɹboɹԀɥʇooɯs",
   "config.gtceu.option.solarBoilerBaseOutput": "ʇndʇnOǝsɐᗺɹǝןıoᗺɹɐןos",
   "config.gtceu.option.solidBoilerBaseOutput": "ʇndʇnOǝsɐᗺɹǝןıoᗺpıןos",
   "config.gtceu.option.sprayCanChainLength": "ɥʇbuǝꞀuıɐɥƆuɐƆʎɐɹds",
@@ -1908,17 +1931,21 @@
   "config.gtceu.option.surfaceRockProspectRange": "ǝbuɐᴚʇɔǝdsoɹԀʞɔoᴚǝɔɐɟɹns",
   "config.gtceu.option.tankItemFluidPreview": "ʍǝıʌǝɹԀpınןℲɯǝʇIʞuɐʇ",
   "config.gtceu.option.temperaturesInCelsius": "snısןǝƆuIsǝɹnʇɐɹǝdɯǝʇ",
+  "config.gtceu.option.textColor": "ɹoןoƆʇxǝʇ",
   "config.gtceu.option.titaniumBoilerHeatSpeed": "pǝǝdSʇɐǝHɹǝןıoᗺɯnıuɐʇıʇ",
   "config.gtceu.option.titaniumBoilerMaxTemperature": "ǝɹnʇɐɹǝdɯǝ⟘xɐWɹǝןıoᗺɯnıuɐʇıʇ",
   "config.gtceu.option.toggle": "ǝןbboʇ",
   "config.gtceu.option.toolCraftingSounds": "spunoSbuıʇɟɐɹƆןooʇ",
   "config.gtceu.option.toolUseSounds": "spunoSǝs∩ןooʇ",
   "config.gtceu.option.tools": "sןooʇ",
+  "config.gtceu.option.tooltipPos": "soԀdıʇןooʇ",
   "config.gtceu.option.treeFellingDelay": "ʎɐןǝᗡbuıןןǝℲǝǝɹʇ",
   "config.gtceu.option.tungstensteelBoilerHeatSpeed": "pǝǝdSʇɐǝHɹǝןıoᗺןǝǝʇsuǝʇsbunʇ",
   "config.gtceu.option.tungstensteelBoilerMaxTemperature": "ǝɹnʇɐɹǝdɯǝ⟘xɐWɹǝןıoᗺןǝǝʇsuǝʇsbunʇ",
+  "config.gtceu.option.ui": "ın",
   "config.gtceu.option.universalHazards": "spɹɐzɐHןɐsɹǝʌıun",
   "config.gtceu.option.updateIntervals": "sןɐʌɹǝʇuIǝʇɐpdn",
+  "config.gtceu.option.useDarkThemeByDefault": "ʇןnɐɟǝᗡʎᗺǝɯǝɥ⟘ʞɹɐᗡǝsn",
   "config.gtceu.option.useVBO": "OᗺΛǝsn",
   "config.gtceu.option.voltageTierAdvImpeller": "ɹǝןןǝdɯIʌpⱯɹǝı⟘ǝbɐʇןoʌ",
   "config.gtceu.option.voltageTierAdvNanoSuit": "ʇınSouɐNʌpⱯɹǝı⟘ǝbɐʇןoʌ",
@@ -2029,20 +2056,18 @@
   "cover.conveyor.transfer_rate": "ɔǝs/sɯǝʇıㄥ§",
   "cover.detector_base.message_inverted_state": "pǝʇɹǝʌuI :snʇɐʇS buıɹoʇıuoW",
   "cover.detector_base.message_normal_state": "ןɐɯɹoN :snʇɐʇS buıɹoʇıuoW",
-  "cover.ender_fluid_link.incomplete_hex.0": "¡ǝʇǝןdɯoɔuı sı ɹoןoɔ pǝʇʇnduI",
-  "cover.ender_fluid_link.incomplete_hex.1": ")sʇıbıp xǝɥ 8 ןןɐ( ǝʇǝןdɯoɔ ǝɔuo pǝıןddɐ ǝq ןןıʍ ʇI",
-  "cover.ender_fluid_link.incomplete_hex.2": "¡sʇıpǝ ǝsoן ןןıʍ ınb ǝɥʇ buısoןƆ",
   "cover.ender_fluid_link.iomode.disabled": "pǝןqɐsıᗡ O/I",
   "cover.ender_fluid_link.iomode.enabled": "pǝןqɐuƎ O/I",
-  "cover.ender_fluid_link.private.tooltip.disabled.0": "ǝpoɯ ʞuɐʇ ǝʇɐʌıɹd oʇ ɥɔʇıʍS",
-  "cover.ender_fluid_link.private.tooltip.disabled.1": "ɹǝʌoɔ ǝɥʇ pǝɔɐןd ʎןןɐuıbıɹo oɥʍ ɹǝʎɐןd ǝɥʇ sǝsn ǝpoɯ ǝʇɐʌıɹԀ",
-  "cover.ender_fluid_link.private.tooltip.enabled": "ǝpoɯ ʞuɐʇ ɔıןqnd oʇ ɥɔʇıʍS",
   "cover.ender_fluid_link.title": "ʞuıꞀ pınןℲ ɹǝpuƎ",
-  "cover.ender_fluid_link.tooltip.channel_description": "ʇxǝʇ ʇnduı ɥʇıʍ uoıʇdıɹɔsǝp ןǝuuɐɥɔ ʇǝS",
-  "cover.ender_fluid_link.tooltip.channel_name": "ʇxǝʇ ʇnduı ɥʇıʍ ǝɯɐu ןǝuuɐɥɔ ʇǝS",
-  "cover.ender_fluid_link.tooltip.clear_button": "uoıʇdıɹɔsǝp ןǝuuɐɥɔ ɹɐǝןƆ",
-  "cover.ender_fluid_link.tooltip.list_button": "ʇsıן ןǝuuɐɥɔ ʍoɥS",
   "cover.ender_item_link.title": "ʞuıꞀ ɯǝʇI ɹǝpuƎ",
+  "cover.ender_link.description_empty": "uoıʇdıɹɔsǝᗡ ʎʇdɯƎ",
+  "cover.ender_link.private.tooltip": "ɹǝʌoɔ sıɥʇ pǝɔɐןd oɥʍ ɹǝʎɐןd ǝɥʇ oʇ ǝןqıssǝɔɔɐ ʎןuO :ǝpoɯ ǝʇɐʌıɹԀ",
+  "cover.ender_link.protected.tooltip": "˙ɯɐǝʇ ǝɯɐs ǝɥʇ uo sɹǝʎɐןd oʇ ǝןqıssǝɔɔⱯ :ǝpoW pǝʇɔǝʇoɹԀ",
+  "cover.ender_link.public.tooltip": "sɹǝʎɐןd ןןɐ oʇ ǝןqıssǝɔɔⱯ :ǝpoɯ ɔıןqnԀ",
+  "cover.ender_link.tooltip.channel_description": "uoıʇdıɹɔsǝp ןǝuuɐɥƆ",
+  "cover.ender_link.tooltip.channel_name": ")ǝnןɐʌ ןɐɯıɔǝpɐxǝɥ ʇıq-ᄅƐ( ᗡI ןǝuuɐɥƆ",
+  "cover.ender_link.tooltip.clear_button": "uoıʇdıɹɔsǝp ןǝuuɐɥɔ ɹɐǝןƆ",
+  "cover.ender_link.tooltip.list_button": "ʇsıן ןǝuuɐɥɔ ʍoɥS",
   "cover.ender_redstone_link.title": "ʞuıꞀ ǝuoʇspǝᴚ ɹǝpuƎ",
   "cover.filter.blacklist.disabled": "ʇsıןǝʇıɥM",
   "cover.filter.blacklist.enabled": "ʇsıןʞɔɐןᗺ",
@@ -2080,6 +2105,7 @@
   "cover.item_smart_filter.filtering_mode.electrolyzer": "ɹǝzʎןoɹʇɔǝןƎ",
   "cover.item_smart_filter.filtering_mode.sifter": "ɹǝʇɟıS",
   "cover.item_smart_filter.title": "ɹǝʇןıℲ ɯǝʇI ʇɹɐɯS",
+  "cover.machine_controller.control": "ʇǝbɹɐ⟘ ɹǝןןoɹʇuoƆ",
   "cover.machine_controller.invert.disabled.0": "unɹ oʇ ןǝʌǝן ǝuoʇspǝɹ ʇǝs ǝɥʇ uɐɥʇ ɹǝʞɐǝʍ ןɐubıs ɐ ǝɹınbǝɹ ןןıʍ ɹǝʌoɔ ǝɥʇ 'ǝpoɯ sıɥʇ uı - ɹ§ןɐɯɹoNǝ§",
   "cover.machine_controller.invert.enabled.0": "unɹ oʇ ןǝʌǝן ǝuoʇspǝɹ ʇǝs ǝɥʇ uɐɥʇ ɹǝbuoɹʇs ןɐubıs ɐ ǝɹınbǝɹ ןןıʍ ɹǝʌoɔ ǝɥʇ 'ǝpoɯ sıɥʇ uı - ɹ§pǝʇɹǝʌuIǝ§",
   "cover.machine_controller.inverted": "pǝʇɹǝʌuI",
@@ -2192,6 +2218,7 @@
   "death.attack.gtceu.wrench_iv": "%s ʎq suɐןd ɹıǝɥʇ oʇuı uʍoɹɥʇ ɥɔuǝɹʍ ɐ pɐɥ %s",
   "death.attack.gtceu.wrench_lv": "%s ʎq pǝuǝsooן ǝɹǝʍ sǝdıd s,%s",
   "effect.gtceu.weak_poison": "uosıoԀ ʞɐǝM",
+  "emi.category.gtceu.equipment_foundry": "ʎɹpunoℲ ʇuǝɯdınbƎ",
   "enchantment.damage.disjunction": "uoıʇɔunظsıᗡ",
   "enchantment.disjunction": "uoıʇɔunظsıᗡ",
   "enchantment.gtceu.disjunction.description": "˙sqoɯ pǝʇɐןǝɹ-ɹǝpuƎ oʇ ssǝuʍoןS puɐ ssǝuʞɐǝM sǝıןddⱯ",
@@ -2235,6 +2262,10 @@
   "gtceu.canner": "ɹǝuuɐƆ",
   "gtceu.central_monitor.gui.create_group": "dnoɹb ǝʇɐǝɹƆ",
   "gtceu.central_monitor.gui.currently_editing": "%s :buıʇıpǝ ʎןʇuǝɹɹnƆ",
+  "gtceu.central_monitor.gui.data_slot": "ʞɔıʇs ɐʇɐp ɟo ɹǝqɯnu ʇoןs ʇǝS",
+  "gtceu.central_monitor.gui.group_editor": "dnoɹb ɹoʇıuoɯ buıʇıpƎ",
+  "gtceu.central_monitor.gui.group_name": ":ǝɯɐN",
+  "gtceu.central_monitor.gui.monitor_groups": "sdnoɹb ɹoʇıuoW",
   "gtceu.central_monitor.gui.remove_from_group": "dnoɹb ɯoɹɟ ǝʌoɯǝᴚ",
   "gtceu.central_monitor.gui.set_target": "ʇǝbɹɐʇ ʇǝS",
   "gtceu.central_monitor.info_tooltip.0": "˙ʇı uı ǝןnpoɯ Ɩ ǝʌɐɥ ʎןuo ʎɐɯ dnoɹb Ɐ ˙ʇsɹıɟ sdnoɹb oʇuı ɯǝɥʇ ʇıןds oʇ ǝʌɐɥ noʎ 'sɹoʇıuoɯ ǝsn oʇ ɹǝpɹo uI",
@@ -2291,7 +2322,8 @@
   "gtceu.creative.chest.ipc": "ǝןɔʎƆ ɹǝd sɯǝʇI",
   "gtceu.creative.chest.item": "ɯǝʇI",
   "gtceu.creative.chest.tpc": "ǝןɔʎƆ ɹǝd sʞɔı⟘",
-  "gtceu.creative.computation.average": "ʇ∩MƆ pǝʇsǝnbǝᴚ ǝbɐɹǝʌⱯ",
+  "gtceu.creative.computation.average": "%d :ʞɔıʇ/∩MƆ ǝbɐɹǝʌⱯ",
+  "gtceu.creative.computation.max_usage": ":ʞɔıʇ/∩MƆ xɐW",
   "gtceu.creative.energy.amperage": "ǝbɐɹǝdɯⱯ",
   "gtceu.creative.energy.sink": "ʞuıS",
   "gtceu.creative.energy.source": "ǝɔɹnoS",
@@ -2327,6 +2359,12 @@
   "gtceu.ender_redstone_link_cover.label": "%d :ɹǝʍod ǝuoʇspǝᴚ",
   "gtceu.ender_redstone_link_cover.title": "ʞuıꞀ ǝuoʇspǝᴚ ɹǝpuƎ",
   "gtceu.ender_redstone_link_cover.tooltip": "˙ㄥ§ɹǝʌoƆɟ§ sɐ ㄥ§uoıʇɔǝuuoƆ ɟ§ɹǝpuƎp§ ssǝןǝɹıMɟ§ ɐ ɥʇıʍ ㄥ§sןɐubıs ǝuoʇspǝᴚɟ§ sʇıɯsuɐɹ⟘ㄥ§",
+  "gtceu.equipment_foundry.gui.applied_to": ":oʇ pǝıןddⱯ",
+  "gtceu.equipment_foundry.gui.module_item": ":ɯǝʇı ǝןnpoW",
+  "gtceu.equipment_foundry.gui.supports_tiers": "%s-%s :sɹǝıʇ ǝןnpoW",
+  "gtceu.equipment_foundry.gui.tier": "%s :ɹǝıʇ ɹoɟ sʇɐʇs buıʍǝıΛ",
+  "gtceu.equipment_foundry.gui.tier_too_high": "ɹǝıʇ sıɥʇ ɹoɟ sʇsıxǝ ɯǝʇı ǝןnpoɯ oN",
+  "gtceu.equipment_foundry.gui.tooltip.tier_switch": "Ɩ ʎq ɹǝıʇ ǝsɐǝɹɔǝp oʇ ʞɔıןɔ-ʇɥbıᴚ\nƖ ʎq ɹǝıʇ ǝsɐǝɹɔuı oʇ ʞɔıןɔ-ʇɟǝꞀ",
   "gtceu.extractor": "ɹoʇɔɐɹʇxƎ",
   "gtceu.extruder": "ɹǝpnɹʇxƎ",
   "gtceu.fermenter": "ɹǝʇuǝɯɹǝℲ",
@@ -2371,10 +2409,24 @@
   "gtceu.gui.adv_stocking_config.title": "buıʞɔoʇS ɔıʇɐɯoʇnⱯ ǝɹnbıɟuoƆ",
   "gtceu.gui.all_voiding": "ןןⱯɔ§ buıpıoΛㄥ§",
   "gtceu.gui.auto_output.name": "oʇnɐ",
+  "gtceu.gui.central_monitor.data_hatch_target": "˙pɐǝʇsuı ʇǝbɹɐʇ ǝɥʇ pǝɹǝpısuoɔ ǝq ןןıʍ )ɹǝʌoɔ ɹǝʇʇıɯsuɐɹʇ ssǝןǝɹıʍ ɐ buıʞɔıןɔ-ʇɥbıɹ ɐıʌ( oʇ pǝʞuıן sı ʇoןs pǝıɟıɔǝds ǝɥʇ uı ʞɔıʇs ɐʇɐp ǝɥʇ ʇɐɥʇ ʞɔoןq ǝɥʇ uǝɥ⟘ ˙ɹǝqɯnu ʇoןs ɐ ɹǝʇuǝ oʇ pǝʇdɯoɹd ǝq ןןıʍ noʎ 'ʇǝbɹɐʇ ɐ sɐ ɥɔʇɐɥ ɐʇɐp ɐ ʇɔǝןǝs noʎ ɟI",
   "gtceu.gui.central_monitor.group": "%s :dnoɹ⅁",
   "gtceu.gui.central_monitor.group_default_name": "%d# dnoɹ⅁",
-  "gtceu.gui.central_monitor.none": "ǝuou",
+  "gtceu.gui.central_monitor.gui_module_info": "˙ɹoʇıpǝ dnoɹb ɹoʇıuoɯ ǝɥʇ uı ʇǝbɹɐʇ ɐ ʇɔǝןǝs 'ɯoɹɟ I∩⅁ ǝɥʇ ʇǝb oʇ ʞɔoןq ɐ ʇɔǝןǝs o⟘",
+  "gtceu.gui.central_monitor.help": ":suoıʇɔǝןǝs ɟo sǝdʎʇ ǝɹɐ ǝɹǝɥ 'xoqʇxǝʇ ǝɯɐu dnoɹb ǝɥʇ ʍoןǝq pıɹb ǝɥʇ uı ɹoʇıuoɯ Ɩ ʇsɐǝן ʇɐ ʇɔǝןǝs oʇ ǝʌɐɥ noʎ uǝɥ⟘\n)ʎɐןdsıp oʇ ʇxǝʇ ǝɥʇ ɹǝʇuǝ ʇsnظ ǝןdɯɐxǝ ɹoɟ( ǝןnpoɯ ǝɥʇ ǝɹnbıɟuoɔ oʇ ɹɐǝddɐ ןןıʍ uoʇʇnq ɐ 'ʇı ʇɹǝsuı noʎ uǝɥM\n˙xoqʇxǝʇ ǝɯɐu dnoɹb ǝɥʇ ɟo ʇɥbıɹ ǝɥʇ oʇ ʇoןs ǝɥʇ uı pǝʇɹǝsuı ǝq ʇsnɯ ǝןnpoɯ Ɐ\nǝןnpoɯ ɹoʇıuoɯ pǝɹnbıɟuoɔ puɐ pǝʇɹǝsuı uɐ - \nuo buıɥʇǝɯos ʎɐןdsıp oʇ ʇuɐʍ noʎ ʇɐɥʇ sɹoʇıuoɯ ǝɥʇ ʇɔǝןǝs oʇ noʎ - \n:sbuıɥʇ ᄅ spǝǝu ʇı 'buıɥʇʎuɐ ʎɐןdsıp oʇ dnoɹb ɐ ɹoℲ\n˙ʞɔoןqıʇןnɯ ǝɥʇ uı sɹoʇıuoɯ ɟo ʇunoɯɐ ʎuɐ ɟo uoıʇɔǝןןoɔ ɐ sı dnoɹb ɹoʇıuoɯ Ɐ",
+  "gtceu.gui.central_monitor.in_group": "ɟɟnʇs ʎɐןdsıp oʇ pǝsn ǝq ןןıʍ puɐ 'dnoɹb ǝɥʇ oʇ pǝppɐ ǝɹɐ ʎɐʍ sıɥʇ pǝʇɔǝןǝs sɹoʇıuoW",
+  "gtceu.gui.central_monitor.in_group_and_target": "˙ǝɯıʇ ǝɯɐs ǝɥʇ ʇɐ ʇǝbɹɐʇ ɐ sɐ puɐ buıʎɐןdsıp ɹoɟ pǝsn sı ʎɐʍ sıɥʇ pǝʇɔǝןǝs ɹoʇıuoɯ ǝɥ⟘",
+  "gtceu.gui.central_monitor.left_click": "ʇı buıʞɔıןɔ-ʇɟǝן ʎq ɹoʇıuoɯ ɐ ʇɔǝןǝsun/ʇɔǝןǝS",
+  "gtceu.gui.central_monitor.module_editor_button": "ǝןnpoɯ ʇıpƎ",
+  "gtceu.gui.central_monitor.module_editor_disabled": "ʇı ʇıpǝ oʇ I∩⅁ sıɥʇ uǝdo-ǝɹ ǝsɐǝןd 'ǝןnpoɯ ǝɥʇ pǝbuɐɥɔ ʎןʇuǝɔǝɹ noʎ",
+  "gtceu.gui.central_monitor.pause": "˙unɹ ǝq ʇ,uoʍ ǝpoɔ puɐ 'pǝʇɐpdn ǝq ʇ,uoʍ ʇxǝ⟘\n˙uoıʇnɔǝxǝ ɹǝpןoɥǝɔɐןd ǝsnɐԀ",
+  "gtceu.gui.central_monitor.resume": "˙uoıʇnɔǝxǝ ɹǝpןoɥǝɔɐןd ǝsnɐdu∩",
+  "gtceu.gui.central_monitor.right_click": "˙ʇǝbɹɐʇ ɐ ǝq uɐɔ ʞɔoןq Ɩ ʎןuO ˙ʇı buıʞɔıןɔ-ʇɥbıɹ ʎq ʞɔoןq ɐ ʇɔǝןǝS",
+  "gtceu.gui.central_monitor.target": "˙ǝןnpoɯ ʇxǝʇ ɐ uı sɹǝpןoɥǝɔɐןd ɥʇıʍ pǝsn ǝq oʇ 'ʇǝbɹɐʇ ɐ pǝɹǝpısuoɔ sı ʎɐʍ sıɥʇ pǝʇɔǝןǝs ʞɔoןq ǝɥ⟘",
+  "gtceu.gui.central_monitor.text_module_help": "\n:%0ϛ< sı ʎbɹǝuǝ uǝɥʍ ןɐubıs ǝuoʇspǝɹ ɐ spuǝs puɐ oɟuı ʎbɹǝuǝ ǝɯos sʎɐןdsıp ʇɐɥʇ 'sɹǝpןoɥǝɔɐןd ɟo ǝbɐsn ǝןdɯɐxǝ uɐ s,ǝɹǝH\n˙oɟuı ǝɹoɯ ɹoɟ ǝɹǝɥʇ ǝbɐd dןǝɥ ǝɥʇ ʇno ʞɔǝɥɔ 'ʍopuıʍ buıʇıpǝ dnoɹb ɹoʇıuoɯ ǝɥʇ uı ʇǝbɹɐʇ ɐ ʇɔǝןǝS\n˙SSԀ ɐ ɹo ɹǝɟɟnq ʎɹǝʇʇɐq ɐ ʎןןɐnsn 'ʞɔoןq ʇǝbɹɐʇ sʇı uı ʎbɹǝuǝ ɟo ʇunoɯɐ ǝɥʇ sʎɐןdsıp }ʎbɹǝuǝ{ ǝןdɯɐxǝ ɹoℲ ˙ʞɔoןqıʇןnɯ ɹoʇıuoɯ ןɐɹʇuǝɔ\nǝɥʇ ɟo ʇɹɐd sı ɹo sɹǝʌoɔ ʇdǝɔɔɐ uɐɔ ʇɐɥʇ ʞɔoןq ʎuɐ ʎןןɐɔısɐq sı ʇǝbɹɐʇ Ɐ ˙uoıʇɔunɟ oʇ ʇǝbɹɐʇ ɐ ǝʌɐɥ ʇsnɯ }ʎbɹǝuǝ{ ǝʞıן 'sɹǝpןoɥǝɔɐןd ǝɯoS\n˙ɔʇǝ 'suoıʇɐןnɔןɐɔ unɹ 'ʇnduı ǝuoʇspǝɹ pɐǝɹ/ʇndʇno ǝuoʇspǝɹ ɐ ʇǝs sɐ ɥɔns 'sbuıɥʇ ɹǝɥʇo ǝɯos op osןɐ uɐɔ ʎǝɥ⟘\n˙)ʎbɹǝuǝ ɟo ʇunoɯɐ ǝɥʇ ǝsɐɔ sıɥʇ uı( pɐǝʇsuı ǝnןɐʌ ɹıǝɥʇ ʎɐןdsıp ןןıʍ 'pǝʎɐןdsıp uǝɥʍ ʇɐɥʇ \"}ʎbɹǝuǝ{\" ǝʞıן sbuıɹʇs ǝɹɐ sɹǝpןoɥǝɔɐןԀ\n˙sɹǝpןoɥǝɔɐןd ǝʌɐɥ uɐɔ ʇɐɥʇ ʇxǝʇ sʎɐןdsıp ǝןnpoɯ sıɥ⟘",
   "gtceu.gui.central_monitor.text_scale": "ǝןɐɔs ʇxǝ⟘",
+  "gtceu.gui.central_monitor.update_once": "˙ǝɔuo ʎןʇɔɐxǝ ʇı uı sɹǝpןoɥǝɔɐןd ןןɐ unɹ puɐ ʇxǝʇ ǝʇɐpd∩",
+  "gtceu.gui.central_monitor.url": ":Ꞁᴚ∩ ǝbɐɯı ʇnduI",
   "gtceu.gui.charger_slot.tooltip.0": "ɹ§ʇoןS ɹǝbɹɐɥƆɟ§",
   "gtceu.gui.charger_slot.tooltip.1": "ɹ§sǝıɹǝʇʇɐq %s ɯoɹɟ ɹǝʍod sʍɐɹᗡㄥ§",
   "gtceu.gui.charger_slot.tooltip.2": "sǝıɹǝʇʇɐq puɐ sןooʇ %s sǝbɹɐɥƆㄥ§",
@@ -2392,8 +2444,7 @@
   "gtceu.gui.computer_monitor_cover.placeholder_reference.1": ")oɟuı ǝɹoɯ ɹoɟ ɹǝʌoɥ(",
   "gtceu.gui.computer_monitor_cover.second_page_textbox_tooltip.0": "˙ǝɹǝɥ ,}{, %s ɟo ǝɔɐןd uı pǝsn ǝq oʇ ɹǝpןoɥǝɔɐןd ʇnduI",
   "gtceu.gui.computer_monitor_cover.second_page_textbox_tooltip.1": "˙sǝxoq ʇxǝʇ ǝsǝɥʇ uı ,ʎʇıɔɐdɐƆʎbɹǝuǝ, puɐ ,ʎbɹǝuǝ, puɐ ,∩Ǝ }{/}{ :ʎbɹǝuƎ, buıɹʇs ɐ ǝʌɐɥ uɐɔ noʎ 'ǝןdɯɐxǝ ɹoℲ",
-  "gtceu.gui.computer_monitor_cover.slot_tooltip.0": "ǝɔuǝɹǝɟǝɹ uɐɔ sɹǝpןoɥǝɔɐןd ǝɯos ʇɐɥʇ sɯǝʇı ɹoɟ ʇoןs Ɐ",
-  "gtceu.gui.computer_monitor_cover.slot_tooltip.1": "%d :ɹǝqɯnu ʇoןS",
+  "gtceu.gui.computer_monitor_cover.slot_tooltip": "\n%d :ɹǝqɯnu ʇoןS\nǝɔuǝɹǝɟǝɹ uɐɔ sɹǝpןoɥǝɔɐןd ǝɯos ʇɐɥʇ sɯǝʇı ɹoɟ ʇoןs Ɐ",
   "gtceu.gui.computer_monitor_cover.update_interval": ")sʞɔıʇ uı( ןɐʌɹǝʇuı ǝʇɐpd∩",
   "gtceu.gui.config_slot": "ɹ§ʇoןS bıɟuoƆɟ§",
   "gtceu.gui.config_slot.auto_pull_managed": "ןןnԀ-oʇnⱯ ʎq pǝbɐuɐW ㄥ§:pǝןqɐsıᗡㄣ§",
@@ -2435,8 +2486,6 @@
   "gtceu.gui.fluid_amount": ":ʇunoɯⱯ pınןℲ",
   "gtceu.gui.fluid_auto_input.tooltip.disabled": "pǝןqɐsıᗡ ʇnduI-oʇnⱯ pınןℲ",
   "gtceu.gui.fluid_auto_input.tooltip.enabled": "pǝןqɐuƎ ʇnduI-oʇnⱯ pınןℲ",
-  "gtceu.gui.fluid_auto_output.allow_input.disabled": "ǝpıs ʇndʇno ǝɥʇ ɯoɹɟ ʇnduı spınןɟ ǝןqɐsıp",
-  "gtceu.gui.fluid_auto_output.allow_input.enabled": "ǝpıs ʇndʇno ǝɥʇ ɯoɹɟ ʇnduı spınןɟ ʍoןןɐ",
   "gtceu.gui.fluid_auto_output.disabled": "pǝןqɐsıᗡɔ§ :ʇndʇnO oʇnⱯ pınןℲ",
   "gtceu.gui.fluid_auto_output.enabled": "pǝןqɐuƎɐ§ :ʇndʇnO oʇnⱯ pınןℲ",
   "gtceu.gui.fluid_auto_output.other_direction.0": "uoıʇɔǝɹıᗡ ɹǝɥʇO9§ :ʇndʇnO oʇnⱯ pınןℲ",
@@ -2446,6 +2495,8 @@
   "gtceu.gui.fluid_auto_output.tooltip.enabled": "pǝןqɐuƎ ʇndʇnO-oʇnⱯ pınןℲ",
   "gtceu.gui.fluid_auto_output.unselected.0": "ʇndʇnO oʇnⱯ pınןℲ",
   "gtceu.gui.fluid_auto_output.unselected.1": "˙ʇndʇno sʇı ǝɹnbıɟuoɔ oʇ ǝuıɥɔɐɯ ǝɥʇ ɟo ǝpıs ɐ ʇɔǝןǝSㄥ§",
+  "gtceu.gui.fluid_input_from_output.disabled": "pǝןqɐsıᗡɔ§ :ǝpıS ʇndʇnO ɯoɹɟ ʇnduI pınןℲ ʍoןןⱯ",
+  "gtceu.gui.fluid_input_from_output.enabled": "pǝןqɐuƎɐ§ :ǝpıS ʇndʇnO ɯoɹɟ ʇnduI pınןℲ ʍoןןⱯ",
   "gtceu.gui.fluid_lock.tooltip.disabled": "pǝןqɐsıᗡ buıʞɔoꞀ pınןℲ",
   "gtceu.gui.fluid_lock.tooltip.enabled": "pǝןqɐuƎ buıʞɔoꞀ pınןℲ",
   "gtceu.gui.fluid_voiding": "spınןℲ6§ buıpıoΛㄥ§",
@@ -2454,8 +2505,6 @@
   "gtceu.gui.fuel_amount": ":ʇunoɯⱯ ןǝnℲ",
   "gtceu.gui.item_auto_input.tooltip.disabled": "pǝןqɐsıᗡ ʇnduI-oʇnⱯ ɯǝʇI",
   "gtceu.gui.item_auto_input.tooltip.enabled": "pǝןqɐuƎ ʇnduI-oʇnⱯ ɯǝʇI",
-  "gtceu.gui.item_auto_output.allow_input.disabled": "ǝpıs ʇndʇno ǝɥʇ ɯoɹɟ ʇnduı sɯǝʇı ǝןqɐsıp",
-  "gtceu.gui.item_auto_output.allow_input.enabled": "ǝpıs ʇndʇno ǝɥʇ ɯoɹɟ ʇnduı sɯǝʇı ʍoןןɐ",
   "gtceu.gui.item_auto_output.disabled": "pǝןqɐsıᗡɔ§ :ʇndʇnO oʇnⱯ ɯǝʇI",
   "gtceu.gui.item_auto_output.enabled": "pǝןqɐuƎɐ§ :ʇndʇnO oʇnⱯ ɯǝʇI",
   "gtceu.gui.item_auto_output.other_direction.0": "uoıʇɔǝɹıᗡ ɹǝɥʇO9§ :ʇndʇnO oʇnⱯ ɯǝʇI",
@@ -2465,6 +2514,9 @@
   "gtceu.gui.item_auto_output.tooltip.enabled": "pǝןqɐuƎ ʇndʇnO-oʇnⱯ ɯǝʇI",
   "gtceu.gui.item_auto_output.unselected.0": "ʇndʇnO oʇnⱯ ɯǝʇI",
   "gtceu.gui.item_auto_output.unselected.1": "˙ʇndʇno sʇı ǝɹnbıɟuoɔ oʇ ǝuıɥɔɐɯ ǝɥʇ ɟo ǝpıs ɐ ʇɔǝןǝSㄥ§",
+  "gtceu.gui.item_collector.range": " :ǝbuɐᴚ",
+  "gtceu.gui.item_input_from_output.disabled": "pǝןqɐsıᗡɔ§ :ǝpıS ʇndʇnO ɯoɹɟ ʇnduI ɯǝʇI ʍoןןⱯ",
+  "gtceu.gui.item_input_from_output.enabled": "pǝןqɐuƎɐ§ :ǝpıS ʇndʇnO ɯoɹɟ ʇnduI ɯǝʇI ʍoןןⱯ",
   "gtceu.gui.item_lock.tooltip.disabled": "pǝןqɐsıᗡ buıʞɔoꞀ ɯǝʇI",
   "gtceu.gui.item_lock.tooltip.enabled": "pǝןqɐuƎ buıʞɔoꞀ ɯǝʇI",
   "gtceu.gui.item_voiding": "sɯǝʇI9§ buıpıoΛㄥ§",
@@ -2474,8 +2526,13 @@
   "gtceu.gui.machinemode.tab_tooltip": "ǝpoW ǝuıɥɔɐW ǝʌıʇɔɐ ǝbuɐɥƆ",
   "gtceu.gui.machinemode.title": "ǝpoW ǝuıɥɔɐW ǝʌıʇɔⱯ",
   "gtceu.gui.me_bus.auto_pull_button": "ƎW ɯoɹɟ buıןןnd ɯǝʇı ɔıʇɐɯoʇnɐ ǝןbboʇ oʇ ʞɔıןƆ",
+  "gtceu.gui.me_network.auto_pull_toggle": "ןןnԀ-oʇnⱯ ǝןbbo⟘",
+  "gtceu.gui.me_network.empty": "ʎʇdɯƎ",
+  "gtceu.gui.me_network.min_stack_size": ":ǝzıS ʞɔɐʇS uıW",
   "gtceu.gui.me_network.offline": "ɹ§ǝuıןɟɟOㄣ§ :snʇɐʇS ʞɹoʍʇǝN",
   "gtceu.gui.me_network.online": "ɹ§ǝuıןuOᄅ§ :snʇɐʇS ʞɹoʍʇǝN",
+  "gtceu.gui.me_network.stocking_settings": "sbuıʇʇǝS buıʞɔoʇS",
+  "gtceu.gui.me_network.ticks_per_cycle": ":ǝןɔʎƆ ɹǝԀ sʞɔı⟘",
   "gtceu.gui.multiblock.voiding_mode": ":ǝpoW buıpıoΛ",
   "gtceu.gui.no_voiding": "buıɥʇoN buıpıoΛㄥ§",
   "gtceu.gui.output_setting.title": "sbuıʇʇǝS ʇndʇnO",
@@ -2490,6 +2547,7 @@
   "gtceu.gui.overclock.off": "X",
   "gtceu.gui.overclock.range": "]%s '%s[ sɹǝı⟘ ǝןqɐןıɐʌⱯ",
   "gtceu.gui.overclock.title": "ɹǝı⟘ ʞɔoןɔɹǝʌO",
+  "gtceu.gui.pattern_buffer.set_custom_name": " :ǝɯɐN ɯoʇsnƆ ʇǝS",
   "gtceu.gui.silktouch.disabled.0": "˙ǝןqɐuƎ oʇ ʞɔıןƆ :pǝןqɐsıᗡ ɥɔno⟘ ʞןıS",
   "gtceu.gui.silktouch.disabled.1": "˙ǝuıɥɔɐɯ ǝןpı uɐ sǝɹınbǝɹ buıɥɔʇıʍSㄥ§",
   "gtceu.gui.silktouch.enabled.0": "˙ǝןqɐsıᗡ oʇ ʞɔıןƆ :pǝןqɐuƎ ɥɔno⟘ ʞןıS",
@@ -2503,11 +2561,13 @@
   "gtceu.gui.toggle_view.disabled": ")spınןℲ( ʍǝıΛ ǝןbbo⟘",
   "gtceu.gui.toggle_view.enabled": ")sɯǝʇI( ʍǝıΛ ǝןbbo⟘",
   "gtceu.gui.waiting_list": ":ǝnǝnὉ buıpuǝS",
+  "gtceu.gui.waiting_list_empty": "ʎʇdɯƎᄅ§ :ǝnǝnὉ buıpuǝS",
   "gtceu.implosion_compressor": "ɹossǝɹdɯoƆ uoısoןdɯI",
   "gtceu.io.both": "ɥʇoᗺ",
   "gtceu.io.export": "ʇɹodxƎ",
   "gtceu.io.import": "ʇɹodɯI",
   "gtceu.io.none": "ǝuoN",
+  "gtceu.item.tooltip.image_url": "%s :Ꞁᴚ∩ ǝbɐɯI",
   "gtceu.item_filter.empty_item": ")ɯǝʇI oN( ʎʇdɯƎ",
   "gtceu.item_filter.footer": "ǝpıɹɹǝʌo oʇ ɯǝʇı ɥʇıʍ ʞɔıןƆǝ§",
   "gtceu.item_list.item_stored": "%d :pǝɹoʇSㄥ§",
@@ -2757,6 +2817,7 @@
   "gtceu.machine.ev_sifter.tooltip": "buıʇɟıs dǝǝʞ puɐ ɯןɐɔ ʎɐʇSㄥ§",
   "gtceu.machine.ev_thermal_centrifuge.tooltip": "ʎןǝsıɔǝɹd ǝɹoɯ sǝɹO buıʇɐɹɐdǝSㄥ§",
   "gtceu.machine.ev_wiremill.tooltip": "ʎןʇuǝıɔıɟɟǝ ǝɹoɯ sǝɹıM sǝɔnpoɹԀㄥ§",
+  "gtceu.machine.exploded": ")%d '%d '%d( ʇɐ pǝpoןdxǝ %s",
   "gtceu.machine.extreme_combustion_engine.tooltip": "ɹǝsɐǝןǝᴚ ʎbɹǝuƎ ןɐɔıɯǝɥƆ ǝɯǝɹʇxƎ",
   "gtceu.machine.fisher.requirement": "˙ʍoןǝq ʎןʇɔǝɹıp ɹǝʇɐʍ ɟo ǝɹɐnbs pǝɹǝʇuǝɔ %dx%d ɐ sǝɹınbǝᴚ",
   "gtceu.machine.fisher.speed": "sʞɔıʇ %d ʎɹǝʌǝ buıɥʇǝɯos sǝɥɔʇɐƆ",
@@ -3034,19 +3095,16 @@
   "gtceu.machine.me_import_item_hatch.configs.tooltip": "ʞɔoʇs uı sǝdʎʇ ɯǝʇı 9Ɩ sdǝǝʞ",
   "gtceu.machine.miner.chunkradius": "%d :snıpɐᴚ ʞunɥƆ",
   "gtceu.machine.miner.fluid_usage": "˙ʞɔoןɔɹǝʌo ɹǝd pǝןqnop 'ㄥ§%sɟ§ ɟoㄥ§ ʇ/ᗺɯ %dɟ§ sǝs∩",
-  "gtceu.machine.miner.minex": "%d :Xɯ",
-  "gtceu.machine.miner.miney": "%d :ʎɯ",
-  "gtceu.machine.miner.minez": "%d :Zɯ",
   "gtceu.machine.miner.multi.description": "˙ǝɹo ɟo ʎʇıʇuɐnb ǝbnɥ sǝɔnpoɹd puɐ ɐǝɹɐ ǝbɹɐן ɐ sɹǝʌoɔ ʇɐɥʇ ǝuıɥɔɐɯ buıuıɯ ʞɔoןqıʇןnɯ Ɐ",
   "gtceu.machine.miner.multi.modes": "˙sǝpoW pǝubıןⱯ ʞunɥƆ puɐ ɥɔno⟘ ʞןıS sɐH",
   "gtceu.machine.miner.multi.production": "˙ㄥ§ɹoʇɐɹǝɔɐWɟ§ ɐ uɐɥʇ ǝɹo pǝɥsnɹɔ ǝɹoɯ ㄥ§xƐɟ§ sǝɔnpoɹԀ",
   "gtceu.machine.miner.per_block": "ʞɔoןᗺ ɹǝdㄥ§ %dsɟ§ sǝʞɐʇㄥ§",
   "gtceu.machine.miner.progress": "%d/%d :ssǝɹboɹԀ",
   "gtceu.machine.miner.radius": "%d :snıpɐᴚ",
-  "gtceu.machine.miner.startx": "%d :Xs",
-  "gtceu.machine.miner.starty": "%d :ʎs",
-  "gtceu.machine.miner.startz": "%d :Zs",
   "gtceu.machine.miner.tooltip": "ɐǝɹɐㄥ§ %sx%sɟ§ sɐ sʇɹɐʇS ¡ɹǝuıW ǝɥʇ ʍoןǝq sǝɹo sǝuıWㄥ§",
+  "gtceu.machine.miner.x": "%d :Xɯ '%d :Xs",
+  "gtceu.machine.miner.y": "%d :ʎɯ '%d :ʎs",
+  "gtceu.machine.miner.z": "%d :Zɯ '%d :Zs",
   "gtceu.machine.muffle.off": "pǝןqɐsıᗡ :buıןɟɟnW punoS",
   "gtceu.machine.muffle.on": "pǝןqɐuƎ :buıןɟɟnW punoS",
   "gtceu.machine.muffler_hatch.tooltip.0": "sǝuıɥɔɐɯ ɯoɹɟ ǝʇsɐʍ sɹǝʌoɔǝᴚ",
@@ -3101,6 +3159,7 @@
   "gtceu.machine.opv_gas_collector.tooltip": "uoısuǝɯıp ǝɥʇ uo buıpuǝdǝp ǝsɹǝʌıun ǝɥʇ ɯoɹɟ sɐ⅁ sʇɔǝןןoƆㄥ§",
   "gtceu.machine.opv_rock_crusher.tooltip": "ɹǝqɯɐɥƆ uoıʇɐɯɹoℲ ɔıuɐɔןoΛㄥ§",
   "gtceu.machine.parallel_hatch.display": "ʞɔoןqıʇןnɯ ǝɥʇ ɟo ןǝןןɐɹɐd ɯnɯıxɐɯ ǝɥʇ ʇsnظpⱯ",
+  "gtceu.machine.parallel_hatch.parallel_ui": "sןǝןןɐɹɐԀ",
   "gtceu.machine.parallel_hatch_mk5.tooltip": "˙ןǝןןɐɹɐd uı sǝdıɔǝɹ ㄣ oʇ dn unɹ oʇ sʍoןןⱯ",
   "gtceu.machine.parallel_hatch_mk6.tooltip": "˙ןǝןןɐɹɐd uı sǝdıɔǝɹ 9Ɩ oʇ dn unɹ oʇ sʍoןןⱯ",
   "gtceu.machine.parallel_hatch_mk7.tooltip": "˙ןǝןןɐɹɐd uı sǝdıɔǝɹ ㄣ9 oʇ dn unɹ oʇ sʍoןןⱯ",
@@ -3263,6 +3322,36 @@
   "gtceu.mode.both": "ɹ§)ɯǝʇI puⱯ pınןℲ( ɥʇoᗺp§",
   "gtceu.mode.fluid": "ɹ§pınןℲ6§",
   "gtceu.mode.item": "ɹ§ɯǝʇI9§",
+  "gtceu.module.advanced_jetpack": ")ǝןnpoɯ ʎɹǝʇʇɐq ʎuɐ sǝɹınbǝɹ( ʞɔɐdʇǝظ pǝɔuɐʌpɐ uɐ ǝʞıן ʞɹoʍ ǝʇɐןdʇsǝɥɔ ǝɥʇ sǝʞɐW",
+  "gtceu.module.attack_damage": "%s%% ʎq ǝbɐɯɐp ʞɔɐʇʇɐ sǝsɐǝɹɔuI",
+  "gtceu.module.attack_speed": "%s%% ʎq pǝǝds ʞɔɐʇʇɐ sǝsɐǝɹɔuI",
+  "gtceu.module.battery": ")s,ʎɹǝʇʇɐq ǝɥʇ oʇ ןɐnbǝ sı ʎʇıɔɐdɐɔ( ʎʇıɔɐdɐɔ sʇı sǝsɐǝɹɔuı ɹo ʎbɹǝuǝ ǝɹoʇs oʇ ɯǝʇı ǝɥʇ sʍoןןⱯ",
+  "gtceu.module.block_reach": "sʞɔoןq %s ʎq ɥɔɐǝɹ ʞɔoןq sǝsɐǝɹɔuI",
+  "gtceu.module.block_reach.short": "sʞɔoןq %s ʎq ˙˙˙",
+  "gtceu.module.creative_flight": ")buıʎןɟ ǝןıɥʍ ʇ/∩Ǝ %s sǝɯnsuoɔ( ʇɥbıןɟ ǝʌıʇɐǝɹɔ sʍoןןⱯ",
+  "gtceu.module.damage_block": ")ǝןnpoɯ ʎɹǝʇʇɐq ʎuɐ sǝɹınbǝɹ 'ԀH ɹǝd ∩Ǝ %s( ∩Ǝ ɥʇıʍ ǝbɐɯɐp ɟo ʇunoɯɐ ʎuɐ sʞɔoןᗺ",
+  "gtceu.module.damage_block.short": "ԀH ɹǝd ∩Ǝ %s",
+  "gtceu.module.fluid_storage": ")s,ʞuɐʇ ǝɥʇ oʇ ןɐnbǝ sı ʎʇıɔɐdɐɔ( ʎʇıɔɐdɐɔ sʇı sǝsɐǝɹɔuı ɹo spınbıן ǝɹoʇs oʇ ɯǝʇı ǝɥʇ sʍoןןⱯ",
+  "gtceu.module.gui.charge": ":ǝbɹɐɥƆ",
+  "gtceu.module.gui.enabled": ":pǝןqɐuƎ",
+  "gtceu.module.gui.jump_boost": ":ʇsooᗺ",
+  "gtceu.module.gui.power": ":ɹǝʍoԀ",
+  "gtceu.module.jetpack": ")ǝןnpoɯ ʎɹǝʇʇɐq ʎuɐ sǝɹınbǝɹ( ʞɔɐdʇǝظ ɐ ǝʞıן ʞɹoʍ ǝʇɐןdʇsǝɥɔ ǝɥʇ sǝʞɐW",
+  "gtceu.module.jump": "sʞɔoןq %s ʎq ʇɥbıǝɥ dɯnظ sǝsɐǝɹɔuI",
+  "gtceu.module.liquid_fuel_jetpack": ")ǝןnpoɯ ǝbɐɹoʇs pınןɟ ʎuɐ sǝɹınbǝɹ( ʞɔɐdʇǝظ pǝןǝnɟ pınbıן ɐ ǝʞıן ʞɹoʍ ǝʇɐןdʇsǝɥɔ ǝɥʇ sǝʞɐW",
+  "gtceu.module.movement_speed": "%s%% ʎq pǝǝds ʇuǝɯǝʌoɯ ןןɐ sǝsɐǝɹɔuI",
+  "gtceu.module.nightvision": ")ǝʌıʇɔɐ ǝןıɥʍ ʇ/∩Ǝ %s sǝɯnsuoɔ( uoısıʌ ʇɥbıu sǝpıʌoɹԀ",
+  "gtceu.module.ppe": "sǝɔǝıd ɹoɯɹɐ ןןɐ oʇ pǝıןddɐ ɟı spɹɐzɐɥ ןɐʇuǝɯuoɹıʌuǝ ɯoɹɟ uoıʇɔǝʇoɹd sǝpıʌoɹԀ",
+  "gtceu.module.sensor": ")ɹǝʎɐןd ǝɥʇ ʎq pǝɔɐןd sǝuıɥɔɐɯ ɹoɟ( suoısoןdxǝ ǝuıɥɔɐɯ sʇɹodǝᴚ",
+  "gtceu.module.short_percentage": "%s%% ʎq ˙˙˙",
+  "gtceu.module.sneak_speed": "%s%% ʎq pǝǝds buıʞɐǝus sǝsɐǝɹɔuI",
+  "gtceu.module.speed": "%s%% ʎq pǝǝds ʇuıɹds sǝsɐǝɹɔuI",
+  "gtceu.module.step_height": "sʞɔoןq %s ʎq ʇɥbıǝɥ dǝʇs sǝsɐǝɹɔuI",
+  "gtceu.module.swim_speed": "%s%% ʎq pǝǝds ɯıʍs sǝsɐǝɹɔuI",
+  "gtceu.module.wireless_charging": "ʇı uo buıʞɔıןɔ-ʇɥbıɹ ʎq ɹǝbɹɐɥɔ ɐ oʇ puıq ')xɐɯ %s ⱯƖ( sʞɔoןq %s ɟo ǝbuɐɹ ǝɥʇ uı buıbɹɐɥɔ ssǝןǝɹıʍ sʍoןןⱯ",
+  "gtceu.module.wireless_charging.interdimensional": "ʇuǝsǝɹd sı ɹoʇɐɹǝuǝb pןǝıɟ %s ʇsɐǝן ʇɐ uɐ ɟı ןɐuoısuǝɯıpɹǝʇuı 'xɐɯ %s ⱯƖ 'sʞɔoןq %s",
+  "gtceu.module.wireless_charging.short": "xɐɯ %s ⱯƖ 'sʞɔoןq %s",
+  "gtceu.modules": ":sǝןnpoW",
   "gtceu.muffler.recovery_tooltip": "%d%%ɟ§ :ǝɔuɐɥƆ ʎɹǝʌoɔǝᴚq§",
   "gtceu.multiblock.active_transformer.average_in": "ʇ/∩Ǝ %sɟ§ :ʇnduI ˙bʌⱯq§",
   "gtceu.multiblock.active_transformer.average_out": "ʇ/∩Ǝ %sɟ§ :ʇndʇnO ˙bʌⱯq§",
@@ -3324,10 +3413,9 @@
   "gtceu.multiblock.hpca.info_bridging_disabled": "pǝןqɐsıᗡ buıbpıɹᗺ",
   "gtceu.multiblock.hpca.info_bridging_enabled": "pǝןqɐuƎ buıbpıɹᗺ",
   "gtceu.multiblock.hpca.info_coolant_name": "ʇuɐןooƆ ᗺƆԀ",
+  "gtceu.multiblock.hpca.info_cooling_demand": "%d / %s :puɐɯǝᗡ buıןooƆ",
   "gtceu.multiblock.hpca.info_max_computation": "%s :ʇ/∩MƆ xɐW",
   "gtceu.multiblock.hpca.info_max_coolant_required": "%s :pǝpǝǝN ʇuɐןooƆ",
-  "gtceu.multiblock.hpca.info_max_cooling_available": "%s :ǝןqɐןıɐʌⱯ buıןooƆ",
-  "gtceu.multiblock.hpca.info_max_cooling_demand": "%s :puɐɯǝᗡ buıןooƆ",
   "gtceu.multiblock.hpca.temperature": "%s :ǝɹnʇɐɹǝdɯǝ⟘",
   "gtceu.multiblock.hpca.warning_low_cooling": "buıןooɔ ɥbnouǝ ʇoN -",
   "gtceu.multiblock.hpca.warning_multiple_bridges": ")ʇıɟǝuǝq ןɐuoıʇıppɐ ou sǝpıʌoɹd( ǝɹnʇɔnɹʇs uı sǝbpıɹq ǝןdıʇןnW -",
@@ -3480,9 +3568,9 @@
   "gtceu.multiblock.turbine.rotor_durability": "%s%% :ʎʇıןıqɐɹnᗡ ɹoʇoᴚ",
   "gtceu.multiblock.turbine.rotor_speed": "WԀᴚ %s/%s :pǝǝdS ɹoʇoᴚ",
   "gtceu.multiblock.universal.distinct": ":sǝsnᗺ ʇɔuıʇsıᗡ",
+  "gtceu.multiblock.universal.distinct.disabled": "pǝןqɐsıᗡǝ§ :sǝsnᗺ ʇɔuıʇsıᗡ",
+  "gtceu.multiblock.universal.distinct.enabled": "pǝןqɐuƎǝ§ :sǝsnᗺ ʇɔuıʇsıᗡ",
   "gtceu.multiblock.universal.distinct.info": "˙ɔʇǝ 'sǝdɐɥS ɹǝpnɹʇxƎ 'sʇınɔɹıƆ pǝɯɯɐɹboɹԀ ǝʞıן sbuıɥʇ ɹoɟ ןnɟǝs∩ ˙dnʞooן ǝdıɔǝɹ ɹoɟ ɹǝɥʇo ɥɔɐǝ ɯoɹɟ ʇɔuıʇsıp ʎןןnɟ sɐ pǝʇɐǝɹʇ ǝq ןןıʍ snᗺ ʇnduI ɯǝʇI ɥɔɐǝ 'pǝןqɐuǝ ɟI",
-  "gtceu.multiblock.universal.distinct.no": "oN",
-  "gtceu.multiblock.universal.distinct.yes": "sǝʎ",
   "gtceu.multiblock.universal.has_problems": "¡sɯǝןqoɹԀ ǝɔuɐuǝʇuıɐW sɐH",
   "gtceu.multiblock.universal.has_problems_header": ":ɥɔʇɐH ǝɔuɐuǝʇuıɐW ɐ uı sǝnssı buıʍoןןoɟ ǝɥʇ xıℲ",
   "gtceu.multiblock.universal.muffler_obstructed": "¡pǝʇɔnɹʇsqO sı ɥɔʇɐH ɹǝןɟɟnW",
@@ -3513,6 +3601,14 @@
   "gtceu.packer": "ɹǝʞɔɐԀ",
   "gtceu.part_sharing.disabled": "pǝןqɐsıᗡㄣ§ buıɹɐɥS ʞɔoןqıʇןnW",
   "gtceu.part_sharing.enabled": "pǝןqɐuƎɐ§ buıɹɐɥS ʞɔoןqıʇןnW",
+  "gtceu.placeholder_editor.constant_value": "˙ʇuɐʇsuoɔ ɐ ɥʇıʍ ʇı buıɔɐןdǝɹ ɹǝpısuoƆ\n˙ʇןnsǝɹ ǝɯɐs ǝɥʇ oʇ sǝʇɐnןɐʌǝ sʎɐʍןɐ uoıssǝɹdxǝ sıɥ⟘",
+  "gtceu.placeholder_editor.extra_closing_bracket": "ʇǝʞɔɐɹq buısoןɔ ɐɹʇxƎ",
+  "gtceu.placeholder_editor.no_placeholder": "ʇsıxǝ ʇou sǝop ,%s, ǝɯɐu ɥʇıʍ ɹǝpןoɥǝɔɐןԀ",
+  "gtceu.placeholder_editor.unclosed_bracket": ")\"}\"( ʇǝʞɔɐɹq pǝsoןɔu∩",
+  "gtceu.placeholder_editor.unclosed_brackets": "pǝsoןɔun ǝɹɐ )\"}\"( sʇǝʞɔɐɹq %d",
+  "gtceu.placeholder_editor.unclosed_escape": ")\"],\"( ǝdɐɔsǝ pǝsoןɔu∩",
+  "gtceu.placeholder_editor.unclosed_escapes": "pǝsoןɔun ǝɹɐ )\"],\"( sǝdɐɔsǝ %d",
+  "gtceu.placeholder_editor.write_in_if": "˙\"}}\">ǝpoɔ‾ǝsןǝ<\" \">ǝpoɔ<\" >uoıʇıpuoɔ< ɟı{ ןɐʌǝ{\" ǝsn 'sıɥʇ pıoʌɐ o⟘\n˙ʇndʇno ǝuoʇspǝɹ ǝɔnpoɹd ןןıʍ \"}}ϛƖ ʇǝs ǝuoʇspǝɹ{ 0 ɟı{\" 'ǝןdɯɐxǝ ɹoɟ 'ʇɐɥʇ suɐǝɯ sıɥ⟘\n˙uoıʇıpuoɔ ǝɥʇ ɟo ssǝןpɹɐbǝɹ pǝʇnɔǝxǝ ǝɹɐ }ɟı{ ǝpısuı sɹǝpןoɥǝɔɐןԀ",
   "gtceu.placeholder_info.active.0": "˙ǝsıʍɹǝɥʇo 0 'ǝdıɔǝɹ ɐ buıuunɹ ʎןʇuǝɹɹnɔ sı oʇ pǝɥɔɐʇʇɐ sı ɹǝʌoɔ ǝɥʇ ʞɔoןq ǝɥʇ ɟı Ɩ ɐ suɹnʇǝᴚ",
   "gtceu.placeholder_info.active.1": ":ǝbɐs∩",
   "gtceu.placeholder_info.active.2": "ǝdıɔǝɹ buıuunɹ ʎןʇuǝɹɹnɔ ɐ s,ǝɹǝɥʇ ɹǝɥʇǝɥʍ >- }ǝʌıʇɔɐ{  ",
@@ -4126,6 +4222,7 @@
   "item.gtceu.cpu_chip.tooltip": "ʇıu∩ buıssǝɔoɹԀ ןɐɹʇuǝƆㄥ§",
   "item.gtceu.cpu_wafer": "ɹǝɟɐM ∩ԀƆ",
   "item.gtceu.cpu_wafer.tooltip": "ʇıu∩ buıssǝɔoɹԀ ʍɐᴚㄥ§",
+  "item.gtceu.creative_flight_module": "ǝןnpoW uoıʇɐʇıʌɐɹ⅁",
   "item.gtceu.crushed_bentonite_ore": "ǝʇıuoʇuǝᗺ punoɹ⅁",
   "item.gtceu.crushed_cassiterite_sand_ore": "puɐS ǝʇıɹǝʇıssɐƆ punoɹ⅁",
   "item.gtceu.crushed_pitchblende_ore": "ǝpuǝןqɥɔʇıԀ punoɹ⅁",
@@ -4271,6 +4368,7 @@
   "item.gtceu.gray_glass_lens": ")ʎɐɹ⅁( suǝꞀ ssɐן⅁",
   "item.gtceu.green_dye_spray_can": ")uǝǝɹ⅁( uɐƆ ʎɐɹdS",
   "item.gtceu.green_glass_lens": ")uǝǝɹ⅁( suǝꞀ ssɐן⅁",
+  "item.gtceu.gui_module": "ǝןnpoW ın⅁",
   "item.gtceu.hammer_extruder_mold.tooltip": "sɹǝɯɯɐH buıʞɐɯ ɹoɟ ǝdɐɥS ɹǝpnɹʇxƎㄥ§",
   "item.gtceu.hazmat_boots": "sʇooᗺ ʇınS sןɐıɹǝʇɐW snopɹɐzɐH",
   "item.gtceu.hazmat_chestpiece": "ǝɔǝıdʇsǝɥƆ ʇınS sןɐıɹǝʇɐW snopɹɐzɐH",
@@ -5764,6 +5862,33 @@
   "metaarmor.tooltip.falldamage": "ǝbɐɯɐᗡ ןןɐℲ sǝıɟıןןnN",
   "metaarmor.tooltip.freezing": "buızǝǝɹℲ sʇuǝʌǝɹԀ",
   "metaarmor.tooltip.jump": "ǝɔuɐʇsıᗡ puɐ ʇɥbıǝH dɯnſ sǝsɐǝɹɔuI",
+  "metaarmor.tooltip.modifier": "%s :%s - ",
+  "metaarmor.tooltip.modifier.attack_damage": ")%s( ǝןnpoW ǝbɐɯɐᗡ ʞɔɐʇʇⱯ",
+  "metaarmor.tooltip.modifier.attack_speed": ")%s( ǝןnpoW pǝǝdS ʞɔɐʇʇⱯ",
+  "metaarmor.tooltip.modifier.battery": ")%s( ǝןnpoW ʎɹǝʇʇɐᗺ",
+  "metaarmor.tooltip.modifier.battery.hud.boots": "%s :ʎɹǝʇʇɐq sʇooᗺ",
+  "metaarmor.tooltip.modifier.battery.hud.chestplate": "%s :ʎɹǝʇʇɐq ǝʇɐןdʇsǝɥƆ",
+  "metaarmor.tooltip.modifier.battery.hud.helmet": "%s :ʎɹǝʇʇɐq ʇǝɯןǝH",
+  "metaarmor.tooltip.modifier.battery.hud.info": "∩Ǝ %s/%s buıɹoʇS",
+  "metaarmor.tooltip.modifier.battery.hud.leggings": "%s :ʎɹǝʇʇɐq sbuıbbǝꞀ",
+  "metaarmor.tooltip.modifier.block_reach": ")%s( ǝןnpoW ɥɔɐǝᴚ",
+  "metaarmor.tooltip.modifier.creative_flight": "ǝןnpoW ʇɥbıןℲ ǝʌıʇɐǝɹƆ",
+  "metaarmor.tooltip.modifier.damage_block": ")%s( ǝןnpoW pןǝıɥS ʎbɹǝuƎ",
+  "metaarmor.tooltip.modifier.empty": "ʎʇdɯƎ",
+  "metaarmor.tooltip.modifier.fluid_storage": ")%s( ǝbɐɹoʇs pınןɟ ןɐuoıʇıppⱯ",
+  "metaarmor.tooltip.modifier.fluid_storage.tooltip": "%s ɟo ᗺɯ %s/%s buıɹoʇS",
+  "metaarmor.tooltip.modifier.jetpack": ")%s( ǝןnpoW ʞɔɐdʇǝſ",
+  "metaarmor.tooltip.modifier.jump": ")%s( ǝןnpoW dɯnſ",
+  "metaarmor.tooltip.modifier.movement_speed": ")%s( ǝןnpoW pǝǝdS ʇuǝɯǝʌoW",
+  "metaarmor.tooltip.modifier.sensor": ")%s( ǝןnpoW buıʇɹodǝᴚ uoısoןdxƎ",
+  "metaarmor.tooltip.modifier.sneak_speed": ")%s( ǝןnpoW pǝǝdS ʞɐǝuS",
+  "metaarmor.tooltip.modifier.speed": ")%s( ǝןnpoW pǝǝdS buıuunᴚ",
+  "metaarmor.tooltip.modifier.step_height": ")%s( ǝןnpoW ʇɥbıǝH dǝʇS",
+  "metaarmor.tooltip.modifier.swim_speed": ")%s( ǝןnpoW pǝǝdS ɯıʍS",
+  "metaarmor.tooltip.modifier.wireless_charging": ")%s( ǝןnpoW buıbɹɐɥƆ ssǝןǝɹıM",
+  "metaarmor.tooltip.modifier_slot.tiered": ")%s( pǝɹǝı⟘",
+  "metaarmor.tooltip.modifier_slot.universal": "ןɐsɹǝʌıu∩",
+  "metaarmor.tooltip.modifiers": ":sʇoןs ǝןnpoW",
   "metaarmor.tooltip.potions": "sʇɔǝɟɟƎ ןnɟɯɹɐH sǝıɟıןןnN",
   "metaarmor.tooltip.speed": "pǝǝdS buıuunᴚ sǝsɐǝɹɔuI",
   "metaarmor.tooltip.stepassist": "ʇsıssⱯ-dǝʇS sǝpıʌoɹԀ",
diff --git a/src/generated/resources/assets/gtceu/lang/en_us.json b/src/generated/resources/assets/gtceu/lang/en_us.json
index c9d6d18f758..18edb1dd561 100644
--- a/src/generated/resources/assets/gtceu/lang/en_us.json
+++ b/src/generated/resources/assets/gtceu/lang/en_us.json
@@ -58,6 +58,7 @@
   "behavior.prospector.not_enough_energy": "Not Enough Energy!",
   "behavior.toggle_energy_consumer.tooltip": "Use to toggle mode",
   "behaviour.boor.by": "by %s",
+  "behaviour.charger_linked": "Linked charger",
   "behaviour.hammer": "Turns on and off Muffling for Machines (by hitting them)",
   "behaviour.hoe": "Can till dirt",
   "behaviour.lighter.fluid.tooltip": "Can light things on fire with Butane or Propane",
@@ -211,6 +212,7 @@
   "block.gtceu.empty_tier_ii_battery": "Empty Tier II Capacitor",
   "block.gtceu.empty_tier_iii_battery": "Empty Tier III Capacitor",
   "block.gtceu.engine_intake_casing": "Engine Intake Casing",
+  "block.gtceu.equipment_foundry": "Equipment Foundry",
   "block.gtceu.ev_16a_energy_converter": "§5EV§r 16§eA§r Energy Converter",
   "block.gtceu.ev_1a_energy_converter": "§5EV§r 1§eA§r Energy Converter",
   "block.gtceu.ev_4a_energy_converter": "§5EV§r 4§eA§r Energy Converter",
@@ -1133,6 +1135,8 @@
   "block.gtceu.substation_capacitor.tooltip_filled": "§cEnergy Capacity: §f%d EU",
   "block.gtceu.superconducting_coil": "Superconducting Coil Block",
   "block.gtceu.tempered_glass": "Tempered Glass",
+  "block.gtceu.test_mui": "Test Mui",
+  "block.gtceu.test_mui_new": "Test Mui New",
   "block.gtceu.the_end_marker": "The End",
   "block.gtceu.the_nether_marker": "The Nether",
   "block.gtceu.titanium_crate": "Titanium Crate",
@@ -1777,7 +1781,9 @@
   "config.gtceu.option.coloredWireOutline": "coloredWireOutline",
   "config.gtceu.option.compat": "compat",
   "config.gtceu.option.createCompat": "createCompat",
+  "config.gtceu.option.cursorColor": "cursorColor",
   "config.gtceu.option.debug": "debug",
+  "config.gtceu.option.debugUI": "debugUI",
   "config.gtceu.option.debugWorldgen": "debugWorldgen",
   "config.gtceu.option.defaultPaintingColor": "defaultPaintingColor",
   "config.gtceu.option.defaultUIColor": "defaultUIColor",
@@ -1805,6 +1811,7 @@
   "config.gtceu.option.energyUsageMultiplier": "energyUsageMultiplier",
   "config.gtceu.option.environmentalHazardDecayRate": "environmentalHazardDecayRate",
   "config.gtceu.option.environmentalHazards": "environmentalHazards",
+  "config.gtceu.option.escRestoresLastText": "escRestoresLastText",
   "config.gtceu.option.euToFeRatio": "euToFeRatio",
   "config.gtceu.option.extractorRecyclingYield": "extractorRecyclingYield",
   "config.gtceu.option.feToEuRatio": "feToEuRatio",
@@ -1856,6 +1863,7 @@
   "config.gtceu.option.meHatchEnergyUsage": "meHatchEnergyUsage",
   "config.gtceu.option.minerSpeed": "minerSpeed",
   "config.gtceu.option.minimap": "minimap",
+  "config.gtceu.option.mui": "mui",
   "config.gtceu.option.nanoSaber": "nanoSaber",
   "config.gtceu.option.nanoSaberBaseDamage": "nanoSaberBaseDamage",
   "config.gtceu.option.nanoSaberDamageBoost": "nanoSaberDamageBoost",
@@ -1876,6 +1884,7 @@
   "config.gtceu.option.oreVeinGridSize": "oreVeinGridSize",
   "config.gtceu.option.oreVeinRandomOffset": "oreVeinRandomOffset",
   "config.gtceu.option.oreVeins": "oreVeins",
+  "config.gtceu.option.outlineColor": "outlineColor",
   "config.gtceu.option.ownerOPBypass": "ownerOPBypass",
   "config.gtceu.option.prospectorEnergyUseMultiplier": "prospectorEnergyUseMultiplier",
   "config.gtceu.option.quantumTank": "quantumTank",
@@ -1889,14 +1898,28 @@
   "config.gtceu.option.renderGrowingPlants": "renderGrowingPlants",
   "config.gtceu.option.renderer": "renderer",
   "config.gtceu.option.replaceMinedBlocksWith": "replaceMinedBlocksWith",
+  "config.gtceu.option.replaceVanillaTooltips": "replaceVanillaTooltips",
   "config.gtceu.option.replaceWithCobbleVersion": "replaceWithCobbleVersion",
   "config.gtceu.option.requireGTToolsForBlocks": "requireGTToolsForBlocks",
   "config.gtceu.option.rngDamageElectricTools": "rngDamageElectricTools",
   "config.gtceu.option.rubberTreeSpawnChance": "rubberTreeSpawnChance",
   "config.gtceu.option.sandOresFall": "sandOresFall",
+  "config.gtceu.option.scale": "scale",
   "config.gtceu.option.shouldWeatherOrTerrainExplosion": "shouldWeatherOrTerrainExplosion",
   "config.gtceu.option.showDimensionTier": "showDimensionTier",
+  "config.gtceu.option.showExtra": "showExtra",
+  "config.gtceu.option.showHovered": "showHovered",
+  "config.gtceu.option.showOutline": "showOutline",
+  "config.gtceu.option.showParent": "showParent",
+  "config.gtceu.option.showParentOutline": "showParentOutline",
+  "config.gtceu.option.showParentPos": "showParentPos",
+  "config.gtceu.option.showParentSize": "showParentSize",
+  "config.gtceu.option.showParentWidgetTheme": "showParentWidgetTheme",
+  "config.gtceu.option.showPos": "showPos",
+  "config.gtceu.option.showSize": "showSize",
+  "config.gtceu.option.showWidgetTheme": "showWidgetTheme",
   "config.gtceu.option.smallBoilers": "smallBoilers",
+  "config.gtceu.option.smoothProgressBar": "smoothProgressBar",
   "config.gtceu.option.solarBoilerBaseOutput": "solarBoilerBaseOutput",
   "config.gtceu.option.solidBoilerBaseOutput": "solidBoilerBaseOutput",
   "config.gtceu.option.sprayCanChainLength": "sprayCanChainLength",
@@ -1908,17 +1931,21 @@
   "config.gtceu.option.surfaceRockProspectRange": "surfaceRockProspectRange",
   "config.gtceu.option.tankItemFluidPreview": "tankItemFluidPreview",
   "config.gtceu.option.temperaturesInCelsius": "temperaturesInCelsius",
+  "config.gtceu.option.textColor": "textColor",
   "config.gtceu.option.titaniumBoilerHeatSpeed": "titaniumBoilerHeatSpeed",
   "config.gtceu.option.titaniumBoilerMaxTemperature": "titaniumBoilerMaxTemperature",
   "config.gtceu.option.toggle": "toggle",
   "config.gtceu.option.toolCraftingSounds": "toolCraftingSounds",
   "config.gtceu.option.toolUseSounds": "toolUseSounds",
   "config.gtceu.option.tools": "tools",
+  "config.gtceu.option.tooltipPos": "tooltipPos",
   "config.gtceu.option.treeFellingDelay": "treeFellingDelay",
   "config.gtceu.option.tungstensteelBoilerHeatSpeed": "tungstensteelBoilerHeatSpeed",
   "config.gtceu.option.tungstensteelBoilerMaxTemperature": "tungstensteelBoilerMaxTemperature",
+  "config.gtceu.option.ui": "ui",
   "config.gtceu.option.universalHazards": "universalHazards",
   "config.gtceu.option.updateIntervals": "updateIntervals",
+  "config.gtceu.option.useDarkThemeByDefault": "useDarkThemeByDefault",
   "config.gtceu.option.useVBO": "useVBO",
   "config.gtceu.option.voltageTierAdvImpeller": "voltageTierAdvImpeller",
   "config.gtceu.option.voltageTierAdvNanoSuit": "voltageTierAdvNanoSuit",
@@ -2029,20 +2056,18 @@
   "cover.conveyor.transfer_rate": "§7items/sec",
   "cover.detector_base.message_inverted_state": "Monitoring Status: Inverted",
   "cover.detector_base.message_normal_state": "Monitoring Status: Normal",
-  "cover.ender_fluid_link.incomplete_hex.0": "Inputted color is incomplete!",
-  "cover.ender_fluid_link.incomplete_hex.1": "It will be applied once complete (all 8 hex digits)",
-  "cover.ender_fluid_link.incomplete_hex.2": "Closing the gui will lose edits!",
   "cover.ender_fluid_link.iomode.disabled": "I/O Disabled",
   "cover.ender_fluid_link.iomode.enabled": "I/O Enabled",
-  "cover.ender_fluid_link.private.tooltip.disabled.0": "Switch to private tank mode",
-  "cover.ender_fluid_link.private.tooltip.disabled.1": "Private mode uses the player who originally placed the cover",
-  "cover.ender_fluid_link.private.tooltip.enabled": "Switch to public tank mode",
   "cover.ender_fluid_link.title": "Ender Fluid Link",
-  "cover.ender_fluid_link.tooltip.channel_description": "Set channel description with input text",
-  "cover.ender_fluid_link.tooltip.channel_name": "Set channel name with input text",
-  "cover.ender_fluid_link.tooltip.clear_button": "Clear channel description",
-  "cover.ender_fluid_link.tooltip.list_button": "Show channel list",
   "cover.ender_item_link.title": "Ender Item Link",
+  "cover.ender_link.description_empty": "Empty Description",
+  "cover.ender_link.private.tooltip": "Private mode: Only accessible to the player who placed this cover",
+  "cover.ender_link.protected.tooltip": "Protected Mode: Accessible to players on the same team.",
+  "cover.ender_link.public.tooltip": "Public mode: Accessible to all players",
+  "cover.ender_link.tooltip.channel_description": "Channel description",
+  "cover.ender_link.tooltip.channel_name": "Channel ID (32-bit hexadecimal value)",
+  "cover.ender_link.tooltip.clear_button": "Clear channel description",
+  "cover.ender_link.tooltip.list_button": "Show channel list",
   "cover.ender_redstone_link.title": "Ender Redstone Link",
   "cover.filter.blacklist.disabled": "Whitelist",
   "cover.filter.blacklist.enabled": "Blacklist",
@@ -2080,6 +2105,7 @@
   "cover.item_smart_filter.filtering_mode.electrolyzer": "Electrolyzer",
   "cover.item_smart_filter.filtering_mode.sifter": "Sifter",
   "cover.item_smart_filter.title": "Smart Item Filter",
+  "cover.machine_controller.control": "Controller Target",
   "cover.machine_controller.invert.disabled.0": "§eNormal§r - in this mode, the cover will require a signal weaker than the set redstone level to run",
   "cover.machine_controller.invert.enabled.0": "§eInverted§r - in this mode, the cover will require a signal stronger than the set redstone level to run",
   "cover.machine_controller.inverted": "Inverted",
@@ -2192,6 +2218,7 @@
   "death.attack.gtceu.wrench_iv": "%s had a wrench thrown into their plans by %s",
   "death.attack.gtceu.wrench_lv": "%s's pipes were loosened by %s",
   "effect.gtceu.weak_poison": "Weak Poison",
+  "emi.category.gtceu.equipment_foundry": "Equipment Foundry",
   "enchantment.damage.disjunction": "Disjunction",
   "enchantment.disjunction": "Disjunction",
   "enchantment.gtceu.disjunction.description": "Applies Weakness and Slowness to Ender-related mobs.",
@@ -2235,6 +2262,10 @@
   "gtceu.canner": "Canner",
   "gtceu.central_monitor.gui.create_group": "Create group",
   "gtceu.central_monitor.gui.currently_editing": "Currently editing: %s",
+  "gtceu.central_monitor.gui.data_slot": "Set slot number of data stick",
+  "gtceu.central_monitor.gui.group_editor": "Editing monitor group",
+  "gtceu.central_monitor.gui.group_name": "Name:",
+  "gtceu.central_monitor.gui.monitor_groups": "Monitor groups",
   "gtceu.central_monitor.gui.remove_from_group": "Remove from group",
   "gtceu.central_monitor.gui.set_target": "Set target",
   "gtceu.central_monitor.info_tooltip.0": "In order to use monitors, you have to split them into groups first. A group may only have 1 module in it.",
@@ -2291,7 +2322,8 @@
   "gtceu.creative.chest.ipc": "Items per Cycle",
   "gtceu.creative.chest.item": "Item",
   "gtceu.creative.chest.tpc": "Ticks per Cycle",
-  "gtceu.creative.computation.average": "Average Requested CWUt",
+  "gtceu.creative.computation.average": "Average CWU/tick: %d",
+  "gtceu.creative.computation.max_usage": "Max CWU/tick:",
   "gtceu.creative.energy.amperage": "Amperage",
   "gtceu.creative.energy.sink": "Sink",
   "gtceu.creative.energy.source": "Source",
@@ -2327,6 +2359,12 @@
   "gtceu.ender_redstone_link_cover.label": "Redstone power: %d",
   "gtceu.ender_redstone_link_cover.title": "Ender Redstone Link",
   "gtceu.ender_redstone_link_cover.tooltip": "§7Transmits §fRedstone signals§7 with a §fWireless §dEnder§f Connection§7 as §fCover§7.",
+  "gtceu.equipment_foundry.gui.applied_to": "Applied to:",
+  "gtceu.equipment_foundry.gui.module_item": "Module item:",
+  "gtceu.equipment_foundry.gui.supports_tiers": "Module tiers: %s-%s",
+  "gtceu.equipment_foundry.gui.tier": "Viewing stats for tier: %s",
+  "gtceu.equipment_foundry.gui.tier_too_high": "No module item exists for this tier",
+  "gtceu.equipment_foundry.gui.tooltip.tier_switch": "Left-click to increase tier by 1\nRight-click to decrease tier by 1",
   "gtceu.extractor": "Extractor",
   "gtceu.extruder": "Extruder",
   "gtceu.fermenter": "Fermenter",
@@ -2371,10 +2409,24 @@
   "gtceu.gui.adv_stocking_config.title": "Configure Automatic Stocking",
   "gtceu.gui.all_voiding": "§7Voiding §cAll",
   "gtceu.gui.auto_output.name": "auto",
+  "gtceu.gui.central_monitor.data_hatch_target": "If you select a data hatch as a target, you will be prompted to enter a slot number. Then the block that the data stick in the specified slot is linked to (via right-clicking a wireless transmitter cover) will be considered the target instead.",
   "gtceu.gui.central_monitor.group": "Group: %s",
   "gtceu.gui.central_monitor.group_default_name": "Group #%d",
-  "gtceu.gui.central_monitor.none": "none",
+  "gtceu.gui.central_monitor.gui_module_info": "To select a block to get the GUI from, select a target in the monitor group editor.",
+  "gtceu.gui.central_monitor.help": "A monitor group is a collection of any amount of monitors in the multiblock.\nFor a group to display anything, it needs 2 things:\n - you to select the monitors that you want to display something on\n - an inserted and configured monitor module\nA module must be inserted in the slot to the right of the group name textbox.\nWhen you insert it, a button will appear to configure the module (for example just enter the text to display)\nThen you have to select at least 1 monitor in the grid below the group name textbox, here are types of selections:",
+  "gtceu.gui.central_monitor.in_group": "Monitors selected this way are added to the group, and will be used to display stuff",
+  "gtceu.gui.central_monitor.in_group_and_target": "The monitor selected this way is used for displaying and as a target at the same time.",
+  "gtceu.gui.central_monitor.left_click": "Select/unselect a monitor by left-clicking it",
+  "gtceu.gui.central_monitor.module_editor_button": "Edit module",
+  "gtceu.gui.central_monitor.module_editor_disabled": "You recently changed the module, please re-open this GUI to edit it",
+  "gtceu.gui.central_monitor.pause": "Pause placeholder execution.\nText won't be updated, and code won't be run.",
+  "gtceu.gui.central_monitor.resume": "Unpause placeholder execution.",
+  "gtceu.gui.central_monitor.right_click": "Select a block by right-clicking it. Only 1 block can be a target.",
+  "gtceu.gui.central_monitor.target": "The block selected this way is considered a target, to be used with placeholders in a text module.",
+  "gtceu.gui.central_monitor.text_module_help": "This module displays text that can have placeholders.\nPlaceholders are strings like \"{energy}\" that when displayed, will display their value instead (in this case the amount of energy).\nThey can also do some other things, such as set a redstone output/read redstone input, run calculations, etc.\nSome placeholders, like {energy} must have a target to function. A target is basically any block that can accept covers or is part of the\ncentral monitor multiblock. For example {energy} displays the amount of energy in its target block, usually a battery buffer or a PSS.\nSelect a target in the monitor group editing window, check out the help page there for more info.\nHere's an example usage of placeholders, that displays some energy info and sends a redstone signal when energy is <50%:\n",
   "gtceu.gui.central_monitor.text_scale": "Text scale",
+  "gtceu.gui.central_monitor.update_once": "Update text and run all placeholders in it exactly once.",
+  "gtceu.gui.central_monitor.url": "Input image URL:",
   "gtceu.gui.charger_slot.tooltip.0": "§fCharger Slot§r",
   "gtceu.gui.charger_slot.tooltip.1": "§7Draws power from %s batteries§r",
   "gtceu.gui.charger_slot.tooltip.2": "§7Charges %s tools and batteries",
@@ -2392,8 +2444,7 @@
   "gtceu.gui.computer_monitor_cover.placeholder_reference.1": "(hover for more info)",
   "gtceu.gui.computer_monitor_cover.second_page_textbox_tooltip.0": "Input placeholder to be used in place of %s '{}' here.",
   "gtceu.gui.computer_monitor_cover.second_page_textbox_tooltip.1": "For example, you can have a string 'Energy: {}/{} EU' and 'energy' and 'energyCapacity' in these text boxes.",
-  "gtceu.gui.computer_monitor_cover.slot_tooltip.0": "A slot for items that some placeholders can reference",
-  "gtceu.gui.computer_monitor_cover.slot_tooltip.1": "Slot number: %d",
+  "gtceu.gui.computer_monitor_cover.slot_tooltip": "A slot for items that some placeholders can reference\nSlot number: %d\n",
   "gtceu.gui.computer_monitor_cover.update_interval": "Update interval (in ticks)",
   "gtceu.gui.config_slot": "§fConfig Slot§r",
   "gtceu.gui.config_slot.auto_pull_managed": "§4Disabled:§7 Managed by Auto-Pull",
@@ -2435,8 +2486,6 @@
   "gtceu.gui.fluid_amount": "Fluid Amount:",
   "gtceu.gui.fluid_auto_input.tooltip.disabled": "Fluid Auto-Input Disabled",
   "gtceu.gui.fluid_auto_input.tooltip.enabled": "Fluid Auto-Input Enabled",
-  "gtceu.gui.fluid_auto_output.allow_input.disabled": "disable fluids input from the output side",
-  "gtceu.gui.fluid_auto_output.allow_input.enabled": "allow fluids input from the output side",
   "gtceu.gui.fluid_auto_output.disabled": "Fluid Auto Output: §cDisabled",
   "gtceu.gui.fluid_auto_output.enabled": "Fluid Auto Output: §aEnabled",
   "gtceu.gui.fluid_auto_output.other_direction.0": "Fluid Auto Output: §6Other Direction",
@@ -2446,6 +2495,8 @@
   "gtceu.gui.fluid_auto_output.tooltip.enabled": "Fluid Auto-Output Enabled",
   "gtceu.gui.fluid_auto_output.unselected.0": "Fluid Auto Output",
   "gtceu.gui.fluid_auto_output.unselected.1": "§7Select a side of the machine to configure its output.",
+  "gtceu.gui.fluid_input_from_output.disabled": "Allow Fluid Input from Output Side: §cDisabled",
+  "gtceu.gui.fluid_input_from_output.enabled": "Allow Fluid Input from Output Side: §aEnabled",
   "gtceu.gui.fluid_lock.tooltip.disabled": "Fluid Locking Disabled",
   "gtceu.gui.fluid_lock.tooltip.enabled": "Fluid Locking Enabled",
   "gtceu.gui.fluid_voiding": "§7Voiding §9Fluids",
@@ -2454,8 +2505,6 @@
   "gtceu.gui.fuel_amount": "Fuel Amount:",
   "gtceu.gui.item_auto_input.tooltip.disabled": "Item Auto-Input Disabled",
   "gtceu.gui.item_auto_input.tooltip.enabled": "Item Auto-Input Enabled",
-  "gtceu.gui.item_auto_output.allow_input.disabled": "disable items input from the output side",
-  "gtceu.gui.item_auto_output.allow_input.enabled": "allow items input from the output side",
   "gtceu.gui.item_auto_output.disabled": "Item Auto Output: §cDisabled",
   "gtceu.gui.item_auto_output.enabled": "Item Auto Output: §aEnabled",
   "gtceu.gui.item_auto_output.other_direction.0": "Item Auto Output: §6Other Direction",
@@ -2465,6 +2514,9 @@
   "gtceu.gui.item_auto_output.tooltip.enabled": "Item Auto-Output Enabled",
   "gtceu.gui.item_auto_output.unselected.0": "Item Auto Output",
   "gtceu.gui.item_auto_output.unselected.1": "§7Select a side of the machine to configure its output.",
+  "gtceu.gui.item_collector.range": "Range: ",
+  "gtceu.gui.item_input_from_output.disabled": "Allow Item Input from Output Side: §cDisabled",
+  "gtceu.gui.item_input_from_output.enabled": "Allow Item Input from Output Side: §aEnabled",
   "gtceu.gui.item_lock.tooltip.disabled": "Item Locking Disabled",
   "gtceu.gui.item_lock.tooltip.enabled": "Item Locking Enabled",
   "gtceu.gui.item_voiding": "§7Voiding §6Items",
@@ -2474,8 +2526,13 @@
   "gtceu.gui.machinemode.tab_tooltip": "Change active Machine Mode",
   "gtceu.gui.machinemode.title": "Active Machine Mode",
   "gtceu.gui.me_bus.auto_pull_button": "Click to toggle automatic item pulling from ME",
+  "gtceu.gui.me_network.auto_pull_toggle": "Toggle Auto-Pull",
+  "gtceu.gui.me_network.empty": "Empty",
+  "gtceu.gui.me_network.min_stack_size": "Min Stack Size:",
   "gtceu.gui.me_network.offline": "Network Status: §4Offline§r",
   "gtceu.gui.me_network.online": "Network Status: §2Online§r",
+  "gtceu.gui.me_network.stocking_settings": "Stocking Settings",
+  "gtceu.gui.me_network.ticks_per_cycle": "Ticks Per Cycle:",
   "gtceu.gui.multiblock.voiding_mode": "Voiding Mode:",
   "gtceu.gui.no_voiding": "§7Voiding Nothing",
   "gtceu.gui.output_setting.title": "Output Settings",
@@ -2490,6 +2547,7 @@
   "gtceu.gui.overclock.off": "X",
   "gtceu.gui.overclock.range": "Available Tiers [%s, %s]",
   "gtceu.gui.overclock.title": "Overclock Tier",
+  "gtceu.gui.pattern_buffer.set_custom_name": "Set Custom Name: ",
   "gtceu.gui.silktouch.disabled.0": "Silk Touch Disabled: Click to Enable.",
   "gtceu.gui.silktouch.disabled.1": "§7Switching requires an idle machine.",
   "gtceu.gui.silktouch.enabled.0": "Silk Touch Enabled: Click to Disable.",
@@ -2503,11 +2561,13 @@
   "gtceu.gui.toggle_view.disabled": "Toggle View (Fluids)",
   "gtceu.gui.toggle_view.enabled": "Toggle View (Items)",
   "gtceu.gui.waiting_list": "Sending Queue:",
+  "gtceu.gui.waiting_list_empty": "Sending Queue: §2Empty",
   "gtceu.implosion_compressor": "Implosion Compressor",
   "gtceu.io.both": "Both",
   "gtceu.io.export": "Export",
   "gtceu.io.import": "Import",
   "gtceu.io.none": "None",
+  "gtceu.item.tooltip.image_url": "Image URL: %s",
   "gtceu.item_filter.empty_item": "Empty (No Item)",
   "gtceu.item_filter.footer": "§eClick with item to override",
   "gtceu.item_list.item_stored": "§7Stored: %d",
@@ -2757,6 +2817,7 @@
   "gtceu.machine.ev_sifter.tooltip": "§7Stay calm and keep sifting",
   "gtceu.machine.ev_thermal_centrifuge.tooltip": "§7Separating Ores more precisely",
   "gtceu.machine.ev_wiremill.tooltip": "§7Produces Wires more efficiently",
+  "gtceu.machine.exploded": "%s exploded at (%d, %d, %d)",
   "gtceu.machine.extreme_combustion_engine.tooltip": "Extreme Chemical Energy Releaser",
   "gtceu.machine.fisher.requirement": "Requires a %dx%d centered square of water directly below.",
   "gtceu.machine.fisher.speed": "Catches something every %d ticks",
@@ -3034,19 +3095,16 @@
   "gtceu.machine.me_import_item_hatch.configs.tooltip": "Keeps 16 item types in stock",
   "gtceu.machine.miner.chunkradius": "Chunk Radius: %d",
   "gtceu.machine.miner.fluid_usage": "Uses §f%d mB/t §7of §f%s§7, doubled per overclock.",
-  "gtceu.machine.miner.minex": "mX: %d",
-  "gtceu.machine.miner.miney": "mY: %d",
-  "gtceu.machine.miner.minez": "mZ: %d",
   "gtceu.machine.miner.multi.description": "A multiblock mining machine that covers a large area and produces huge quantity of ore.",
   "gtceu.machine.miner.multi.modes": "Has Silk Touch and Chunk Aligned Modes.",
   "gtceu.machine.miner.multi.production": "Produces §f3x§7 more crushed ore than a §fMacerator§7.",
   "gtceu.machine.miner.per_block": "§7takes §f%ds §7per Block",
   "gtceu.machine.miner.progress": "Progress: %d/%d",
   "gtceu.machine.miner.radius": "Radius: %d",
-  "gtceu.machine.miner.startx": "sX: %d",
-  "gtceu.machine.miner.starty": "sY: %d",
-  "gtceu.machine.miner.startz": "sZ: %d",
   "gtceu.machine.miner.tooltip": "§7Mines ores below the Miner! Starts as §f%sx%s §7area",
+  "gtceu.machine.miner.x": "sX: %d, mX: %d",
+  "gtceu.machine.miner.y": "sY: %d, mY: %d",
+  "gtceu.machine.miner.z": "sZ: %d, mZ: %d",
   "gtceu.machine.muffle.off": "Sound Muffling: Disabled",
   "gtceu.machine.muffle.on": "Sound Muffling: Enabled",
   "gtceu.machine.muffler_hatch.tooltip.0": "Recovers waste from machines",
@@ -3101,6 +3159,7 @@
   "gtceu.machine.opv_gas_collector.tooltip": "§7Collects Gas from the universe depending on the dimension",
   "gtceu.machine.opv_rock_crusher.tooltip": "§7Volcanic Formation Chamber",
   "gtceu.machine.parallel_hatch.display": "Adjust the maximum parallel of the multiblock",
+  "gtceu.machine.parallel_hatch.parallel_ui": "Parallels",
   "gtceu.machine.parallel_hatch_mk5.tooltip": "Allows to run up to 4 recipes in parallel.",
   "gtceu.machine.parallel_hatch_mk6.tooltip": "Allows to run up to 16 recipes in parallel.",
   "gtceu.machine.parallel_hatch_mk7.tooltip": "Allows to run up to 64 recipes in parallel.",
@@ -3263,6 +3322,36 @@
   "gtceu.mode.both": "§dBoth (Fluid And Item)§r",
   "gtceu.mode.fluid": "§9Fluid§r",
   "gtceu.mode.item": "§6Item§r",
+  "gtceu.module.advanced_jetpack": "Makes the chestplate work like an advanced jetpack (requires any battery module)",
+  "gtceu.module.attack_damage": "Increases attack damage by %s%%",
+  "gtceu.module.attack_speed": "Increases attack speed by %s%%",
+  "gtceu.module.battery": "Allows the item to store energy or increases its capacity (capacity is equal to the battery's)",
+  "gtceu.module.block_reach": "Increases block reach by %s blocks",
+  "gtceu.module.block_reach.short": "... by %s blocks",
+  "gtceu.module.creative_flight": "Allows creative flight (consumes %s EU/t while flying)",
+  "gtceu.module.damage_block": "Blocks any amount of damage with EU (%s EU per HP, requires any battery module)",
+  "gtceu.module.damage_block.short": "%s EU per HP",
+  "gtceu.module.fluid_storage": "Allows the item to store liquids or increases its capacity (capacity is equal to the tank's)",
+  "gtceu.module.gui.charge": "Charge:",
+  "gtceu.module.gui.enabled": "Enabled:",
+  "gtceu.module.gui.jump_boost": "Boost:",
+  "gtceu.module.gui.power": "Power:",
+  "gtceu.module.jetpack": "Makes the chestplate work like a jetpack (requires any battery module)",
+  "gtceu.module.jump": "Increases jump height by %s blocks",
+  "gtceu.module.liquid_fuel_jetpack": "Makes the chestplate work like a liquid fueled jetpack (requires any fluid storage module)",
+  "gtceu.module.movement_speed": "Increases all movement speed by %s%%",
+  "gtceu.module.nightvision": "Provides night vision (consumes %s EU/t while active)",
+  "gtceu.module.ppe": "Provides protection from environmental hazards if applied to all armor pieces",
+  "gtceu.module.sensor": "Reports machine explosions (for machines placed by the player)",
+  "gtceu.module.short_percentage": "... by %s%%",
+  "gtceu.module.sneak_speed": "Increases sneaking speed by %s%%",
+  "gtceu.module.speed": "Increases sprint speed by %s%%",
+  "gtceu.module.step_height": "Increases step height by %s blocks",
+  "gtceu.module.swim_speed": "Increases swim speed by %s%%",
+  "gtceu.module.wireless_charging": "Allows wireless charging in the range of %s blocks (1A %s max), bind to a charger by right-clicking on it",
+  "gtceu.module.wireless_charging.interdimensional": "%s blocks, 1A %s max, interdimensional if an at least %s field generator is present",
+  "gtceu.module.wireless_charging.short": "%s blocks, 1A %s max",
+  "gtceu.modules": "Modules:",
   "gtceu.muffler.recovery_tooltip": "§bRecovery Chance: §f%d%%",
   "gtceu.multiblock.active_transformer.average_in": "§bAvg. Input: §f%s EU/t",
   "gtceu.multiblock.active_transformer.average_out": "§bAvg. Output: §f%s EU/t",
@@ -3324,10 +3413,9 @@
   "gtceu.multiblock.hpca.info_bridging_disabled": "Bridging Disabled",
   "gtceu.multiblock.hpca.info_bridging_enabled": "Bridging Enabled",
   "gtceu.multiblock.hpca.info_coolant_name": "PCB Coolant",
+  "gtceu.multiblock.hpca.info_cooling_demand": "Cooling Demand: %s / %d",
   "gtceu.multiblock.hpca.info_max_computation": "Max CWU/t: %s",
   "gtceu.multiblock.hpca.info_max_coolant_required": "Coolant Needed: %s",
-  "gtceu.multiblock.hpca.info_max_cooling_available": "Cooling Available: %s",
-  "gtceu.multiblock.hpca.info_max_cooling_demand": "Cooling Demand: %s",
   "gtceu.multiblock.hpca.temperature": "Temperature: %s",
   "gtceu.multiblock.hpca.warning_low_cooling": "- Not enough cooling",
   "gtceu.multiblock.hpca.warning_multiple_bridges": "- Multiple bridges in structure (provides no additional benefit)",
@@ -3480,9 +3568,9 @@
   "gtceu.multiblock.turbine.rotor_durability": "Rotor Durability: %s%%",
   "gtceu.multiblock.turbine.rotor_speed": "Rotor Speed: %s/%s RPM",
   "gtceu.multiblock.universal.distinct": "Distinct Buses:",
+  "gtceu.multiblock.universal.distinct.disabled": "Distinct Buses: §eDisabled",
+  "gtceu.multiblock.universal.distinct.enabled": "Distinct Buses: §eEnabled",
   "gtceu.multiblock.universal.distinct.info": "If enabled, each Item Input Bus will be treated as fully distinct from each other for recipe lookup. Useful for things like Programmed Circuits, Extruder Shapes, etc.",
-  "gtceu.multiblock.universal.distinct.no": "No",
-  "gtceu.multiblock.universal.distinct.yes": "Yes",
   "gtceu.multiblock.universal.has_problems": "Has Maintenance Problems!",
   "gtceu.multiblock.universal.has_problems_header": "Fix the following issues in a Maintenance Hatch:",
   "gtceu.multiblock.universal.muffler_obstructed": "Muffler Hatch is Obstructed!",
@@ -3513,6 +3601,14 @@
   "gtceu.packer": "Packer",
   "gtceu.part_sharing.disabled": "Multiblock Sharing §4Disabled",
   "gtceu.part_sharing.enabled": "Multiblock Sharing §aEnabled",
+  "gtceu.placeholder_editor.constant_value": "This expression always evaluates to the same result.\nConsider replacing it with a constant.",
+  "gtceu.placeholder_editor.extra_closing_bracket": "Extra closing bracket",
+  "gtceu.placeholder_editor.no_placeholder": "Placeholder with name '%s' does not exist",
+  "gtceu.placeholder_editor.unclosed_bracket": "Unclosed bracket (\"}\")",
+  "gtceu.placeholder_editor.unclosed_brackets": "%d brackets (\"}\") are unclosed",
+  "gtceu.placeholder_editor.unclosed_escape": "Unclosed escape (\"']\")",
+  "gtceu.placeholder_editor.unclosed_escapes": "%d escapes (\"']\") are unclosed",
+  "gtceu.placeholder_editor.write_in_if": "Placeholders inside {if} are executed regardless of the condition.\nThis means that, for example, \"{if 0 {redstone set 15}}\" will produce redstone output.\nTo avoid this, use \"{eval {if <condition> \"<code>\" \"<else_code>\"}}\".",
   "gtceu.placeholder_info.active.0": "Returns a 1 if the block the cover is attached to is currently running a recipe, 0 otherwise.",
   "gtceu.placeholder_info.active.1": "Usage:",
   "gtceu.placeholder_info.active.2": "  {active} -> whether there's a currently running recipe",
@@ -4126,6 +4222,7 @@
   "item.gtceu.cpu_chip.tooltip": "§7Central Processing Unit",
   "item.gtceu.cpu_wafer": "CPU Wafer",
   "item.gtceu.cpu_wafer.tooltip": "§7Raw Processing Unit",
+  "item.gtceu.creative_flight_module": "Gravitation Module",
   "item.gtceu.crushed_bentonite_ore": "Ground Bentonite",
   "item.gtceu.crushed_cassiterite_sand_ore": "Ground Cassiterite Sand",
   "item.gtceu.crushed_pitchblende_ore": "Ground Pitchblende",
@@ -4271,6 +4368,7 @@
   "item.gtceu.gray_glass_lens": "Glass Lens (Gray)",
   "item.gtceu.green_dye_spray_can": "Spray Can (Green)",
   "item.gtceu.green_glass_lens": "Glass Lens (Green)",
+  "item.gtceu.gui_module": "Gui Module",
   "item.gtceu.hammer_extruder_mold.tooltip": "§7Extruder Shape for making Hammers",
   "item.gtceu.hazmat_boots": "Hazardous Materials Suit Boots",
   "item.gtceu.hazmat_chestpiece": "Hazardous Materials Suit Chestpiece",
@@ -5764,6 +5862,33 @@
   "metaarmor.tooltip.falldamage": "Nullifies Fall Damage",
   "metaarmor.tooltip.freezing": "Prevents Freezing",
   "metaarmor.tooltip.jump": "Increases Jump Height and Distance",
+  "metaarmor.tooltip.modifier": " - %s: %s",
+  "metaarmor.tooltip.modifier.attack_damage": "Attack Damage Module (%s)",
+  "metaarmor.tooltip.modifier.attack_speed": "Attack Speed Module (%s)",
+  "metaarmor.tooltip.modifier.battery": "Battery Module (%s)",
+  "metaarmor.tooltip.modifier.battery.hud.boots": "Boots battery: %s",
+  "metaarmor.tooltip.modifier.battery.hud.chestplate": "Chestplate battery: %s",
+  "metaarmor.tooltip.modifier.battery.hud.helmet": "Helmet battery: %s",
+  "metaarmor.tooltip.modifier.battery.hud.info": "Storing %s/%s EU",
+  "metaarmor.tooltip.modifier.battery.hud.leggings": "Leggings battery: %s",
+  "metaarmor.tooltip.modifier.block_reach": "Reach Module (%s)",
+  "metaarmor.tooltip.modifier.creative_flight": "Creative Flight Module",
+  "metaarmor.tooltip.modifier.damage_block": "Energy Shield Module (%s)",
+  "metaarmor.tooltip.modifier.empty": "Empty",
+  "metaarmor.tooltip.modifier.fluid_storage": "Additional fluid storage (%s)",
+  "metaarmor.tooltip.modifier.fluid_storage.tooltip": "Storing %s/%s mB of %s",
+  "metaarmor.tooltip.modifier.jetpack": "Jetpack Module (%s)",
+  "metaarmor.tooltip.modifier.jump": "Jump Module (%s)",
+  "metaarmor.tooltip.modifier.movement_speed": "Movement Speed Module (%s)",
+  "metaarmor.tooltip.modifier.sensor": "Explosion Reporting Module (%s)",
+  "metaarmor.tooltip.modifier.sneak_speed": "Sneak Speed Module (%s)",
+  "metaarmor.tooltip.modifier.speed": "Running Speed Module (%s)",
+  "metaarmor.tooltip.modifier.step_height": "Step Height Module (%s)",
+  "metaarmor.tooltip.modifier.swim_speed": "Swim Speed Module (%s)",
+  "metaarmor.tooltip.modifier.wireless_charging": "Wireless Charging Module (%s)",
+  "metaarmor.tooltip.modifier_slot.tiered": "Tiered (%s)",
+  "metaarmor.tooltip.modifier_slot.universal": "Universal",
+  "metaarmor.tooltip.modifiers": "Module slots:",
   "metaarmor.tooltip.potions": "Nullifies Harmful Effects",
   "metaarmor.tooltip.speed": "Increases Running Speed",
   "metaarmor.tooltip.stepassist": "Provides Step-Assist",
diff --git a/src/generated/resources/assets/gtceu/models/block/equipment_foundry.json b/src/generated/resources/assets/gtceu/models/block/equipment_foundry.json
new file mode 100644
index 00000000000..77b8bf7bbc7
--- /dev/null
+++ b/src/generated/resources/assets/gtceu/models/block/equipment_foundry.json
@@ -0,0 +1,6 @@
+{
+  "parent": "minecraft:block/cube_all",
+  "textures": {
+    "all": "gtceu:block/equipment_foundry"
+  }
+}
\ No newline at end of file
diff --git a/src/generated/resources/assets/gtceu/models/block/machine/test_mui.json b/src/generated/resources/assets/gtceu/models/block/machine/test_mui.json
new file mode 100644
index 00000000000..f86f60d96f9
--- /dev/null
+++ b/src/generated/resources/assets/gtceu/models/block/machine/test_mui.json
@@ -0,0 +1,18 @@
+{
+  "parent": "minecraft:block/block",
+  "loader": "gtceu:machine",
+  "machine": "gtceu:test_mui",
+  "replaceable_textures": [
+    "all"
+  ],
+  "variants": {
+    "": {
+      "model": {
+        "parent": "gtceu:block/machine/part/computer_monitor",
+        "textures": {
+          "all": "gtceu:block/casings/solid/machine_casing_clean_stainless_steel"
+        }
+      }
+    }
+  }
+}
\ No newline at end of file
diff --git a/src/generated/resources/assets/gtceu/models/block/machine/test_mui_new.json b/src/generated/resources/assets/gtceu/models/block/machine/test_mui_new.json
new file mode 100644
index 00000000000..12fd1d59a84
--- /dev/null
+++ b/src/generated/resources/assets/gtceu/models/block/machine/test_mui_new.json
@@ -0,0 +1,42 @@
+{
+  "parent": "minecraft:block/block",
+  "loader": "gtceu:machine",
+  "machine": "gtceu:test_mui_new",
+  "replaceable_textures": [
+    "all"
+  ],
+  "variants": {
+    "recipe_logic_status=idle": {
+      "model": {
+        "parent": "gtceu:block/machine/part/computer_monitor",
+        "textures": {
+          "all": "gtceu:block/casings/solid/machine_casing_clean_stainless_steel"
+        }
+      }
+    },
+    "recipe_logic_status=suspend": {
+      "model": {
+        "parent": "gtceu:block/machine/part/computer_monitor",
+        "textures": {
+          "all": "gtceu:block/casings/solid/machine_casing_clean_stainless_steel"
+        }
+      }
+    },
+    "recipe_logic_status=waiting": {
+      "model": {
+        "parent": "gtceu:block/machine/part/computer_monitor",
+        "textures": {
+          "all": "gtceu:block/casings/solid/machine_casing_clean_stainless_steel"
+        }
+      }
+    },
+    "recipe_logic_status=working": {
+      "model": {
+        "parent": "gtceu:block/machine/part/computer_monitor",
+        "textures": {
+          "all": "gtceu:block/casings/solid/machine_casing_clean_stainless_steel"
+        }
+      }
+    }
+  }
+}
\ No newline at end of file
diff --git a/src/generated/resources/assets/gtceu/models/item/creative_flight_module.json b/src/generated/resources/assets/gtceu/models/item/creative_flight_module.json
new file mode 100644
index 00000000000..cda3d565098
--- /dev/null
+++ b/src/generated/resources/assets/gtceu/models/item/creative_flight_module.json
@@ -0,0 +1,6 @@
+{
+  "parent": "minecraft:item/generated",
+  "textures": {
+    "layer0": "gtceu:item/creative_flight_module"
+  }
+}
\ No newline at end of file
diff --git a/src/generated/resources/assets/gtceu/models/item/equipment_foundry.json b/src/generated/resources/assets/gtceu/models/item/equipment_foundry.json
new file mode 100644
index 00000000000..4de77ddab56
--- /dev/null
+++ b/src/generated/resources/assets/gtceu/models/item/equipment_foundry.json
@@ -0,0 +1,3 @@
+{
+  "parent": "gtceu:block/equipment_foundry"
+}
\ No newline at end of file
diff --git a/src/generated/resources/assets/gtceu/models/item/gui_module.json b/src/generated/resources/assets/gtceu/models/item/gui_module.json
new file mode 100644
index 00000000000..5c1152837c4
--- /dev/null
+++ b/src/generated/resources/assets/gtceu/models/item/gui_module.json
@@ -0,0 +1,6 @@
+{
+  "parent": "minecraft:item/generated",
+  "textures": {
+    "layer0": "gtceu:item/gui_module"
+  }
+}
\ No newline at end of file
diff --git a/src/generated/resources/assets/gtceu/models/item/test_mui.json b/src/generated/resources/assets/gtceu/models/item/test_mui.json
new file mode 100644
index 00000000000..9ae958ad11c
--- /dev/null
+++ b/src/generated/resources/assets/gtceu/models/item/test_mui.json
@@ -0,0 +1,3 @@
+{
+  "parent": "gtceu:block/machine/test_mui"
+}
\ No newline at end of file
diff --git a/src/generated/resources/assets/gtceu/models/item/test_mui_new.json b/src/generated/resources/assets/gtceu/models/item/test_mui_new.json
new file mode 100644
index 00000000000..e741c72dc8d
--- /dev/null
+++ b/src/generated/resources/assets/gtceu/models/item/test_mui_new.json
@@ -0,0 +1,3 @@
+{
+  "parent": "gtceu:block/machine/test_mui_new"
+}
\ No newline at end of file
diff --git a/src/generated/resources/data/gtceu/loot_tables/blocks/equipment_foundry.json b/src/generated/resources/data/gtceu/loot_tables/blocks/equipment_foundry.json
new file mode 100644
index 00000000000..6298ba16691
--- /dev/null
+++ b/src/generated/resources/data/gtceu/loot_tables/blocks/equipment_foundry.json
@@ -0,0 +1,21 @@
+{
+  "type": "minecraft:block",
+  "pools": [
+    {
+      "bonus_rolls": 0.0,
+      "conditions": [
+        {
+          "condition": "minecraft:survives_explosion"
+        }
+      ],
+      "entries": [
+        {
+          "type": "minecraft:item",
+          "name": "gtceu:equipment_foundry"
+        }
+      ],
+      "rolls": 1.0
+    }
+  ],
+  "random_sequence": "gtceu:blocks/equipment_foundry"
+}
\ No newline at end of file
diff --git a/src/generated/resources/data/gtceu/tags/items/electric_motors.json b/src/generated/resources/data/gtceu/tags/items/electric_motors.json
index 05904c9c33a..fb43bbca08d 100644
--- a/src/generated/resources/data/gtceu/tags/items/electric_motors.json
+++ b/src/generated/resources/data/gtceu/tags/items/electric_motors.json
@@ -8,6 +8,11 @@
     "gtceu:luv_electric_motor",
     "gtceu:zpm_electric_motor",
     "gtceu:uv_electric_motor",
+    "gtceu:uhv_electric_motor",
+    "gtceu:uev_electric_motor",
+    "gtceu:uiv_electric_motor",
+    "gtceu:uxv_electric_motor",
+    "gtceu:opv_electric_motor",
     {
       "id": "gtceu:uhv_electric_motor",
       "required": false
diff --git a/src/generated/resources/data/gtceu/tags/items/electric_pumps.json b/src/generated/resources/data/gtceu/tags/items/electric_pumps.json
index 2fb3023fbd4..8db38c02bc2 100644
--- a/src/generated/resources/data/gtceu/tags/items/electric_pumps.json
+++ b/src/generated/resources/data/gtceu/tags/items/electric_pumps.json
@@ -8,6 +8,11 @@
     "gtceu:luv_electric_pump",
     "gtceu:zpm_electric_pump",
     "gtceu:uv_electric_pump",
+    "gtceu:uhv_electric_pump",
+    "gtceu:uev_electric_pump",
+    "gtceu:uiv_electric_pump",
+    "gtceu:uxv_electric_pump",
+    "gtceu:opv_electric_pump",
     {
       "id": "gtceu:uhv_electric_pump",
       "required": false
diff --git a/src/generated/resources/data/gtceu/tags/items/fluid_containers.json b/src/generated/resources/data/gtceu/tags/items/fluid_containers.json
new file mode 100644
index 00000000000..519fd22af7c
--- /dev/null
+++ b/src/generated/resources/data/gtceu/tags/items/fluid_containers.json
@@ -0,0 +1,30 @@
+{
+  "values": [
+    "gtceu:lv_super_tank",
+    "gtceu:mv_super_tank",
+    "gtceu:hv_super_tank",
+    "gtceu:ev_super_tank",
+    "gtceu:iv_quantum_tank",
+    "gtceu:luv_quantum_tank",
+    "gtceu:zpm_quantum_tank",
+    "gtceu:uv_quantum_tank",
+    "gtceu:uhv_quantum_tank",
+    "gtceu:uev_quantum_tank",
+    "gtceu:uiv_quantum_tank",
+    "gtceu:uxv_quantum_tank",
+    "gtceu:opv_quantum_tank",
+    "gtceu:wood_drum",
+    "gtceu:bronze_drum",
+    "gtceu:steel_drum",
+    "gtceu:aluminium_drum",
+    "gtceu:stainless_steel_drum",
+    "gtceu:gold_drum",
+    "gtceu:titanium_drum",
+    "gtceu:tungsten_steel_drum",
+    "gtceu:steel_fluid_cell",
+    "gtceu:aluminium_fluid_cell",
+    "gtceu:stainless_steel_fluid_cell",
+    "gtceu:titanium_fluid_cell",
+    "gtceu:tungsten_steel_fluid_cell"
+  ]
+}
\ No newline at end of file
diff --git a/src/main/java/com/gregtechceu/gtceu/api/GTValues.java b/src/main/java/com/gregtechceu/gtceu/api/GTValues.java
index 7f2da34899c..d75000693d6 100644
--- a/src/main/java/com/gregtechceu/gtceu/api/GTValues.java
+++ b/src/main/java/com/gregtechceu/gtceu/api/GTValues.java
@@ -140,8 +140,8 @@ public static int[] tiersBetween(int minInclusive, int maxInclusive) {
             MODID_FTB_QUEST = "ftbquests",
             MODID_CCTWEAKED = "computercraft",
             MODID_ENDERIO = "enderio",
-            MODID_ENSORCELLATION = "ensorcellation";
-
+            MODID_ENSORCELLATION = "ensorcellation",
+            MODID_ATTRIBUTEFIX = "attributefix";
     /**
      * Spray painting compat modids
      */
diff --git a/src/main/java/com/gregtechceu/gtceu/api/block/MetaMachineBlock.java b/src/main/java/com/gregtechceu/gtceu/api/block/MetaMachineBlock.java
index 93c4037f202..b52a2a787dc 100644
--- a/src/main/java/com/gregtechceu/gtceu/api/block/MetaMachineBlock.java
+++ b/src/main/java/com/gregtechceu/gtceu/api/block/MetaMachineBlock.java
@@ -295,9 +295,12 @@ public InteractionResult use(BlockState state, Level world, BlockPos pos, Player
             shouldOpenUi = gtToolItem.definition$shouldOpenUIAfterUse(new UseOnContext(player, hand, hit));
         }
 
-        if (shouldOpenUi && machine instanceof IUIMachine uiMachine &&
-                MachineOwner.canOpenOwnerMachine(player, machine)) {
-            return uiMachine.tryToOpenUI(player, hand, hit);
+        if (shouldOpenUi && MachineOwner.canOpenOwnerMachine(player, machine)) {
+            if (machine.getDefinition().getUI() != null) {
+                return machine.getDefinition().getUI().tryToOpenUI(player, hand, hit);
+            } else if (machine instanceof IMuiMachine muiMachine) {
+                return muiMachine.tryToOpenUI(player, hand, hit);
+            }
         }
         return shouldOpenUi ? InteractionResult.PASS : InteractionResult.CONSUME;
     }
diff --git a/src/main/java/com/gregtechceu/gtceu/api/block/RendererMaterialBlock.java b/src/main/java/com/gregtechceu/gtceu/api/block/RendererMaterialBlock.java
deleted file mode 100644
index ddd25dd4e5c..00000000000
--- a/src/main/java/com/gregtechceu/gtceu/api/block/RendererMaterialBlock.java
+++ /dev/null
@@ -1,31 +0,0 @@
-package com.gregtechceu.gtceu.api.block;
-
-import com.gregtechceu.gtceu.api.data.chemical.material.Material;
-import com.gregtechceu.gtceu.api.data.tag.TagPrefix;
-
-import com.lowdragmc.lowdraglib.client.renderer.IBlockRendererProvider;
-import com.lowdragmc.lowdraglib.client.renderer.IRenderer;
-
-import net.minecraft.world.level.block.state.BlockState;
-import net.minecraftforge.api.distmarker.Dist;
-import net.minecraftforge.api.distmarker.OnlyIn;
-
-import org.jetbrains.annotations.Nullable;
-
-public class RendererMaterialBlock extends MaterialBlock implements IBlockRendererProvider {
-
-    public final IRenderer renderer;
-
-    public RendererMaterialBlock(Properties properties, TagPrefix tagPrefix, Material material,
-                                 @Nullable IRenderer renderer) {
-        super(properties, tagPrefix, material, false);
-        this.renderer = renderer;
-    }
-
-    @Nullable
-    @Override
-    @OnlyIn(Dist.CLIENT)
-    public IRenderer getRenderer(BlockState state) {
-        return renderer;
-    }
-}
diff --git a/src/main/java/com/gregtechceu/gtceu/api/blockentity/PipeBlockEntity.java b/src/main/java/com/gregtechceu/gtceu/api/blockentity/PipeBlockEntity.java
index 85160932110..d0d0a1babe8 100644
--- a/src/main/java/com/gregtechceu/gtceu/api/blockentity/PipeBlockEntity.java
+++ b/src/main/java/com/gregtechceu/gtceu/api/blockentity/PipeBlockEntity.java
@@ -5,7 +5,6 @@
 import com.gregtechceu.gtceu.api.cover.CoverBehavior;
 import com.gregtechceu.gtceu.api.data.chemical.material.Material;
 import com.gregtechceu.gtceu.api.data.tag.TagPrefix;
-import com.gregtechceu.gtceu.api.gui.GuiTextures;
 import com.gregtechceu.gtceu.api.item.tool.GTToolType;
 import com.gregtechceu.gtceu.api.item.tool.IToolGridHighlight;
 import com.gregtechceu.gtceu.api.machine.TickableSubscription;
@@ -16,11 +15,10 @@
 import com.gregtechceu.gtceu.api.sync_system.annotations.SyncToClient;
 import com.gregtechceu.gtceu.common.data.GTMaterialBlocks;
 import com.gregtechceu.gtceu.common.data.GTMaterials;
+import com.gregtechceu.gtceu.common.mui.GTGuiTextures;
 import com.gregtechceu.gtceu.utils.ExtendedUseOnContext;
 import com.gregtechceu.gtceu.utils.GTUtil;
 
-import com.lowdragmc.lowdraglib.gui.texture.ResourceTexture;
-
 import net.minecraft.MethodsReturnNonnullByDefault;
 import net.minecraft.core.BlockPos;
 import net.minecraft.core.Direction;
@@ -37,6 +35,7 @@
 import net.minecraft.world.level.block.entity.BlockEntityType;
 import net.minecraft.world.level.block.state.BlockState;
 
+import brachy.modularui.drawable.UITexture;
 import com.mojang.datafixers.util.Pair;
 import lombok.Getter;
 import org.jetbrains.annotations.NotNull;
@@ -329,13 +328,13 @@ public boolean shouldRenderGrid(Player player, BlockPos pos, BlockState state, I
         return false;
     }
 
-    public ResourceTexture getPipeTexture(boolean isBlock) {
-        return isBlock ? GuiTextures.TOOL_PIPE_CONNECT : GuiTextures.TOOL_PIPE_BLOCK;
+    public UITexture getPipeTexture(boolean isBlock) {
+        return isBlock ? GTGuiTextures.TOOL_PIPE_CONNECT : GTGuiTextures.TOOL_PIPE_BLOCK;
     }
 
     @Override
-    public @Nullable ResourceTexture sideTips(Player player, BlockPos pos, BlockState state, Set<GTToolType> toolTypes,
-                                              Direction side) {
+    public @Nullable UITexture sideTips(Player player, BlockPos pos, BlockState state, Set<GTToolType> toolTypes,
+                                        Direction side) {
         if (toolTypes.contains(getPipeTuneTool())) {
             if (player.isShiftKeyDown() && this.canHaveBlockedFaces()) {
                 return getPipeTexture(isBlocked(side));
diff --git a/src/main/java/com/gregtechceu/gtceu/api/capability/GTCapability.java b/src/main/java/com/gregtechceu/gtceu/api/capability/GTCapability.java
index fc3b3a420d2..303dea2c73c 100644
--- a/src/main/java/com/gregtechceu/gtceu/api/capability/GTCapability.java
+++ b/src/main/java/com/gregtechceu/gtceu/api/capability/GTCapability.java
@@ -1,5 +1,6 @@
 package com.gregtechceu.gtceu.api.capability;
 
+import com.gregtechceu.gtceu.api.item.module.IModularItem;
 import com.gregtechceu.gtceu.api.machine.feature.multiblock.IMaintenanceMachine;
 import com.gregtechceu.gtceu.common.capability.MedicalConditionTracker;
 
@@ -36,6 +37,9 @@ public class GTCapability {
     public static final Capability<MedicalConditionTracker> CAPABILITY_MEDICAL_CONDITION_TRACKER = CapabilityManager
             .get(new CapabilityToken<>() {});
 
+    public static final Capability<IModularItem> CAPABILITY_MODULAR_ITEM = CapabilityManager
+            .get(new CapabilityToken<>() {});
+
     public static void register(RegisterCapabilitiesEvent event) {
         event.register(IEnergyContainer.class);
         event.register(IEnergyInfoProvider.class);
@@ -50,5 +54,6 @@ public static void register(RegisterCapabilitiesEvent event) {
         event.register(MedicalConditionTracker.class);
         event.register(IHazardParticleContainer.class);
         event.register(IMonitorComponent.class);
+        event.register(IModularItem.class);
     }
 }
diff --git a/src/main/java/com/gregtechceu/gtceu/api/capability/GTCapabilityHelper.java b/src/main/java/com/gregtechceu/gtceu/api/capability/GTCapabilityHelper.java
index b8b78742232..0f69f802e1d 100644
--- a/src/main/java/com/gregtechceu/gtceu/api/capability/GTCapabilityHelper.java
+++ b/src/main/java/com/gregtechceu/gtceu/api/capability/GTCapabilityHelper.java
@@ -1,5 +1,6 @@
 package com.gregtechceu.gtceu.api.capability;
 
+import com.gregtechceu.gtceu.api.item.module.IModularItem;
 import com.gregtechceu.gtceu.api.machine.feature.multiblock.IMaintenanceMachine;
 import com.gregtechceu.gtceu.common.capability.MedicalConditionTracker;
 
@@ -106,6 +107,11 @@ public static IMonitorComponent getMonitorComponent(Level level, BlockPos pos, @
         return getBlockEntityCapability(GTCapability.CAPABILITY_MONITOR_COMPONENT, level, pos, side);
     }
 
+    @Nullable
+    public static IModularItem getModularItem(ItemStack stack) {
+        return stack.getCapability(GTCapability.CAPABILITY_MODULAR_ITEM).resolve().orElse(null);
+    }
+
     @Nullable
     private static <T> T getBlockEntityCapability(Capability<T> capability, Level level, BlockPos pos,
                                                   @Nullable Direction side) {
diff --git a/src/main/java/com/gregtechceu/gtceu/api/capability/IMonitorComponent.java b/src/main/java/com/gregtechceu/gtceu/api/capability/IMonitorComponent.java
index 002c650a187..b956dd6933f 100644
--- a/src/main/java/com/gregtechceu/gtceu/api/capability/IMonitorComponent.java
+++ b/src/main/java/com/gregtechceu/gtceu/api/capability/IMonitorComponent.java
@@ -1,10 +1,9 @@
 package com.gregtechceu.gtceu.api.capability;
 
-import com.lowdragmc.lowdraglib.gui.texture.IGuiTexture;
-
 import net.minecraft.core.BlockPos;
 import net.minecraftforge.items.IItemHandler;
 
+import brachy.modularui.api.drawable.IDrawable;
 import org.jetbrains.annotations.Nullable;
 
 public interface IMonitorComponent {
@@ -13,7 +12,7 @@ default boolean isMonitor() {
         return false;
     }
 
-    IGuiTexture getComponentIcon();
+    IDrawable getIcon();
 
     BlockPos getBlockPos();
 
diff --git a/src/main/java/com/gregtechceu/gtceu/api/capability/recipe/FluidRecipeCapability.java b/src/main/java/com/gregtechceu/gtceu/api/capability/recipe/FluidRecipeCapability.java
index 8f2e15d80e7..755a9c88955 100644
--- a/src/main/java/com/gregtechceu/gtceu/api/capability/recipe/FluidRecipeCapability.java
+++ b/src/main/java/com/gregtechceu/gtceu/api/capability/recipe/FluidRecipeCapability.java
@@ -17,11 +17,11 @@
 import com.gregtechceu.gtceu.api.recipe.ui.GTRecipeTypeUI;
 import com.gregtechceu.gtceu.client.TooltipsHandler;
 import com.gregtechceu.gtceu.common.valueprovider.*;
-import com.gregtechceu.gtceu.integration.xei.entry.fluid.FluidEntryList;
-import com.gregtechceu.gtceu.integration.xei.entry.fluid.FluidStackList;
-import com.gregtechceu.gtceu.integration.xei.entry.fluid.FluidTagList;
-import com.gregtechceu.gtceu.integration.xei.handlers.fluid.CycleFluidEntryHandler;
-import com.gregtechceu.gtceu.integration.xei.widgets.GTRecipeWidget;
+import com.gregtechceu.gtceu.integration.recipeviewer.entry.fluid.FluidEntryList;
+import com.gregtechceu.gtceu.integration.recipeviewer.entry.fluid.FluidStackList;
+import com.gregtechceu.gtceu.integration.recipeviewer.entry.fluid.FluidTagList;
+import com.gregtechceu.gtceu.integration.recipeviewer.handlers.fluid.CycleFluidEntryHandler;
+import com.gregtechceu.gtceu.integration.recipeviewer.widgets.GTRecipeWidget;
 import com.gregtechceu.gtceu.utils.GTMath;
 
 import com.lowdragmc.lowdraglib.gui.texture.ProgressTexture;
diff --git a/src/main/java/com/gregtechceu/gtceu/api/capability/recipe/IO.java b/src/main/java/com/gregtechceu/gtceu/api/capability/recipe/IO.java
index 40a905e48e0..ba6ef3a0ca1 100644
--- a/src/main/java/com/gregtechceu/gtceu/api/capability/recipe/IO.java
+++ b/src/main/java/com/gregtechceu/gtceu/api/capability/recipe/IO.java
@@ -1,16 +1,12 @@
 package com.gregtechceu.gtceu.api.capability.recipe;
 
-import com.gregtechceu.gtceu.api.gui.widget.EnumSelectorWidget;
-
-import com.lowdragmc.lowdraglib.gui.texture.IGuiTexture;
-import com.lowdragmc.lowdraglib.gui.texture.ResourceTexture;
-
+import brachy.modularui.drawable.UITexture;
 import lombok.Getter;
 
 /**
  * The capability can be input or output or both
  */
-public enum IO implements EnumSelectorWidget.SelectableEnum {
+public enum IO {
 
     IN("gtceu.io.import", "import"),
     OUT("gtceu.io.export", "export"),
@@ -20,11 +16,11 @@ public enum IO implements EnumSelectorWidget.SelectableEnum {
     @Getter
     public final String tooltip;
     @Getter
-    public final IGuiTexture icon;
+    public final UITexture uiTexture;
 
     IO(String tooltip, String textureName) {
         this.tooltip = tooltip;
-        this.icon = new ResourceTexture("gtceu:textures/gui/icon/io_mode/" + textureName + ".png");
+        this.uiTexture = UITexture.fullImage("gtceu:textures/gui/icon/io_mode/" + textureName + ".png");
     }
 
     public boolean support(IO io) {
diff --git a/src/main/java/com/gregtechceu/gtceu/api/capability/recipe/ItemRecipeCapability.java b/src/main/java/com/gregtechceu/gtceu/api/capability/recipe/ItemRecipeCapability.java
index 239d8a9377b..e38611320d5 100644
--- a/src/main/java/com/gregtechceu/gtceu/api/capability/recipe/ItemRecipeCapability.java
+++ b/src/main/java/com/gregtechceu/gtceu/api/capability/recipe/ItemRecipeCapability.java
@@ -23,11 +23,11 @@
 import com.gregtechceu.gtceu.core.mixins.IngredientAccessor;
 import com.gregtechceu.gtceu.core.mixins.TagValueAccessor;
 import com.gregtechceu.gtceu.core.mixins.forge.IntersectionIngredientAccessor;
-import com.gregtechceu.gtceu.integration.xei.entry.item.ItemEntryList;
-import com.gregtechceu.gtceu.integration.xei.entry.item.ItemStackList;
-import com.gregtechceu.gtceu.integration.xei.entry.item.ItemTagList;
-import com.gregtechceu.gtceu.integration.xei.handlers.item.CycleItemEntryHandler;
-import com.gregtechceu.gtceu.integration.xei.widgets.GTRecipeWidget;
+import com.gregtechceu.gtceu.integration.recipeviewer.entry.item.ItemEntryList;
+import com.gregtechceu.gtceu.integration.recipeviewer.entry.item.ItemStackList;
+import com.gregtechceu.gtceu.integration.recipeviewer.entry.item.ItemTagList;
+import com.gregtechceu.gtceu.integration.recipeviewer.handlers.item.CycleItemEntryHandler;
+import com.gregtechceu.gtceu.integration.recipeviewer.widgets.GTRecipeWidget;
 import com.gregtechceu.gtceu.utils.*;
 
 import com.lowdragmc.lowdraglib.gui.widget.Widget;
diff --git a/src/main/java/com/gregtechceu/gtceu/api/cover/CoverBehavior.java b/src/main/java/com/gregtechceu/gtceu/api/cover/CoverBehavior.java
index 24ce428669d..8b948e23b28 100644
--- a/src/main/java/com/gregtechceu/gtceu/api/cover/CoverBehavior.java
+++ b/src/main/java/com/gregtechceu/gtceu/api/cover/CoverBehavior.java
@@ -2,24 +2,20 @@
 
 import com.gregtechceu.gtceu.api.blockentity.ICopyable;
 import com.gregtechceu.gtceu.api.capability.ICoverable;
-import com.gregtechceu.gtceu.api.gui.GuiTextures;
-import com.gregtechceu.gtceu.api.gui.factory.CoverUIFactory;
-import com.gregtechceu.gtceu.api.gui.fancy.IFancyConfigurator;
 import com.gregtechceu.gtceu.api.item.tool.GTToolType;
 import com.gregtechceu.gtceu.api.item.tool.IToolGridHighlight;
 import com.gregtechceu.gtceu.api.machine.MetaMachine;
+import com.gregtechceu.gtceu.api.mui.factory.CoverUIFactory;
 import com.gregtechceu.gtceu.api.sync_system.ISyncManaged;
-import com.gregtechceu.gtceu.api.sync_system.ManagedSyncBlockEntity;
 import com.gregtechceu.gtceu.api.sync_system.SyncDataHolder;
 import com.gregtechceu.gtceu.api.sync_system.annotations.SaveField;
 import com.gregtechceu.gtceu.api.sync_system.annotations.SyncToClient;
 import com.gregtechceu.gtceu.api.transfer.fluid.IFluidHandlerModifiable;
 import com.gregtechceu.gtceu.client.renderer.cover.ICoverRenderer;
 import com.gregtechceu.gtceu.client.renderer.cover.IDynamicCoverRenderer;
+import com.gregtechceu.gtceu.common.mui.GTGuiTextures;
 import com.gregtechceu.gtceu.utils.ExtendedUseOnContext;
 
-import com.lowdragmc.lowdraglib.gui.texture.ResourceTexture;
-
 import net.minecraft.MethodsReturnNonnullByDefault;
 import net.minecraft.core.BlockPos;
 import net.minecraft.core.Direction;
@@ -31,6 +27,7 @@
 import net.minecraft.world.level.block.state.BlockState;
 import net.minecraftforge.items.IItemHandlerModifiable;
 
+import brachy.modularui.drawable.UITexture;
 import com.mojang.datafixers.util.Pair;
 import lombok.Getter;
 import org.jetbrains.annotations.MustBeInvokedByOverriders;
@@ -79,9 +76,7 @@ public void scheduleRenderUpdate() {
 
     @Override
     public void markAsChanged() {
-        if (coverHolder instanceof ManagedSyncBlockEntity syncEntity) {
-            syncEntity.markAsChanged();
-        }
+        coverHolder.markAsChanged();
     }
 
     /**
@@ -108,6 +103,7 @@ public void onAttached(ItemStack itemStack, @Nullable ServerPlayer player) {
         attachItem = itemStack.copy();
         attachItem.setCount(1);
         syncDataHolder.markClientSyncFieldDirty("attachItem");
+        markAsChanged();
     }
 
     public void onLoad() {}
@@ -161,9 +157,9 @@ public boolean canConnectRedstone() {
     }
 
     public InteractionResult onScrewdriverClick(ExtendedUseOnContext context) {
-        if (this instanceof IUICover) {
+        if (this instanceof IMuiCover muiCover) {
             if (context.getPlayer() instanceof ServerPlayer serverPlayer) {
-                CoverUIFactory.INSTANCE.openUI(this, serverPlayer);
+                CoverUIFactory.INSTANCE.open(serverPlayer, muiCover);
             }
             return InteractionResult.sidedSuccess(coverHolder.isRemote());
         }
@@ -192,25 +188,21 @@ public boolean shouldRenderPlate() {
         return coverDefinition.getCoverRenderer();
     }
 
-    public @Nullable IFancyConfigurator getConfigurator() {
-        return null;
-    }
-
     @Override
     public boolean shouldRenderGrid(Player player, BlockPos pos, BlockState state, ItemStack held,
                                     Set<GTToolType> toolTypes) {
         return toolTypes.contains(GTToolType.CROWBAR) ||
-                ((toolTypes.isEmpty() || toolTypes.contains(GTToolType.SCREWDRIVER)) && this instanceof IUICover);
+                ((toolTypes.isEmpty() || toolTypes.contains(GTToolType.SCREWDRIVER)) && this instanceof IMuiCover);
     }
 
     @Override
-    public @Nullable ResourceTexture sideTips(Player player, BlockPos pos, BlockState state, Set<GTToolType> toolTypes,
-                                              Direction side) {
+    public @Nullable UITexture sideTips(Player player, BlockPos pos, BlockState state, Set<GTToolType> toolTypes,
+                                        Direction side) {
         if (toolTypes.contains(GTToolType.CROWBAR)) {
-            return GuiTextures.TOOL_REMOVE_COVER;
+            return GTGuiTextures.TOOL_REMOVE_COVER;
         }
-        if ((toolTypes.isEmpty() || toolTypes.contains(GTToolType.SCREWDRIVER)) && this instanceof IUICover) {
-            return GuiTextures.TOOL_COVER_SETTINGS;
+        if ((toolTypes.isEmpty() || toolTypes.contains(GTToolType.SCREWDRIVER)) && this instanceof IMuiCover) {
+            return GTGuiTextures.TOOL_COVER_SETTINGS;
         }
         return null;
     }
@@ -223,7 +215,7 @@ public BlockState getAppearance(BlockState sourceState, BlockPos sourcePos) {
         return null;
     }
 
-    public Supplier<IDynamicCoverRenderer> getDynamicRenderer() {
+    public Supplier<@Nullable IDynamicCoverRenderer> getDynamicRenderer() {
         return () -> null;
     }
 
diff --git a/src/main/java/com/gregtechceu/gtceu/api/cover/IMuiCover.java b/src/main/java/com/gregtechceu/gtceu/api/cover/IMuiCover.java
new file mode 100644
index 00000000000..e1eae3187b0
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/api/cover/IMuiCover.java
@@ -0,0 +1,90 @@
+package com.gregtechceu.gtceu.api.cover;
+
+import com.gregtechceu.gtceu.api.mui.GTGuiScreen;
+import com.gregtechceu.gtceu.common.mui.GTGuiTextures;
+import com.gregtechceu.gtceu.common.mui.GTGuiTheme;
+import com.gregtechceu.gtceu.common.mui.GTMuiWidgets;
+
+import net.minecraftforge.api.distmarker.Dist;
+import net.minecraftforge.api.distmarker.OnlyIn;
+
+import brachy.modularui.api.IUIHolder;
+import brachy.modularui.factory.SidedPosGuiData;
+import brachy.modularui.screen.ModularPanel;
+import brachy.modularui.screen.ModularScreen;
+import brachy.modularui.screen.UISettings;
+import brachy.modularui.value.BoolValue;
+import brachy.modularui.value.sync.EnumSyncValue;
+import brachy.modularui.value.sync.PanelSyncManager;
+import brachy.modularui.widgets.SlotGroupWidget;
+import brachy.modularui.widgets.layout.Flow;
+
+public interface IMuiCover extends IUIHolder<SidedPosGuiData> {
+
+    default CoverBehavior self() {
+        return (CoverBehavior) this;
+    }
+
+    default boolean isRemote() {
+        return self().coverHolder.isRemote();
+    }
+
+    default boolean isRemoved() {
+        return self().coverHolder.isRemoved() || self().coverHolder.getCoverAtSide(self().attachedSide) != self();
+    }
+
+    default GTGuiTheme getUITheme() {
+        return GTGuiTheme.COVER;
+    }
+
+    @Override
+    @OnlyIn(Dist.CLIENT)
+    default ModularScreen createScreen(SidedPosGuiData data, ModularPanel<?> mainPanel) {
+        return new GTGuiScreen(mainPanel);
+    }
+
+    @Override
+    default ModularPanel<?> buildUI(SidedPosGuiData data, PanelSyncManager syncManager, UISettings settings) {
+        ModularPanel<?> panel = ModularPanel.defaultPanel(this.self().coverDefinition.getId().getPath(), 176, 192 + 18);
+
+        panel.child(GTMuiWidgets.createTitleBar(this.self().getAttachItem(), 176, GTGuiTextures.BACKGROUND));
+
+        Flow column = Flow.column()
+                .top(7).margin(7, 0)
+                .childPadding(2)
+                .widthRel(1.0f).coverChildrenHeight();
+
+        createCoverUIRows(column, data, syncManager, settings);
+        return panel.child(column)
+                .child(SlotGroupWidget.playerInventory(false).left(7).bottom(7));
+    }
+
+    /**
+     * The default cover UI panel builds a single column with rows added by each cover.
+     */
+    default void createCoverUIRows(Flow column, SidedPosGuiData data, PanelSyncManager syncManager,
+                                   UISettings settings) {}
+
+    /* Helper methods for UI creation with covers that are commonly used */
+
+    /**
+     * The color used for Cover UI text. Available for reference, but is
+     * handled automatically by the {@link GTGuiTheme#COVER} theme.
+     */
+    int UI_TEXT_COLOR = 0xFF555555;
+
+    default Flow coverUIRow() {
+        return Flow.row()
+                .coverChildrenHeight()
+                .widthRel(1f)
+                .childPadding(2);
+    }
+
+    /**
+     * Get a BoolValue for use with toggle buttons which are "linked together,"
+     * meaning only one of them can be pressed at a time.
+     */
+    default <T extends Enum<T>> BoolValue.Dynamic boolValueOf(EnumSyncValue<T> syncValue, T value) {
+        return new BoolValue.Dynamic(() -> syncValue.getValue() == value, $ -> syncValue.setValue(value));
+    }
+}
diff --git a/src/main/java/com/gregtechceu/gtceu/api/cover/IUICover.java b/src/main/java/com/gregtechceu/gtceu/api/cover/IUICover.java
deleted file mode 100644
index 93d85bd74f5..00000000000
--- a/src/main/java/com/gregtechceu/gtceu/api/cover/IUICover.java
+++ /dev/null
@@ -1,49 +0,0 @@
-package com.gregtechceu.gtceu.api.cover;
-
-import com.gregtechceu.gtceu.api.gui.GuiTextures;
-import com.gregtechceu.gtceu.api.gui.UITemplate;
-
-import com.lowdragmc.lowdraglib.gui.modular.IUIHolder;
-import com.lowdragmc.lowdraglib.gui.modular.ModularUI;
-import com.lowdragmc.lowdraglib.gui.widget.Widget;
-import com.lowdragmc.lowdraglib.utils.Position;
-
-import net.minecraft.world.entity.player.Player;
-
-public interface IUICover extends IUIHolder {
-
-    default CoverBehavior self() {
-        return (CoverBehavior) this;
-    }
-
-    @Override
-    default boolean isInvalid() {
-        return self().coverHolder.isRemoved() || self().coverHolder.getCoverAtSide(self().attachedSide) != self();
-    }
-
-    @Override
-    default boolean isRemote() {
-        return self().coverHolder.isRemote();
-    }
-
-    @Override
-    default ModularUI createUI(Player entityPlayer) {
-        var widget = createUIWidget();
-        var size = widget.getSize();
-        widget.setSelfPosition(new Position((176 - size.width) / 2, 0));
-        var modularUI = new ModularUI(176, size.height + 82, this, entityPlayer)
-                .background(GuiTextures.BACKGROUND)
-                .widget(widget)
-                .widget(UITemplate.bindPlayerInventory(entityPlayer.getInventory(), GuiTextures.SLOT, 7, size.height,
-                        true));
-        modularUI.registerCloseListener(this::onUIClosed);
-        return modularUI;
-    }
-
-    default void onUIClosed() {}
-
-    Widget createUIWidget();
-
-    @Override
-    default void markAsDirty() {}
-}
diff --git a/src/main/java/com/gregtechceu/gtceu/api/cover/filter/Filter.java b/src/main/java/com/gregtechceu/gtceu/api/cover/filter/Filter.java
index 304aef62395..cdb011c12c0 100644
--- a/src/main/java/com/gregtechceu/gtceu/api/cover/filter/Filter.java
+++ b/src/main/java/com/gregtechceu/gtceu/api/cover/filter/Filter.java
@@ -1,15 +1,21 @@
 package com.gregtechceu.gtceu.api.cover.filter;
 
-import com.lowdragmc.lowdraglib.gui.widget.WidgetGroup;
-
 import net.minecraft.nbt.CompoundTag;
 
+import brachy.modularui.factory.GuiData;
+import brachy.modularui.screen.ModularPanel;
+import brachy.modularui.screen.UISettings;
+import brachy.modularui.value.sync.PanelSyncManager;
+
 import java.util.function.Consumer;
 import java.util.function.Predicate;
 
 public interface Filter<T, S extends Filter<T, S>> extends Predicate<T> {
 
-    WidgetGroup openConfigurator(int x, int y);
+    /**
+     * @return Filter panel when opened by itself (including the player inventory)
+     */
+    ModularPanel<?> getPanel(GuiData data, PanelSyncManager syncManager, UISettings settings);
 
     CompoundTag saveFilter();
 
diff --git a/src/main/java/com/gregtechceu/gtceu/api/cover/filter/FilterHandler.java b/src/main/java/com/gregtechceu/gtceu/api/cover/filter/FilterHandler.java
index ea051ee971f..ac2f13b4d4f 100644
--- a/src/main/java/com/gregtechceu/gtceu/api/cover/filter/FilterHandler.java
+++ b/src/main/java/com/gregtechceu/gtceu/api/cover/filter/FilterHandler.java
@@ -2,8 +2,6 @@
 
 import com.gregtechceu.gtceu.GTCEu;
 import com.gregtechceu.gtceu.api.cover.CoverBehavior;
-import com.gregtechceu.gtceu.api.gui.GuiTextures;
-import com.gregtechceu.gtceu.api.gui.widget.SlotWidget;
 import com.gregtechceu.gtceu.api.machine.MachineCoverContainer;
 import com.gregtechceu.gtceu.api.machine.MetaMachine;
 import com.gregtechceu.gtceu.api.sync_system.ISyncManaged;
@@ -12,10 +10,6 @@
 import com.gregtechceu.gtceu.api.sync_system.annotations.SyncToClient;
 import com.gregtechceu.gtceu.api.transfer.item.CustomItemStackHandler;
 
-import com.lowdragmc.lowdraglib.gui.texture.GuiTextureGroup;
-import com.lowdragmc.lowdraglib.gui.widget.Widget;
-import com.lowdragmc.lowdraglib.gui.widget.WidgetGroup;
-
 import net.minecraft.MethodsReturnNonnullByDefault;
 import net.minecraft.world.item.ItemStack;
 
@@ -43,40 +37,24 @@ public abstract class FilterHandler<T, F extends Filter<T, F>> implements ISyncM
 
     private @Nullable F filter;
     private @Nullable CustomItemStackHandler filterSlot;
-    private @Nullable WidgetGroup filterGroup;
 
     private @NotNull Consumer<F> onFilterLoaded = (filter) -> {};
-    private @NotNull Consumer<F> onFilterRemoved = (filter) -> {};
+    private @NotNull Runnable onFilterRemoved = () -> {};
     private @NotNull Consumer<F> onFilterUpdated = (filter) -> {};
 
     public FilterHandler(ISyncManaged container) {
         this.container = container;
     }
 
-    protected abstract F loadFilter(ItemStack filterItem);
+    public abstract F loadFilter(ItemStack filterItem);
 
     protected abstract F getEmptyFilter();
 
-    protected abstract boolean canInsertFilterItem(ItemStack itemStack);
-
     //////////////////////////////////
     // ***** PUBLIC API ******//
     //////////////////////////////////
 
-    public Widget createFilterSlotUI(int xPos, int yPos) {
-        return new SlotWidget(getFilterSlot(), 0, xPos, yPos)
-                .setChangeListener(this::updateFilter)
-                .setBackgroundTexture(new GuiTextureGroup(GuiTextures.SLOT, GuiTextures.FILTER_SLOT_OVERLAY));
-    }
-
-    public Widget createFilterConfigUI(int xPos, int yPos, int width, int height) {
-        this.filterGroup = new WidgetGroup(xPos, yPos, width, height);
-        if (!this.filterItem.isEmpty()) {
-            this.filterGroup.addWidget(getFilter().openConfigurator(0, 0));
-        }
-
-        return this.filterGroup;
-    }
+    public abstract boolean canInsertFilterItem(ItemStack itemStack);
 
     public boolean isFilterPresent() {
         return filter != null || !filterItem.isEmpty();
@@ -103,7 +81,7 @@ public FilterHandler<T, F> onFilterLoaded(Consumer<F> onFilterLoaded) {
         return this;
     }
 
-    public FilterHandler<T, F> onFilterRemoved(Consumer<F> onFilterRemoved) {
+    public FilterHandler<T, F> onFilterRemoved(Runnable onFilterRemoved) {
         this.onFilterRemoved = onFilterRemoved;
         return this;
     }
@@ -117,7 +95,7 @@ public FilterHandler<T, F> onFilterUpdated(Consumer<F> onFilterUpdated) {
     // ***** FILTER HANDLING ******//
     ///////////////////////////////////////
 
-    private CustomItemStackHandler getFilterSlot() {
+    public CustomItemStackHandler getFilterSlot() {
         if (this.filterSlot == null) {
             this.filterSlot = new CustomItemStackHandler(this.filterItem) {
 
@@ -152,7 +130,7 @@ private void updateFilter() {
 
         if (this.filter != null) {
             this.filter = null;
-            this.onFilterRemoved.accept(this.filter);
+            this.onFilterRemoved.run();
         }
 
         loadFilterFromItem();
@@ -172,18 +150,6 @@ private void loadFilterFromItem() {
             }
             this.onFilterLoaded.accept(this.filter);
         }
-        updateFilterGroupUI();
-    }
-
-    private void updateFilterGroupUI() {
-        if (this.filterGroup == null)
-            return;
-
-        this.filterGroup.clearAllWidgets();
-
-        if (!this.filterItem.isEmpty() && this.filter != null) {
-            this.filterGroup.addWidget(this.filter.openConfigurator(0, 0));
-        }
     }
 
     @Override
diff --git a/src/main/java/com/gregtechceu/gtceu/api/cover/filter/FilterHandlers.java b/src/main/java/com/gregtechceu/gtceu/api/cover/filter/FilterHandlers.java
index cb269e0aa23..c48c9f4d0e8 100644
--- a/src/main/java/com/gregtechceu/gtceu/api/cover/filter/FilterHandlers.java
+++ b/src/main/java/com/gregtechceu/gtceu/api/cover/filter/FilterHandlers.java
@@ -2,16 +2,21 @@
 
 import com.gregtechceu.gtceu.api.sync_system.ISyncManaged;
 
+import net.minecraft.MethodsReturnNonnullByDefault;
 import net.minecraft.world.item.ItemStack;
 import net.minecraftforge.fluids.FluidStack;
 
+import javax.annotation.ParametersAreNonnullByDefault;
+
+@ParametersAreNonnullByDefault
+@MethodsReturnNonnullByDefault
 public interface FilterHandlers {
 
     static FilterHandler<ItemStack, ItemFilter> item(ISyncManaged container) {
         return new FilterHandler<>(container) {
 
             @Override
-            protected ItemFilter loadFilter(ItemStack filterItem) {
+            public ItemFilter loadFilter(ItemStack filterItem) {
                 return ItemFilter.loadFilter(filterItem);
             }
 
@@ -21,7 +26,7 @@ protected ItemFilter getEmptyFilter() {
             }
 
             @Override
-            protected boolean canInsertFilterItem(ItemStack itemStack) {
+            public boolean canInsertFilterItem(ItemStack itemStack) {
                 return ItemFilter.FILTERS.containsKey(itemStack.getItem());
             }
         };
@@ -31,7 +36,7 @@ static FilterHandler<FluidStack, FluidFilter> fluid(ISyncManaged container) {
         return new FilterHandler<>(container) {
 
             @Override
-            protected FluidFilter loadFilter(ItemStack filterItem) {
+            public FluidFilter loadFilter(ItemStack filterItem) {
                 return FluidFilter.loadFilter(filterItem);
             }
 
@@ -41,7 +46,7 @@ protected FluidFilter getEmptyFilter() {
             }
 
             @Override
-            protected boolean canInsertFilterItem(ItemStack itemStack) {
+            public boolean canInsertFilterItem(ItemStack itemStack) {
                 return FluidFilter.FILTERS.containsKey(itemStack.getItem());
             }
         };
diff --git a/src/main/java/com/gregtechceu/gtceu/api/cover/filter/FluidFilter.java b/src/main/java/com/gregtechceu/gtceu/api/cover/filter/FluidFilter.java
index 9a8a09fb68e..eb2c1191c4e 100644
--- a/src/main/java/com/gregtechceu/gtceu/api/cover/filter/FluidFilter.java
+++ b/src/main/java/com/gregtechceu/gtceu/api/cover/filter/FluidFilter.java
@@ -1,12 +1,14 @@
 package com.gregtechceu.gtceu.api.cover.filter;
 
-import com.lowdragmc.lowdraglib.gui.widget.WidgetGroup;
-
 import net.minecraft.nbt.CompoundTag;
 import net.minecraft.world.item.ItemStack;
 import net.minecraft.world.level.ItemLike;
 import net.minecraftforge.fluids.FluidStack;
 
+import brachy.modularui.factory.GuiData;
+import brachy.modularui.screen.ModularPanel;
+import brachy.modularui.screen.UISettings;
+import brachy.modularui.value.sync.PanelSyncManager;
 import org.apache.commons.lang3.NotImplementedException;
 
 import java.util.HashMap;
@@ -54,8 +56,8 @@ public int testFluidAmount(FluidStack fluidStack) {
         }
 
         @Override
-        public WidgetGroup openConfigurator(int x, int y) {
-            throw new NotImplementedException("Not available for empty fluid filter");
+        public ModularPanel<?> getPanel(GuiData data, PanelSyncManager syncManager, UISettings settings) {
+            return null;
         }
 
         @Override
diff --git a/src/main/java/com/gregtechceu/gtceu/api/cover/filter/ItemFilter.java b/src/main/java/com/gregtechceu/gtceu/api/cover/filter/ItemFilter.java
index 73e24344dc7..a149cd64ab3 100644
--- a/src/main/java/com/gregtechceu/gtceu/api/cover/filter/ItemFilter.java
+++ b/src/main/java/com/gregtechceu/gtceu/api/cover/filter/ItemFilter.java
@@ -1,11 +1,13 @@
 package com.gregtechceu.gtceu.api.cover.filter;
 
-import com.lowdragmc.lowdraglib.gui.widget.WidgetGroup;
-
 import net.minecraft.nbt.CompoundTag;
 import net.minecraft.world.item.ItemStack;
 import net.minecraft.world.level.ItemLike;
 
+import brachy.modularui.factory.GuiData;
+import brachy.modularui.screen.ModularPanel;
+import brachy.modularui.screen.UISettings;
+import brachy.modularui.value.sync.PanelSyncManager;
 import org.apache.commons.lang3.NotImplementedException;
 
 import java.util.HashMap;
@@ -53,8 +55,8 @@ public boolean test(ItemStack itemStack) {
         }
 
         @Override
-        public WidgetGroup openConfigurator(int x, int y) {
-            throw new NotImplementedException("Not available for empty item filter");
+        public ModularPanel<?> getPanel(GuiData data, PanelSyncManager syncManager, UISettings settings) {
+            return null;
         }
 
         @Override
diff --git a/src/main/java/com/gregtechceu/gtceu/api/cover/filter/SimpleFluidFilter.java b/src/main/java/com/gregtechceu/gtceu/api/cover/filter/SimpleFluidFilter.java
index d2c6610a644..d32f3afba1e 100644
--- a/src/main/java/com/gregtechceu/gtceu/api/cover/filter/SimpleFluidFilter.java
+++ b/src/main/java/com/gregtechceu/gtceu/api/cover/filter/SimpleFluidFilter.java
@@ -1,11 +1,9 @@
 package com.gregtechceu.gtceu.api.cover.filter;
 
-import com.gregtechceu.gtceu.api.gui.GuiTextures;
-import com.gregtechceu.gtceu.api.gui.widget.ScrollablePhantomFluidWidget;
-import com.gregtechceu.gtceu.api.gui.widget.ToggleButtonWidget;
 import com.gregtechceu.gtceu.api.transfer.fluid.CustomFluidTank;
-
-import com.lowdragmc.lowdraglib.gui.widget.WidgetGroup;
+import com.gregtechceu.gtceu.common.data.GTItems;
+import com.gregtechceu.gtceu.common.mui.GTGuiTextures;
+import com.gregtechceu.gtceu.common.mui.GTMuiWidgets;
 
 import net.minecraft.MethodsReturnNonnullByDefault;
 import net.minecraft.nbt.CompoundTag;
@@ -14,6 +12,18 @@
 import net.minecraft.world.item.ItemStack;
 import net.minecraftforge.fluids.FluidStack;
 
+import brachy.modularui.factory.GuiData;
+import brachy.modularui.screen.ModularPanel;
+import brachy.modularui.screen.UISettings;
+import brachy.modularui.value.sync.BooleanSyncValue;
+import brachy.modularui.value.sync.FluidSlotSyncHandler;
+import brachy.modularui.value.sync.PanelSyncManager;
+import brachy.modularui.widgets.Dialog;
+import brachy.modularui.widgets.SlotGroupWidget;
+import brachy.modularui.widgets.ToggleButton;
+import brachy.modularui.widgets.layout.Flow;
+import brachy.modularui.widgets.layout.Grid;
+import brachy.modularui.widgets.slot.FluidSlot;
 import lombok.Getter;
 
 import java.util.Arrays;
@@ -38,9 +48,17 @@ public class SimpleFluidFilter implements FluidFilter {
     @Getter
     protected int maxStackSize = 1;
 
-    private CustomFluidTank[] fluidStorageSlots = new CustomFluidTank[9];
+    private final CustomFluidTank[] fluidStorageSlots = new CustomFluidTank[9];
 
     protected SimpleFluidFilter() {
+        for (int i = 0; i < 9; i++) {
+            int finalI = i;
+            fluidStorageSlots[i] = new CustomFluidTank(64000);
+            fluidStorageSlots[i].setOnContentsChanged(() -> {
+                matches[finalI] = fluidStorageSlots[finalI].getFluid();
+                onUpdated.accept(this);
+            });
+        }
         Arrays.fill(matches, FluidStack.EMPTY);
     }
 
@@ -56,6 +74,7 @@ private static SimpleFluidFilter loadFilter(CompoundTag tag, Consumer<FluidFilte
         var list = tag.getList("matches", Tag.TAG_COMPOUND);
         for (int i = 0; i < list.size(); i++) {
             handler.matches[i] = FluidStack.loadFluidStackFromNBT((CompoundTag) list.get(i));
+            handler.fluidStorageSlots[i].setFluid(handler.matches[i]);
         }
         return handler;
     }
@@ -98,46 +117,39 @@ public void setIgnoreNbt(boolean ingoreNbt) {
         onUpdated.accept(this);
     }
 
-    public WidgetGroup openConfigurator(int x, int y) {
-        WidgetGroup group = new WidgetGroup(x, y, 18 * 3 + 25, 18 * 3); // 80 55
-        fluidStorageSlots = new CustomFluidTank[9];
-        for (int i = 0; i < 3; i++) {
-            for (int j = 0; j < 3; j++) {
-                final int index = i * 3 + j;
-
-                fluidStorageSlots[index] = new CustomFluidTank(maxStackSize);
-                fluidStorageSlots[index].setFluid(matches[index]);
-
-                var tank = new ScrollablePhantomFluidWidget(fluidStorageSlots[index], 0, i * 18, j * 18, 18, 18,
-                        () -> fluidStorageSlots[index].getFluid(),
-                        (fluid) -> fluidStorageSlots[index].setFluid(fluid)) {
-
-                    @Override
-                    public void updateScreen() {
-                        super.updateScreen();
-                        setShowAmount(maxStackSize > 1L);
-                    }
-
-                    @Override
-                    public void detectAndSendChanges() {
-                        super.detectAndSendChanges();
-                        setShowAmount(maxStackSize > 1L);
-                    }
-                };
-
-                tank.setChangeListener(() -> {
-                    matches[index] = fluidStorageSlots[index].getFluidInTank(0);
-                    onUpdated.accept(this);
-                }).setBackground(GuiTextures.SLOT);
-
-                group.addWidget(tank);
-            }
+    @Override
+    public ModularPanel<?> getPanel(GuiData data, PanelSyncManager syncManager, UISettings settings) {
+        for (int i = 0; i < 9; i++) {
+            syncManager.syncValue("filter_slot_" + i,
+                    new FluidSlotSyncHandler(fluidStorageSlots[i]).controlsAmount(true).phantom(true));
         }
-        group.addWidget(new ToggleButtonWidget(18 * 3 + 5, 0, 20, 20,
-                GuiTextures.BUTTON_BLACKLIST, this::isBlackList, this::setBlackList));
-        group.addWidget(new ToggleButtonWidget(18 * 3 + 5, 20, 20, 20,
-                GuiTextures.BUTTON_FILTER_NBT, this::isIgnoreNbt, this::setIgnoreNbt));
-        return group;
+
+        Grid filterGrid = new Grid()
+                .coverChildren()
+                .mapTo(3, 9, i -> new FluidSlot().syncHandler("filter_slot_" + i));
+
+        BooleanSyncValue blacklist = new BooleanSyncValue(this::isBlackList, this::setBlackList);
+        syncManager.syncValue("blacklist", blacklist);
+
+        BooleanSyncValue ignoreNBT = new BooleanSyncValue(this::isIgnoreNbt, this::setIgnoreNbt);
+        syncManager.syncValue("ignoreNBT", ignoreNBT);
+
+        Flow filterConfigButtons = Flow.col()
+                .coverChildren()
+                .child(new ToggleButton().stateBackground(GTGuiTextures.BUTTON_BLACKLIST).syncHandler("blacklist"))
+                .child(new ToggleButton().stateBackground(GTGuiTextures.BUTTON_IGNORE_NBT).syncHandler("ignoreNBT"));
+
+        return new Dialog<>("simple_fluid_filter")
+                .disablePanelsBelow(false)
+                .draggable(true)
+                .closeOnOutOfBoundsClick(true)
+                .child(GTMuiWidgets.createTitleBar(GTItems.FLUID_FILTER.asStack(), 176, GTGuiTextures.BACKGROUND))
+                .child(Flow.row()
+                        .top(10)
+                        .coverChildrenHeight()
+                        .child(filterGrid.horizontalCenter())
+                        .child(filterConfigButtons.marginLeft(118)))
+                .child(SlotGroupWidget.playerInventory(false).left(7).bottom(7));
     }
 
     @Override
diff --git a/src/main/java/com/gregtechceu/gtceu/api/cover/filter/SimpleItemFilter.java b/src/main/java/com/gregtechceu/gtceu/api/cover/filter/SimpleItemFilter.java
index 408a6656687..b187f36ec1b 100644
--- a/src/main/java/com/gregtechceu/gtceu/api/cover/filter/SimpleItemFilter.java
+++ b/src/main/java/com/gregtechceu/gtceu/api/cover/filter/SimpleItemFilter.java
@@ -1,20 +1,32 @@
 package com.gregtechceu.gtceu.api.cover.filter;
 
-import com.gregtechceu.gtceu.api.gui.GuiTextures;
-import com.gregtechceu.gtceu.api.gui.widget.PhantomSlotWidget;
-import com.gregtechceu.gtceu.api.gui.widget.ToggleButtonWidget;
 import com.gregtechceu.gtceu.api.transfer.item.CustomItemStackHandler;
+import com.gregtechceu.gtceu.common.data.GTItems;
+import com.gregtechceu.gtceu.common.mui.GTGuiTextures;
+import com.gregtechceu.gtceu.common.mui.GTMuiWidgets;
 import com.gregtechceu.gtceu.utils.GTUtil;
 
-import com.lowdragmc.lowdraglib.gui.widget.WidgetGroup;
-
 import net.minecraft.MethodsReturnNonnullByDefault;
 import net.minecraft.nbt.CompoundTag;
 import net.minecraft.nbt.ListTag;
 import net.minecraft.nbt.Tag;
 import net.minecraft.world.item.ItemStack;
 
+import brachy.modularui.factory.GuiData;
+import brachy.modularui.screen.ModularPanel;
+import brachy.modularui.screen.UISettings;
+import brachy.modularui.value.sync.BooleanSyncValue;
+import brachy.modularui.value.sync.PanelSyncManager;
+import brachy.modularui.value.sync.PhantomItemSlotSyncHandler;
+import brachy.modularui.widgets.Dialog;
+import brachy.modularui.widgets.SlotGroupWidget;
+import brachy.modularui.widgets.ToggleButton;
+import brachy.modularui.widgets.layout.Flow;
+import brachy.modularui.widgets.layout.Grid;
+import brachy.modularui.widgets.slot.ModularSlot;
+import brachy.modularui.widgets.slot.PhantomItemSlot;
 import lombok.Getter;
+import org.jetbrains.annotations.NotNull;
 
 import java.util.Arrays;
 import java.util.function.Consumer;
@@ -97,42 +109,87 @@ public void setIgnoreNbt(boolean ingoreNbt) {
         onUpdated.accept(this);
     }
 
-    public WidgetGroup openConfigurator(int x, int y) {
-        WidgetGroup group = new WidgetGroup(x, y, 18 * 3 + 25, 18 * 3); // 80 55
-        for (int i = 0; i < 3; i++) {
-            for (int j = 0; j < 3; j++) {
-                final int index = i * 3 + j;
+    @Override
+    public ModularPanel<?> getPanel(GuiData data, PanelSyncManager syncManager, UISettings settings) {
+        FilterItemStackHandler handler = new FilterItemStackHandler(matches, this);
+
+        Grid filterGrid = new Grid()
+                .coverChildren()
+                .mapTo(3, 9, i -> new PhantomItemSlot()
+                        .size(16)
+                        .syncHandler(new PhantomItemSlotSyncHandler(new ModularSlot(handler, i)
+                                .changeListener((stack, amount, client, init) -> {
+                                    handler.setStackInSlot(i, stack);
+                                }).ignoreMaxStackSize(true).accessibility(true, false))));
+
+        BooleanSyncValue blacklist = new BooleanSyncValue(this::isBlackList, this::setBlackList);
+        syncManager.syncValue("blacklist", blacklist);
+
+        BooleanSyncValue ignoreNBT = new BooleanSyncValue(this::isIgnoreNbt, this::setIgnoreNbt);
+        syncManager.syncValue("ignoreNBT", ignoreNBT);
+
+        Flow filterConfigButtons = Flow.col()
+                .coverChildren()
+                .child(new ToggleButton().stateBackground(GTGuiTextures.BUTTON_BLACKLIST).syncHandler("blacklist"))
+                .child(new ToggleButton().stateBackground(GTGuiTextures.BUTTON_IGNORE_NBT).syncHandler("ignoreNBT"));
+
+        return new Dialog<>("simple_item_filter")
+                .disablePanelsBelow(false)
+                .draggable(true)
+                .closeOnOutOfBoundsClick(true)
+                .child(GTMuiWidgets.createTitleBar(GTItems.ITEM_FILTER.asStack(), 176, GTGuiTextures.BACKGROUND))
+                .child(Flow.row()
+                        .top(10)
+                        .coverChildrenHeight()
+                        .child(filterGrid.horizontalCenter())
+                        .child(filterConfigButtons.marginLeft(118)))
+                .child(SlotGroupWidget.playerInventory(false).left(7).bottom(7));
+    }
+
+    public static class FilterItemStackHandler extends CustomItemStackHandler {
 
-                var handler = new CustomItemStackHandler(matches[index]);
+        private final ItemStack[] matches;
+        private final SimpleItemFilter filter;
 
-                var slot = new PhantomSlotWidget(handler, 0, i * 18, j * 18) {
+        public FilterItemStackHandler(SimpleItemFilter filter) {
+            this(filter.matches, filter);
+        }
 
-                    @Override
-                    public void updateScreen() {
-                        super.updateScreen();
-                        setMaxStackSize(maxStackSize);
-                    }
+        public FilterItemStackHandler(ItemStack[] matches, SimpleItemFilter simpleItemFilter) {
+            super(matches.length);
+            this.matches = matches;
+            this.filter = simpleItemFilter;
+        }
 
-                    @Override
-                    public void detectAndSendChanges() {
-                        super.detectAndSendChanges();
-                        setMaxStackSize(maxStackSize);
-                    }
-                };
+        @Override
+        public @NotNull ItemStack getStackInSlot(int slot) {
+            return matches[slot];
+        }
 
-                slot.setChangeListener(() -> {
-                    matches[index] = handler.getStackInSlot(0);
-                    onUpdated.accept(this);
-                }).setBackground(GuiTextures.SLOT);
+        @Override
+        protected int getStackLimit(int slot, @NotNull ItemStack stack) {
+            return 1;
+        }
 
-                group.addWidget(slot);
+        @Override
+        public @NotNull ItemStack extractItem(int slot, int amount, boolean simulate) {
+            if (amount >= matches[slot].getCount()) {
+                matches[slot] = ItemStack.EMPTY;
             }
+            return matches[slot];
+        }
+
+        @Override
+        public @NotNull ItemStack insertItem(int slot, @NotNull ItemStack stack, boolean simulate) {
+            return stack;
+        }
+
+        @Override
+        public void setStackInSlot(int slot, @NotNull ItemStack stack) {
+            super.setStackInSlot(slot, stack);
+            matches[slot] = stack.copyWithCount(1);
+            filter.onUpdated.accept(filter);
         }
-        group.addWidget(new ToggleButtonWidget(18 * 3 + 5, 0, 20, 20,
-                GuiTextures.BUTTON_BLACKLIST, this::isBlackList, this::setBlackList));
-        group.addWidget(new ToggleButtonWidget(18 * 3 + 5, 20, 20, 20,
-                GuiTextures.BUTTON_FILTER_NBT, this::isIgnoreNbt, this::setIgnoreNbt));
-        return group;
     }
 
     @Override
diff --git a/src/main/java/com/gregtechceu/gtceu/api/cover/filter/SmartItemFilter.java b/src/main/java/com/gregtechceu/gtceu/api/cover/filter/SmartItemFilter.java
index c26624f1c2d..4fb3ecb820d 100644
--- a/src/main/java/com/gregtechceu/gtceu/api/cover/filter/SmartItemFilter.java
+++ b/src/main/java/com/gregtechceu/gtceu/api/cover/filter/SmartItemFilter.java
@@ -1,22 +1,34 @@
 package com.gregtechceu.gtceu.api.cover.filter;
 
+import com.gregtechceu.gtceu.GTCEu;
 import com.gregtechceu.gtceu.api.capability.recipe.ItemRecipeCapability;
-import com.gregtechceu.gtceu.api.gui.widget.EnumSelectorWidget;
 import com.gregtechceu.gtceu.api.recipe.GTRecipeType;
 import com.gregtechceu.gtceu.api.recipe.content.Content;
+import com.gregtechceu.gtceu.common.data.GTItems;
 import com.gregtechceu.gtceu.common.data.GTRecipeTypes;
+import com.gregtechceu.gtceu.common.mui.GTGuiTextures;
+import com.gregtechceu.gtceu.common.mui.GTMuiWidgets;
 import com.gregtechceu.gtceu.utils.ItemStackHashStrategy;
 
-import com.lowdragmc.lowdraglib.gui.texture.IGuiTexture;
-import com.lowdragmc.lowdraglib.gui.texture.ResourceTexture;
-import com.lowdragmc.lowdraglib.gui.widget.WidgetGroup;
-
 import net.minecraft.MethodsReturnNonnullByDefault;
 import net.minecraft.nbt.CompoundTag;
+import net.minecraft.network.chat.Component;
 import net.minecraft.world.item.ItemStack;
 
+import brachy.modularui.api.drawable.IKey;
+import brachy.modularui.drawable.ColorType;
+import brachy.modularui.drawable.UITexture;
+import brachy.modularui.factory.GuiData;
+import brachy.modularui.screen.ModularPanel;
+import brachy.modularui.screen.UISettings;
+import brachy.modularui.value.sync.EnumSyncValue;
+import brachy.modularui.value.sync.PanelSyncManager;
+import brachy.modularui.widgets.Dialog;
+import brachy.modularui.widgets.SlotGroupWidget;
 import it.unimi.dsi.fastutil.objects.Object2IntOpenCustomHashMap;
+import lombok.Getter;
 
+import java.util.Arrays;
 import java.util.Collections;
 import java.util.function.Consumer;
 
@@ -25,6 +37,7 @@ public class SmartItemFilter implements ItemFilter {
     protected Consumer<ItemFilter> itemWriter = filter -> {};
     protected Consumer<ItemFilter> onUpdated = filter -> itemWriter.accept(filter);
 
+    @Getter
     private SmartFilteringMode filterMode = SmartFilteringMode.ELECTROLYZER;
 
     protected SmartItemFilter() {}
@@ -69,11 +82,23 @@ private void setFilterMode(SmartFilteringMode filterMode) {
     }
 
     @Override
-    public WidgetGroup openConfigurator(int x, int y) {
-        WidgetGroup group = new WidgetGroup(x, y, 18 * 3 + 25, 18 * 3);
-        group.addWidget(new EnumSelectorWidget<>(16, 8, 32, 32,
-                SmartFilteringMode.VALUES, filterMode, this::setFilterMode));
-        return group;
+    public ModularPanel<?> getPanel(GuiData data, PanelSyncManager syncManager, UISettings settings) {
+        EnumSyncValue<SmartFilteringMode> mode = new EnumSyncValue<>(SmartFilteringMode.class,
+                this::getFilterMode, this::setFilterMode);
+
+        syncManager.syncValue("mode", mode);
+
+        return new Dialog<>("smart_item_filter")
+                .disablePanelsBelow(false)
+                .draggable(true)
+                .closeOnOutOfBoundsClick(true)
+                .child(GTMuiWidgets.createTitleBar(GTItems.SMART_ITEM_FILTER.asStack(), 176, GTGuiTextures.BACKGROUND))
+                .child(new GTMuiWidgets.EnumRowBuilder<>(SmartFilteringMode.class)
+                        .value(mode)
+                        .overlay(16, SmartFilteringMode.getTextures())
+                        .lang(IKey.dynamic(() -> Component.translatable(filterMode.localeName)))
+                        .build().margin(7))
+                .child(SlotGroupWidget.playerInventory(false).left(7).bottom(7));
     }
 
     @Override
@@ -112,7 +137,7 @@ public void setModeFromMachine(String machineName) {
     }
 
     @MethodsReturnNonnullByDefault
-    private enum SmartFilteringMode implements EnumSelectorWidget.SelectableEnum {
+    private enum SmartFilteringMode {
 
         ELECTROLYZER("electrolyzer", GTRecipeTypes.ELECTROLYZER_RECIPES),
         CENTRIFUGE("centrifuge", GTRecipeTypes.CENTRIFUGE_RECIPES),
@@ -129,14 +154,15 @@ private enum SmartFilteringMode implements EnumSelectorWidget.SelectableEnum {
             this.recipeType = type;
         }
 
-        @Override
         public String getTooltip() {
             return "cover.item_smart_filter.filtering_mode." + localeName;
         }
 
-        @Override
-        public IGuiTexture getIcon() {
-            return new ResourceTexture("gtceu:textures/block/machines/" + localeName + "/overlay_front.png");
+        public static UITexture[] getTextures() {
+            return Arrays.stream(VALUES)
+                    .map(v -> UITexture.fullImage(GTCEu.MOD_ID,
+                            "textures/block/machines/" + v.localeName + "/overlay_front.png", ColorType.DEFAULT))
+                    .toArray(UITexture[]::new);
         }
     }
 }
diff --git a/src/main/java/com/gregtechceu/gtceu/api/cover/filter/TagFilter.java b/src/main/java/com/gregtechceu/gtceu/api/cover/filter/TagFilter.java
index 712f8be4a57..83aace338fa 100644
--- a/src/main/java/com/gregtechceu/gtceu/api/cover/filter/TagFilter.java
+++ b/src/main/java/com/gregtechceu/gtceu/api/cover/filter/TagFilter.java
@@ -1,32 +1,30 @@
 package com.gregtechceu.gtceu.api.cover.filter;
 
-import com.gregtechceu.gtceu.api.gui.GuiTextures;
-import com.gregtechceu.gtceu.data.lang.LangHandler;
+import com.gregtechceu.gtceu.common.mui.GTGuiTextures;
+import com.gregtechceu.gtceu.common.mui.GTMuiWidgets;
 import com.gregtechceu.gtceu.utils.TagExprFilter;
 
-import com.lowdragmc.lowdraglib.gui.widget.ImageWidget;
-import com.lowdragmc.lowdraglib.gui.widget.TextFieldWidget;
-import com.lowdragmc.lowdraglib.gui.widget.WidgetGroup;
-
 import net.minecraft.nbt.CompoundTag;
-import net.minecraft.network.chat.MutableComponent;
-
+import net.minecraft.world.item.ItemStack;
+
+import brachy.modularui.factory.GuiData;
+import brachy.modularui.screen.ModularPanel;
+import brachy.modularui.screen.RichTooltip;
+import brachy.modularui.screen.UISettings;
+import brachy.modularui.value.sync.PanelSyncManager;
+import brachy.modularui.value.sync.StringSyncValue;
+import brachy.modularui.widgets.Dialog;
+import brachy.modularui.widgets.SlotGroupWidget;
+import brachy.modularui.widgets.layout.Flow;
+import brachy.modularui.widgets.textfield.TextFieldWidget;
 import lombok.Getter;
 
 import java.util.function.Consumer;
-import java.util.regex.Pattern;
 
 public abstract class TagFilter<T, S extends Filter<T, S>> implements Filter<T, S> {
 
-    private static final Pattern DOUBLE_WILDCARD = Pattern.compile("\\*{2,}");
-    private static final Pattern DOUBLE_AND = Pattern.compile("&{2,}");
-    private static final Pattern DOUBLE_OR = Pattern.compile("\\|{2,}");
-    private static final Pattern DOUBLE_NOT = Pattern.compile("!{2,}");
-    private static final Pattern DOUBLE_XOR = Pattern.compile("\\^{2,}");
-    private static final Pattern DOUBLE_SPACE = Pattern.compile(" {2,}");
-
     @Getter
-    protected String oreDictFilterExpression = "";
+    protected String filterString = "";
 
     protected Consumer<S> itemWriter = filter -> {};
     protected Consumer<S> onUpdated = filter -> itemWriter.accept(filter);
@@ -37,7 +35,7 @@ protected TagFilter() {}
 
     @Override
     public boolean isBlank() {
-        return oreDictFilterExpression.isBlank();
+        return filterString.isBlank();
     }
 
     public CompoundTag saveFilter() {
@@ -45,78 +43,34 @@ public CompoundTag saveFilter() {
             return null;
         }
         var tag = new CompoundTag();
-        tag.putString("oreDict", oreDictFilterExpression);
+        tag.putString("oreDict", filterString);
         return tag;
     }
 
-    public void setOreDict(String oreDict) {
-        this.oreDictFilterExpression = oreDict;
-        matchExpr = TagExprFilter.parseExpression(oreDictFilterExpression);
+    public void setFilterString(String filterString) {
+        this.filterString = filterString;
+        matchExpr = TagExprFilter.parseExpression(filterString);
         onUpdated.accept((S) this);
     }
 
-    public WidgetGroup openConfigurator(int x, int y) {
-        WidgetGroup group = new WidgetGroup(x, y, 18 * 3 + 25, 18 * 3); // 80 55
-        group.addWidget(new ImageWidget(0, 0, 20, 20, GuiTextures.INFO_ICON)
-                .setHoverTooltips(
-                        LangHandler.getMultiLang("cover.tag_filter.info").toArray(new MutableComponent[0])));
-        group.addWidget(new TextFieldWidget(0, 29, 18 * 3 + 25, 12, () -> oreDictFilterExpression, this::setOreDict)
-                .setMaxStringLength(64)
-                .setValidator(input -> {
-                    // remove all operators that are double
-                    input = DOUBLE_WILDCARD.matcher(input).replaceAll("*");
-                    input = DOUBLE_AND.matcher(input).replaceAll("&");
-                    input = DOUBLE_OR.matcher(input).replaceAll("|");
-                    input = DOUBLE_NOT.matcher(input).replaceAll("!");
-                    input = DOUBLE_XOR.matcher(input).replaceAll("^");
-                    input = DOUBLE_SPACE.matcher(input).replaceAll(" ");
-                    // move ( and ) so it doesn't create invalid expressions f.e. xxx (& yyy) => xxx & (yyy)
-                    // append or prepend ( and ) if the amount is not equal
-                    StringBuilder builder = new StringBuilder();
-                    int unclosed = 0;
-                    char last = ' ';
-                    for (int i = 0; i < input.length(); i++) {
-                        char c = input.charAt(i);
-                        if (c == ' ') {
-                            if (last != '(')
-                                builder.append(" ");
-                            continue;
-                        }
-                        if (c == '(')
-                            unclosed++;
-                        else if (c == ')') {
-                            unclosed--;
-                            if (last == '&' || last == '|' || last == '^') {
-                                int l = builder.lastIndexOf(" " + last);
-                                int l2 = builder.lastIndexOf(String.valueOf(last));
-                                builder.insert(l == l2 - 1 ? l : l2, ")");
-                                continue;
-                            }
-                            if (i > 0 && builder.charAt(builder.length() - 1) == ' ') {
-                                builder.deleteCharAt(builder.length() - 1);
-                            }
-                        } else if ((c == '&' || c == '|' || c == '^') && last == '(') {
-                            builder.deleteCharAt(builder.lastIndexOf("("));
-                            builder.append(c).append(" (");
-                            continue;
-                        }
-
-                        builder.append(c);
-                        last = c;
-                    }
-                    if (unclosed > 0) {
-                        builder.append(")".repeat(unclosed));
-                    } else if (unclosed < 0) {
-                        unclosed = -unclosed;
-                        for (int i = 0; i < unclosed; i++) {
-                            builder.insert(0, "(");
-                        }
-                    }
-                    input = builder.toString();
-                    input = input.replaceAll(" {2,}", " ");
-                    return input;
-                }));
-        return group;
+    protected abstract ItemStack getFilterItem();
+
+    @Override
+    public ModularPanel<?> getPanel(GuiData data, PanelSyncManager syncManager, UISettings settings) {
+        StringSyncValue filterString = new StringSyncValue(this::getFilterString, this::setFilterString);
+        RichTooltip infoTooltip = new RichTooltip().add("cover.tag_filter.info");
+
+        var inputRow = Flow.row().margin(7).coverChildren().horizontalCenter()
+                .child(new TextFieldWidget().width(140).value(filterString))
+                .child(GTGuiTextures.INFO.asWidget().tooltip(infoTooltip));
+
+        return new Dialog<>("tag_filter")
+                .disablePanelsBelow(false)
+                .draggable(true)
+                .closeOnOutOfBoundsClick(true)
+                .child(GTMuiWidgets.createTitleBar(getFilterItem(), 176, GTGuiTextures.BACKGROUND))
+                .child(inputRow)
+                .child(SlotGroupWidget.playerInventory(false).left(7).bottom(7));
     }
 
     @Override
diff --git a/src/main/java/com/gregtechceu/gtceu/api/cover/filter/TagFluidFilter.java b/src/main/java/com/gregtechceu/gtceu/api/cover/filter/TagFluidFilter.java
index ff54bd91eb0..014a14e0898 100644
--- a/src/main/java/com/gregtechceu/gtceu/api/cover/filter/TagFluidFilter.java
+++ b/src/main/java/com/gregtechceu/gtceu/api/cover/filter/TagFluidFilter.java
@@ -1,5 +1,6 @@
 package com.gregtechceu.gtceu.api.cover.filter;
 
+import com.gregtechceu.gtceu.common.data.GTItems;
 import com.gregtechceu.gtceu.utils.TagExprFilter;
 
 import net.minecraft.nbt.CompoundTag;
@@ -27,21 +28,26 @@ public static TagFluidFilter loadFilter(ItemStack itemStack) {
     private static TagFluidFilter loadFilter(CompoundTag tag, Consumer<FluidFilter> itemWriter) {
         var handler = new TagFluidFilter();
         handler.itemWriter = itemWriter;
-        handler.oreDictFilterExpression = tag.getString("oreDict");
+        handler.filterString = tag.getString("oreDict");
         handler.matchExpr = null;
         handler.cache.clear();
-        handler.matchExpr = TagExprFilter.parseExpression(handler.oreDictFilterExpression);
+        handler.matchExpr = TagExprFilter.parseExpression(handler.filterString);
         return handler;
     }
 
-    public void setOreDict(String oreDict) {
+    public void setFilterString(String oreDict) {
         cache.clear();
-        super.setOreDict(oreDict);
+        super.setFilterString(oreDict);
+    }
+
+    @Override
+    protected ItemStack getFilterItem() {
+        return GTItems.TAG_FLUID_FILTER.asStack();
     }
 
     @Override
     public boolean test(FluidStack fluidStack) {
-        if (oreDictFilterExpression.isEmpty()) return false;
+        if (filterString.isEmpty()) return false;
         if (cache.containsKey(fluidStack.getFluid())) return cache.getOrDefault(fluidStack.getFluid(), false);
         if (TagExprFilter.tagsMatch(matchExpr, fluidStack)) {
             cache.put(fluidStack.getFluid(), true);
diff --git a/src/main/java/com/gregtechceu/gtceu/api/cover/filter/TagItemFilter.java b/src/main/java/com/gregtechceu/gtceu/api/cover/filter/TagItemFilter.java
index 5018590726a..e33eca3e7df 100644
--- a/src/main/java/com/gregtechceu/gtceu/api/cover/filter/TagItemFilter.java
+++ b/src/main/java/com/gregtechceu/gtceu/api/cover/filter/TagItemFilter.java
@@ -1,5 +1,6 @@
 package com.gregtechceu.gtceu.api.cover.filter;
 
+import com.gregtechceu.gtceu.common.data.GTItems;
 import com.gregtechceu.gtceu.utils.TagExprFilter;
 
 import net.minecraft.nbt.CompoundTag;
@@ -26,21 +27,26 @@ public static TagItemFilter loadFilter(ItemStack itemStack) {
     private static TagItemFilter loadFilter(CompoundTag tag, Consumer<ItemFilter> itemWriter) {
         var handler = new TagItemFilter();
         handler.itemWriter = itemWriter;
-        handler.oreDictFilterExpression = tag.getString("oreDict");
+        handler.filterString = tag.getString("oreDict");
         handler.matchExpr = null;
         handler.cache.clear();
-        handler.matchExpr = TagExprFilter.parseExpression(handler.oreDictFilterExpression);
+        handler.matchExpr = TagExprFilter.parseExpression(handler.filterString);
         return handler;
     }
 
-    public void setOreDict(String oreDict) {
+    public void setFilterString(String oreDict) {
         cache.clear();
-        super.setOreDict(oreDict);
+        super.setFilterString(oreDict);
+    }
+
+    @Override
+    protected ItemStack getFilterItem() {
+        return GTItems.TAG_FILTER.asStack();
     }
 
     @Override
     public boolean test(ItemStack itemStack) {
-        if (oreDictFilterExpression.isEmpty()) return false;
+        if (filterString.isEmpty()) return false;
         if (cache.containsKey(itemStack.getItem())) return cache.getOrDefault(itemStack.getItem(), false);
         if (TagExprFilter.tagsMatch(matchExpr, itemStack)) {
             cache.put(itemStack.getItem(), true);
diff --git a/src/main/java/com/gregtechceu/gtceu/api/data/chemical/material/info/MaterialIconType.java b/src/main/java/com/gregtechceu/gtceu/api/data/chemical/material/info/MaterialIconType.java
index 52d57bac337..9a19269427b 100644
--- a/src/main/java/com/gregtechceu/gtceu/api/data/chemical/material/info/MaterialIconType.java
+++ b/src/main/java/com/gregtechceu/gtceu/api/data/chemical/material/info/MaterialIconType.java
@@ -3,8 +3,7 @@
 import com.gregtechceu.gtceu.GTCEu;
 import com.gregtechceu.gtceu.common.data.models.GTModels;
 import com.gregtechceu.gtceu.integration.kjs.GTRegistryInfo;
-
-import com.lowdragmc.lowdraglib.utils.ResourceHelper;
+import com.gregtechceu.gtceu.utils.GTUtil;
 
 import net.minecraft.client.Minecraft;
 import net.minecraft.resources.ResourceLocation;
@@ -164,7 +163,7 @@ public ResourceLocation getBlockTexturePath(@NotNull MaterialIconSet materialIco
             while (!iconSet.isRootIconset) {
                 ResourceLocation location = GTCEu
                         .id(String.format("textures/block/material_sets/%s/%s%s.png", iconSet.name, this.name, suffix));
-                if (ResourceHelper.isResourceExist(location) || ResourceHelper.isResourceExistRaw(location))
+                if (GTUtil.resourceExists(location))
                     break;
                 iconSet = iconSet.parentIconset;
             }
@@ -172,8 +171,7 @@ public ResourceLocation getBlockTexturePath(@NotNull MaterialIconSet materialIco
 
         ResourceLocation location = GTCEu
                 .id(String.format("textures/block/material_sets/%s/%s%s.png", iconSet.name, this.name, suffix));
-        if (!suffix.isEmpty() && !ResourceHelper.isResourceExist(location) &&
-                !ResourceHelper.isResourceExistRaw(location)) {
+        if (!suffix.isEmpty() && !GTUtil.resourceExists(location)) {
             return GTModels.BLANK_TEXTURE;
         }
         location = GTCEu.id(String.format("block/material_sets/%s/%s%s", iconSet.name, this.name, suffix));
@@ -201,7 +199,7 @@ public ResourceLocation getBlockModelPath(@NotNull MaterialIconSet materialIconS
             while (!iconSet.isRootIconset) {
                 ResourceLocation location = GTCEu
                         .id(String.format("models/block/material_sets/%s/%s.json", iconSet.name, this.name));
-                if (ResourceHelper.isResourceExist(location) || ResourceHelper.isResourceExistRaw(location))
+                if (GTUtil.resourceExists(location))
                     break;
                 iconSet = iconSet.parentIconset;
             }
@@ -228,7 +226,7 @@ public ResourceLocation getItemModelPath(@NotNull MaterialIconSet materialIconSe
             while (!iconSet.isRootIconset) {
                 ResourceLocation location = GTCEu
                         .id(String.format("models/item/material_sets/%s/%s.json", iconSet.name, this.name));
-                if (ResourceHelper.isResourceExist(location) || ResourceHelper.isResourceExistRaw(location))
+                if (GTUtil.resourceExists(location))
                     break;
                 iconSet = iconSet.parentIconset;
             }
@@ -267,7 +265,7 @@ public ResourceLocation getItemTexturePath(@NotNull MaterialIconSet materialIcon
             while (!iconSet.isRootIconset) {
                 ResourceLocation location = GTCEu
                         .id(String.format("textures/item/material_sets/%s/%s%s.png", iconSet.name, this.name, suffix));
-                if (ResourceHelper.isResourceExist(location) || ResourceHelper.isResourceExistRaw(location))
+                if (GTUtil.resourceExists(location))
                     break;
                 iconSet = iconSet.parentIconset;
             }
@@ -275,8 +273,7 @@ public ResourceLocation getItemTexturePath(@NotNull MaterialIconSet materialIcon
 
         ResourceLocation location = GTCEu
                 .id(String.format("textures/item/material_sets/%s/%s%s.png", iconSet.name, this.name, suffix));
-        if (!suffix.isEmpty() && !ResourceHelper.isResourceExist(location) &&
-                !ResourceHelper.isResourceExistRaw(location)) {
+        if (!suffix.isEmpty() && !GTUtil.resourceExists(location)) {
             return null;
         }
         location = GTCEu.id(String.format("item/material_sets/%s/%s%s", iconSet.name, this.name, suffix));
diff --git a/src/main/java/com/gregtechceu/gtceu/api/data/chemical/material/properties/HazardProperty.java b/src/main/java/com/gregtechceu/gtceu/api/data/chemical/material/properties/HazardProperty.java
index 2e7a12f3bb7..8d9e8e5e8ce 100644
--- a/src/main/java/com/gregtechceu/gtceu/api/data/chemical/material/properties/HazardProperty.java
+++ b/src/main/java/com/gregtechceu/gtceu/api/data/chemical/material/properties/HazardProperty.java
@@ -116,7 +116,7 @@ public boolean isProtected(LivingEntity livingEntity) {
             for (ArmorItem.Type equipmentType : equipmentTypes) {
                 ItemStack armor = livingEntity.getItemBySlot(equipmentType.getSlot());
                 if (!armor.isEmpty() && ((armor.getItem() instanceof ArmorComponentItem armorItem &&
-                        armorItem.getArmorLogic().isPPE()) ||
+                        armorItem.getArmorLogic().isPPE(armor)) ||
                         armor.getTags().anyMatch(tag -> tag.equals(CustomTags.PPE_ARMOR)))) {
                     correctArmorItems.add(equipmentType);
                 }
@@ -135,7 +135,7 @@ public boolean isProtected(LivingEntity livingEntity) {
             for (SlotResult result : results) {
                 ItemStack armor = result.stack();
                 if (!armor.isEmpty() && ((armor.getItem() instanceof ArmorComponentItem armorItem &&
-                        armorItem.getArmorLogic().isPPE()) ||
+                        armorItem.getArmorLogic().isPPE(armor)) ||
                         armor.getTags().anyMatch(tag -> tag.equals(CustomTags.PPE_ARMOR)))) {
                     correctCurios.add(result.slotContext().identifier());
                 }
@@ -149,7 +149,7 @@ public void damageEquipment(Player player, int amount) {
                 for (ArmorItem.Type type : this.getEquipmentTypes()) {
                     ItemStack armor = player.getItemBySlot(type.getSlot());
                     if (!armor.isEmpty() && ((armor.getItem() instanceof ArmorComponentItem armorItem &&
-                            armorItem.getArmorLogic().isPPE()) ||
+                            armorItem.getArmorLogic().isPPE(armor)) ||
                             armor.getTags().anyMatch(tag -> tag.equals(CustomTags.PPE_ARMOR)))) {
                         armor.hurtAndBreak(amount, player, p -> p.broadcastBreakEvent(type.getSlot()));
                     }
@@ -165,7 +165,7 @@ public void damageEquipment(Player player, int amount) {
                                 for (int i = 0; i < handler.getSlots(); ++i) {
                                     ItemStack armor = stackHandler.getStackInSlot(i);
                                     if (!armor.isEmpty() && ((armor.getItem() instanceof ArmorComponentItem armorItem &&
-                                            armorItem.getArmorLogic().isPPE()) ||
+                                            armorItem.getArmorLogic().isPPE(armor)) ||
                                             armor.getTags().anyMatch(tag -> tag.equals(CustomTags.PPE_ARMOR)))) {
                                         armor.hurtAndBreak(amount, player, p -> {});
                                     }
diff --git a/src/main/java/com/gregtechceu/gtceu/api/data/tag/TagPrefix.java b/src/main/java/com/gregtechceu/gtceu/api/data/tag/TagPrefix.java
index c438c7e0167..eccb723b760 100644
--- a/src/main/java/com/gregtechceu/gtceu/api/data/tag/TagPrefix.java
+++ b/src/main/java/com/gregtechceu/gtceu/api/data/tag/TagPrefix.java
@@ -23,7 +23,7 @@
 import com.gregtechceu.gtceu.config.ConfigHolder;
 import com.gregtechceu.gtceu.data.recipe.CustomTags;
 import com.gregtechceu.gtceu.integration.kjs.GTRegistryInfo;
-import com.gregtechceu.gtceu.integration.xei.widgets.GTOreByProduct;
+import com.gregtechceu.gtceu.integration.recipeviewer.widgets.GTOreByProduct;
 import com.gregtechceu.gtceu.utils.FormattingUtil;
 import com.gregtechceu.gtceu.utils.memoization.GTMemoizer;
 
diff --git a/src/main/java/com/gregtechceu/gtceu/api/gui/GuiTextures.java b/src/main/java/com/gregtechceu/gtceu/api/gui/GuiTextures.java
index 2b1e3eecbd2..9e3b0948a63 100644
--- a/src/main/java/com/gregtechceu/gtceu/api/gui/GuiTextures.java
+++ b/src/main/java/com/gregtechceu/gtceu/api/gui/GuiTextures.java
@@ -1,5 +1,7 @@
 package com.gregtechceu.gtceu.api.gui;
 
+import com.gregtechceu.gtceu.GTCEu;
+
 import com.lowdragmc.lowdraglib.gui.texture.ResourceBorderTexture;
 import com.lowdragmc.lowdraglib.gui.texture.ResourceTexture;
 
@@ -194,6 +196,8 @@ public class GuiTextures {
             "gtceu:textures/item/storage_cover.png");
     public static final ResourceTexture BUTTON_MINER_MODES = new ResourceTexture(
             "gtceu:textures/gui/widget/button_miner_modes.png");
+    public static final ResourceTexture EQUIPMENT_FOUNDRY_BACKGROUND = new ResourceTexture(
+            GTCEu.id("textures/gui/widget/equipment_foundry_background.png"));
 
     // ORE PROCESSING
     public static final ResourceTexture OREBY_BASE = new ResourceTexture("gtceu:textures/gui/arrows/oreby-base.png");
diff --git a/src/main/java/com/gregtechceu/gtceu/api/gui/UITemplate.java b/src/main/java/com/gregtechceu/gtceu/api/gui/UITemplate.java
deleted file mode 100644
index 46bb179cbeb..00000000000
--- a/src/main/java/com/gregtechceu/gtceu/api/gui/UITemplate.java
+++ /dev/null
@@ -1,31 +0,0 @@
-package com.gregtechceu.gtceu.api.gui;
-
-import com.gregtechceu.gtceu.api.gui.widget.SlotWidget;
-
-import com.lowdragmc.lowdraglib.gui.texture.IGuiTexture;
-import com.lowdragmc.lowdraglib.gui.widget.WidgetGroup;
-
-import net.minecraft.world.entity.player.Inventory;
-
-public class UITemplate {
-
-    public static WidgetGroup bindPlayerInventory(Inventory inventoryPlayer, IGuiTexture imageLocation, int x, int y,
-                                                  boolean addHotbar) {
-        WidgetGroup group = new WidgetGroup(x, y, 162, 54 + (addHotbar ? 22 : 0));
-        for (int row = 0; row < 3; row++) {
-            for (int col = 0; col < 9; col++) {
-                group.addWidget(new SlotWidget(inventoryPlayer, col + (row + 1) * 9, col * 18, row * 18)
-                        .setBackgroundTexture(imageLocation)
-                        .setLocationInfo(true, false));
-            }
-        }
-        if (addHotbar) {
-            for (int slot = 0; slot < 9; slot++) {
-                group.addWidget(new SlotWidget(inventoryPlayer, slot, slot * 18, 58)
-                        .setBackgroundTexture(imageLocation)
-                        .setLocationInfo(true, true));
-            }
-        }
-        return group;
-    }
-}
diff --git a/src/main/java/com/gregtechceu/gtceu/api/gui/editor/EditableMachineUI.java b/src/main/java/com/gregtechceu/gtceu/api/gui/editor/EditableMachineUI.java
deleted file mode 100644
index 56798f4bace..00000000000
--- a/src/main/java/com/gregtechceu/gtceu/api/gui/editor/EditableMachineUI.java
+++ /dev/null
@@ -1,107 +0,0 @@
-package com.gregtechceu.gtceu.api.gui.editor;
-
-import com.gregtechceu.gtceu.GTCEu;
-import com.gregtechceu.gtceu.api.machine.MetaMachine;
-
-import com.lowdragmc.lowdraglib.gui.editor.configurator.IConfigurableWidget;
-import com.lowdragmc.lowdraglib.gui.editor.data.Resources;
-import com.lowdragmc.lowdraglib.gui.widget.WidgetGroup;
-import com.lowdragmc.lowdraglib.utils.Position;
-
-import net.minecraft.client.Minecraft;
-import net.minecraft.nbt.CompoundTag;
-import net.minecraft.nbt.NbtAccounter;
-import net.minecraft.nbt.NbtIo;
-import net.minecraft.resources.ResourceLocation;
-import net.minecraft.server.packs.resources.ResourceManager;
-
-import lombok.Getter;
-import org.jetbrains.annotations.Nullable;
-
-import java.io.DataInputStream;
-import java.io.InputStream;
-import java.util.function.BiConsumer;
-import java.util.function.Supplier;
-
-public class EditableMachineUI implements IEditableUI<WidgetGroup, MetaMachine> {
-
-    @Getter
-    final String groupName;
-    @Getter
-    final ResourceLocation uiPath;
-    final Supplier<WidgetGroup> widgetSupplier;
-    final BiConsumer<WidgetGroup, MetaMachine> binder;
-    @Nullable
-    private CompoundTag customUICache;
-
-    public EditableMachineUI(String groupName, ResourceLocation uiPath, Supplier<WidgetGroup> widgetSupplier,
-                             BiConsumer<WidgetGroup, MetaMachine> binder) {
-        this.groupName = groupName;
-        this.uiPath = uiPath;
-        this.widgetSupplier = widgetSupplier;
-        this.binder = binder;
-    }
-
-    public WidgetGroup createDefault() {
-        return widgetSupplier.get();
-    }
-
-    public void setupUI(WidgetGroup template, MetaMachine machine) {
-        binder.accept(template, machine);
-    }
-
-    //////////////////////////////////////
-    // ******** GUI *********//
-    //////////////////////////////////////
-
-    @Nullable
-    public WidgetGroup createCustomUI() {
-        if (hasCustomUI()) {
-            var nbt = getCustomUI();
-            var group = new WidgetGroup();
-            IConfigurableWidget.deserializeNBT(group, nbt.getCompound("root"),
-                    Resources.fromNBT(nbt.getCompound("resources")), false);
-            group.setSelfPosition(new Position(0, 0));
-            return group;
-        }
-        return null;
-    }
-
-    public CompoundTag getCustomUI() {
-        if (this.customUICache == null) {
-            ResourceManager resourceManager = null;
-            if (GTCEu.isClientSide()) {
-                resourceManager = Minecraft.getInstance().getResourceManager();
-            } else if (GTCEu.getMinecraftServer() != null) {
-                resourceManager = GTCEu.getMinecraftServer().getResourceManager();
-            }
-            if (resourceManager == null) {
-                this.customUICache = new CompoundTag();
-            } else {
-                try {
-                    var resource = resourceManager.getResourceOrThrow(new ResourceLocation(uiPath.getNamespace(),
-                            "ui/machine/%s.mui".formatted(uiPath.getPath())));
-                    try (InputStream inputStream = resource.open()) {
-                        try (DataInputStream dataInputStream = new DataInputStream(inputStream);) {
-                            this.customUICache = NbtIo.read(dataInputStream, NbtAccounter.UNLIMITED);
-                        }
-                    }
-                } catch (Exception e) {
-                    this.customUICache = new CompoundTag();
-                }
-                if (this.customUICache == null) {
-                    this.customUICache = new CompoundTag();
-                }
-            }
-        }
-        return this.customUICache;
-    }
-
-    public boolean hasCustomUI() {
-        return !getCustomUI().isEmpty();
-    }
-
-    public void reloadCustomUI() {
-        this.customUICache = null;
-    }
-}
diff --git a/src/main/java/com/gregtechceu/gtceu/api/gui/editor/EditableUI.java b/src/main/java/com/gregtechceu/gtceu/api/gui/editor/EditableUI.java
deleted file mode 100644
index 3020d5f7676..00000000000
--- a/src/main/java/com/gregtechceu/gtceu/api/gui/editor/EditableUI.java
+++ /dev/null
@@ -1,39 +0,0 @@
-package com.gregtechceu.gtceu.api.gui.editor;
-
-import com.gregtechceu.gtceu.api.gui.WidgetUtils;
-
-import com.lowdragmc.lowdraglib.gui.widget.Widget;
-import com.lowdragmc.lowdraglib.gui.widget.WidgetGroup;
-
-import lombok.Getter;
-
-import java.util.function.BiConsumer;
-import java.util.function.Supplier;
-
-public class EditableUI<W extends Widget, T> implements IEditableUI<W, T> {
-
-    @Getter
-    final String id;
-    final Class<W> clazz;
-    @Getter
-    final Supplier<W> widgetSupplier;
-    @Getter
-    final BiConsumer<W, T> binder;
-
-    public EditableUI(String id, Class<W> clazz, Supplier<W> widgetSupplier, BiConsumer<W, T> binder) {
-        this.id = id;
-        this.clazz = clazz;
-        this.widgetSupplier = widgetSupplier;
-        this.binder = binder;
-    }
-
-    public W createDefault() {
-        var widget = widgetSupplier.get();
-        widget.setId(id);
-        return widget;
-    }
-
-    public void setupUI(WidgetGroup template, T instance) {
-        WidgetUtils.widgetByIdForEach(template, "^" + id + "$", clazz, w -> binder.accept(w, instance));
-    }
-}
diff --git a/src/main/java/com/gregtechceu/gtceu/api/gui/editor/GTUIEditor.java b/src/main/java/com/gregtechceu/gtceu/api/gui/editor/GTUIEditor.java
deleted file mode 100644
index 9f372444007..00000000000
--- a/src/main/java/com/gregtechceu/gtceu/api/gui/editor/GTUIEditor.java
+++ /dev/null
@@ -1,20 +0,0 @@
-package com.gregtechceu.gtceu.api.gui.editor;
-
-import com.lowdragmc.lowdraglib.LDLib;
-import com.lowdragmc.lowdraglib.gui.editor.Icons;
-import com.lowdragmc.lowdraglib.gui.editor.annotation.LDLRegister;
-import com.lowdragmc.lowdraglib.gui.editor.ui.UIEditor;
-import com.lowdragmc.lowdraglib.gui.editor.ui.tool.WidgetToolBox;
-
-import static com.lowdragmc.lowdraglib.gui.editor.ui.tool.WidgetToolBox.Default.registerTab;
-
-@LDLRegister(name = "editor.gtceu", group = "editor")
-public class GTUIEditor extends UIEditor {
-
-    public static final WidgetToolBox.Default GT_CONTAINER = registerTab("widget.gtm_container",
-            Icons.WIDGET_CONTAINER);
-
-    public GTUIEditor() {
-        super(LDLib.location);
-    }
-}
diff --git a/src/main/java/com/gregtechceu/gtceu/api/gui/editor/MachineUIProject.java b/src/main/java/com/gregtechceu/gtceu/api/gui/editor/MachineUIProject.java
deleted file mode 100644
index ef0cf9410a0..00000000000
--- a/src/main/java/com/gregtechceu/gtceu/api/gui/editor/MachineUIProject.java
+++ /dev/null
@@ -1,155 +0,0 @@
-package com.gregtechceu.gtceu.api.gui.editor;
-
-import com.gregtechceu.gtceu.api.machine.MachineDefinition;
-import com.gregtechceu.gtceu.api.registry.GTRegistries;
-
-import com.lowdragmc.lowdraglib.LDLib;
-import com.lowdragmc.lowdraglib.gui.editor.ColorPattern;
-import com.lowdragmc.lowdraglib.gui.editor.Icons;
-import com.lowdragmc.lowdraglib.gui.editor.annotation.LDLRegister;
-import com.lowdragmc.lowdraglib.gui.editor.data.Resources;
-import com.lowdragmc.lowdraglib.gui.editor.data.UIProject;
-import com.lowdragmc.lowdraglib.gui.editor.ui.Editor;
-import com.lowdragmc.lowdraglib.gui.editor.ui.tool.WidgetToolBox;
-import com.lowdragmc.lowdraglib.gui.texture.GuiTextureGroup;
-import com.lowdragmc.lowdraglib.gui.texture.ItemStackTexture;
-import com.lowdragmc.lowdraglib.gui.texture.TextTexture;
-import com.lowdragmc.lowdraglib.gui.util.TreeBuilder;
-import com.lowdragmc.lowdraglib.gui.widget.TabButton;
-import com.lowdragmc.lowdraglib.gui.widget.WidgetGroup;
-import com.lowdragmc.lowdraglib.utils.Position;
-
-import net.minecraft.nbt.CompoundTag;
-import net.minecraft.nbt.NbtIo;
-import net.minecraft.resources.ResourceLocation;
-
-import lombok.Getter;
-import org.jetbrains.annotations.Nullable;
-
-import java.io.File;
-import java.io.IOException;
-import java.util.*;
-
-@LDLRegister(name = "mui", group = "editor.gtceu")
-public class MachineUIProject extends UIProject {
-
-    @Nullable
-    @Getter
-    protected MachineDefinition machineDefinition;
-
-    private MachineUIProject() {
-        this(null, null);
-    }
-
-    public MachineUIProject(Resources resources, WidgetGroup root) {
-        super(resources, root);
-    }
-
-    public MachineUIProject(CompoundTag tag) {
-        super(tag);
-    }
-
-    public void setMachine(@Nullable MachineDefinition machineDefinition) {
-        this.machineDefinition = machineDefinition;
-    }
-
-    public MachineUIProject newEmptyProject() {
-        return new MachineUIProject(Resources.defaultResource(), new WidgetGroup(30, 30, 200, 150));
-    }
-
-    @Override
-    public UIProject loadProject(File file) {
-        try {
-            var tag = NbtIo.read(file);
-            if (tag != null) {
-                return new MachineUIProject(tag);
-            }
-        } catch (IOException ignored) {}
-        return null;
-    }
-
-    @Override
-    public CompoundTag serializeNBT() {
-        var tag = super.serializeNBT();
-        if (machineDefinition != null) {
-            tag.putString("machine", machineDefinition.getId().toString());
-        }
-        return tag;
-    }
-
-    @Override
-    public void deserializeNBT(CompoundTag tag) {
-        super.deserializeNBT(tag);
-        if (tag.contains("machine")) {
-            machineDefinition = GTRegistries.MACHINES.get(new ResourceLocation(tag.getString("machine")));
-        }
-    }
-
-    @Override
-    public void onLoad(Editor editor) {
-        editor.getResourcePanel().loadResource(getResources(), false);
-        editor.getTabPages().addTab(new TabButton(50, 16, 60, 14).setTexture(
-                new GuiTextureGroup(ColorPattern.T_GREEN.rectTexture().setBottomRadius(10).transform(0, 0.4f),
-                        new TextTexture("Main")),
-                new GuiTextureGroup(ColorPattern.T_RED.rectTexture().setBottomRadius(10).transform(0, 0.4f),
-                        new TextTexture("Main"))),
-                new UIMainPanel(editor, root, machineDefinition == null ? null : machineDefinition.getDescriptionId()));
-
-        for (WidgetToolBox.Default tab : WidgetToolBox.Default.TABS) {
-            if (tab == WidgetToolBox.Default.CONTAINER) {
-                continue;
-            }
-            editor.getToolPanel().addNewToolBox("ldlib.gui.editor.group." + tab.groupName, tab.icon,
-                    tab.createToolBox());
-        }
-    }
-
-    @Override
-    public void attachMenu(Editor editor, String name, TreeBuilder.Menu menu) {
-        if (name.equals("file")) {
-            if (machineDefinition == null || machineDefinition.getEditableUI() == null) {
-                menu.remove("ldlib.gui.editor.menu.save");
-            } else {
-                menu.remove("ldlib.gui.editor.menu.save");
-                menu.leaf(Icons.SAVE, "ldlib.gui.editor.menu.save", () -> {
-                    var editableUI = machineDefinition.getEditableUI();
-                    var path = new File(LDLib.location,
-                            "assets/%s/ui/machine".formatted(editableUI.getUiPath().getNamespace()));
-                    path.mkdirs();
-                    saveProject(new File(path, editableUI.getUiPath().getPath() + "." + this.getRegisterUI().name()));
-                    editableUI.reloadCustomUI();
-                });
-            }
-        } else if (name.equals("template_tab")) {
-            Map<String, List<MachineDefinition>> categories = new LinkedHashMap<>();
-            for (var definition : GTRegistries.MACHINES) {
-                final var editableUI = definition.getEditableUI();
-                if (editableUI != null) {
-                    // has editable UI
-                    categories.computeIfAbsent(editableUI.getGroupName(), group -> new ArrayList<>()).add(definition);
-                }
-            }
-            categories.forEach((groupName, definitions) -> menu.branch(groupName, m -> {
-                Set<EditableMachineUI> addedSet = new HashSet<>();
-                for (var definition : definitions) {
-                    var editableUI = definition.getEditableUI();
-                    if (editableUI != null && addedSet.add(editableUI)) {
-                        m.leaf(new ItemStackTexture(definition.asStack()), definition.getDescriptionId(), () -> {
-                            root.clearAllWidgets();
-                            if (editableUI.hasCustomUI()) {
-                                deserializeNBT(editableUI.getCustomUI());
-                            } else {
-                                var template = editableUI.createDefault();
-                                template.setSelfPosition(
-                                        new Position(root.getSelfPosition().x, root.getSelfPosition().y));
-                                this.root = template;
-                            }
-                            setMachine(definition);
-                            editor.loadProject(this);
-                        });
-                    }
-                }
-            }));
-        }
-    }
-}
diff --git a/src/main/java/com/gregtechceu/gtceu/api/gui/editor/RecipeTypeUIProject.java b/src/main/java/com/gregtechceu/gtceu/api/gui/editor/RecipeTypeUIProject.java
deleted file mode 100644
index 5927dedaea1..00000000000
--- a/src/main/java/com/gregtechceu/gtceu/api/gui/editor/RecipeTypeUIProject.java
+++ /dev/null
@@ -1,154 +0,0 @@
-package com.gregtechceu.gtceu.api.gui.editor;
-
-import com.gregtechceu.gtceu.api.recipe.GTRecipeType;
-import com.gregtechceu.gtceu.api.registry.GTRegistries;
-
-import com.lowdragmc.lowdraglib.LDLib;
-import com.lowdragmc.lowdraglib.gui.editor.ColorPattern;
-import com.lowdragmc.lowdraglib.gui.editor.Icons;
-import com.lowdragmc.lowdraglib.gui.editor.annotation.LDLRegister;
-import com.lowdragmc.lowdraglib.gui.editor.configurator.IConfigurableWidget;
-import com.lowdragmc.lowdraglib.gui.editor.data.Resources;
-import com.lowdragmc.lowdraglib.gui.editor.data.UIProject;
-import com.lowdragmc.lowdraglib.gui.editor.ui.Editor;
-import com.lowdragmc.lowdraglib.gui.editor.ui.tool.WidgetToolBox;
-import com.lowdragmc.lowdraglib.gui.texture.*;
-import com.lowdragmc.lowdraglib.gui.util.TreeBuilder;
-import com.lowdragmc.lowdraglib.gui.widget.*;
-
-import net.minecraft.nbt.CompoundTag;
-import net.minecraft.nbt.NbtIo;
-import net.minecraft.resources.ResourceLocation;
-import net.minecraft.world.item.Items;
-
-import lombok.Getter;
-import lombok.Setter;
-import org.jetbrains.annotations.Nullable;
-
-import java.io.File;
-import java.io.IOException;
-import java.util.ArrayList;
-import java.util.LinkedHashMap;
-import java.util.List;
-import java.util.Map;
-
-@LDLRegister(name = "rtui", group = "editor.gtceu")
-public class RecipeTypeUIProject extends UIProject {
-
-    @Nullable
-    @Getter
-    @Setter
-    protected GTRecipeType recipeType;
-
-    private RecipeTypeUIProject() {
-        this(null, null);
-    }
-
-    public RecipeTypeUIProject(Resources resources, WidgetGroup root) {
-        super(resources, root);
-    }
-
-    public RecipeTypeUIProject(CompoundTag tag) {
-        super(tag);
-    }
-
-    @Override
-    public RecipeTypeUIProject newEmptyProject() {
-        return new RecipeTypeUIProject(Resources.defaultResource(), new WidgetGroup(30, 30, 200, 200));
-    }
-
-    @Override
-    public UIProject loadProject(File file) {
-        try {
-            var tag = NbtIo.read(file);
-            if (tag != null) {
-                return new RecipeTypeUIProject(tag);
-            }
-        } catch (IOException ignored) {}
-        return null;
-    }
-
-    @Override
-    public CompoundTag serializeNBT() {
-        var tag = super.serializeNBT();
-        if (recipeType != null) {
-            tag.putString("recipe_type", recipeType.registryName.toString());
-        }
-        return tag;
-    }
-
-    @Override
-    public void deserializeNBT(CompoundTag tag) {
-        super.deserializeNBT(tag);
-        if (tag.contains("recipe_type")) {
-            recipeType = GTRegistries.RECIPE_TYPES.get(new ResourceLocation(tag.getString("recipe_type")));
-        }
-    }
-
-    @Override
-    public void onLoad(Editor editor) {
-        editor.getResourcePanel().loadResource(getResources(), false);
-        editor.getTabPages().addTab(new TabButton(50, 16, 60, 14).setTexture(
-                new GuiTextureGroup(ColorPattern.T_GREEN.rectTexture().setBottomRadius(10).transform(0, 0.4f),
-                        new TextTexture("Main")),
-                new GuiTextureGroup(ColorPattern.T_RED.rectTexture().setBottomRadius(10).transform(0, 0.4f),
-                        new TextTexture("Main"))),
-                new UIMainPanel(editor, root, recipeType == null ? null : recipeType.registryName.toLanguageKey()));
-        for (WidgetToolBox.Default tab : WidgetToolBox.Default.TABS) {
-            if (tab == WidgetToolBox.Default.CONTAINER) {
-                continue;
-            }
-            editor.getToolPanel().addNewToolBox("ldlib.gui.editor.group." + tab.groupName, tab.icon,
-                    tab.createToolBox());
-        }
-    }
-
-    @Override
-    public void attachMenu(Editor editor, String name, TreeBuilder.Menu menu) {
-        if (name.equals("file")) {
-            if (recipeType == null) {
-                menu.remove("ldlib.gui.editor.menu.save");
-            } else {
-                menu.remove("ldlib.gui.editor.menu.save");
-                menu.leaf(Icons.SAVE, "ldlib.gui.editor.menu.save", () -> {
-                    var path = new File(LDLib.getLDLibDir(),
-                            "assets/%s/ui/recipe_type".formatted(recipeType.registryName.getNamespace()));
-                    path.mkdirs();
-                    saveProject(new File(path, recipeType.registryName.getPath() + "." + this.getRegisterUI().name()));
-                    recipeType.getRecipeUI().reloadCustomUI();
-                });
-            }
-        } else if (name.equals("template_tab")) {
-            Map<String, List<GTRecipeType>> categories = new LinkedHashMap<>();
-            for (GTRecipeType recipeType : GTRegistries.RECIPE_TYPES) {
-                categories.computeIfAbsent(recipeType.group, group -> new ArrayList<>()).add(recipeType);
-            }
-            categories.forEach((groupName, recipeTypes) -> menu.branch(groupName, m -> {
-                for (GTRecipeType recipeType : recipeTypes) {
-                    IGuiTexture icon;
-                    if (recipeType.getIconSupplier() != null) {
-                        icon = new ItemStackTexture(recipeType.getIconSupplier().get());
-                    } else {
-                        icon = new ItemStackTexture(Items.BARRIER);
-                    }
-                    m.leaf(icon, recipeType.registryName.toLanguageKey(), () -> {
-                        root.clearAllWidgets();
-                        if (recipeType.getRecipeUI().hasCustomUI()) {
-                            var nbt = recipeType.getRecipeUI().getCustomUI();
-                            IConfigurableWidget.deserializeNBT(root, nbt.getCompound("root"),
-                                    Resources.fromNBT(nbt.getCompound("resources")), false);
-                        } else {
-                            var widget = recipeType.getRecipeUI().createEditableUITemplate(false, false)
-                                    .createDefault();
-                            root.setSize(widget.getSize());
-                            for (Widget children : widget.widgets) {
-                                root.addWidget(children);
-                            }
-                        }
-                        setRecipeType(recipeType);
-                    });
-                }
-            }));
-        }
-    }
-}
diff --git a/src/main/java/com/gregtechceu/gtceu/api/gui/editor/TemplateTab.java b/src/main/java/com/gregtechceu/gtceu/api/gui/editor/TemplateTab.java
deleted file mode 100644
index 717d9e662b6..00000000000
--- a/src/main/java/com/gregtechceu/gtceu/api/gui/editor/TemplateTab.java
+++ /dev/null
@@ -1,13 +0,0 @@
-package com.gregtechceu.gtceu.api.gui.editor;
-
-import com.lowdragmc.lowdraglib.gui.editor.annotation.LDLRegister;
-import com.lowdragmc.lowdraglib.gui.editor.ui.menu.MenuTab;
-import com.lowdragmc.lowdraglib.gui.util.TreeBuilder;
-
-@LDLRegister(name = "template_tab", group = "editor.gtceu")
-public class TemplateTab extends MenuTab {
-
-    protected TreeBuilder.Menu createMenu() {
-        return TreeBuilder.Menu.start();
-    }
-}
diff --git a/src/main/java/com/gregtechceu/gtceu/api/gui/editor/UIMainPanel.java b/src/main/java/com/gregtechceu/gtceu/api/gui/editor/UIMainPanel.java
deleted file mode 100644
index 430266b226a..00000000000
--- a/src/main/java/com/gregtechceu/gtceu/api/gui/editor/UIMainPanel.java
+++ /dev/null
@@ -1,44 +0,0 @@
-package com.gregtechceu.gtceu.api.gui.editor;
-
-import com.gregtechceu.gtceu.api.gui.GuiTextures;
-
-import com.lowdragmc.lowdraglib.gui.editor.ui.Editor;
-import com.lowdragmc.lowdraglib.gui.editor.ui.MainPanel;
-import com.lowdragmc.lowdraglib.gui.texture.IGuiTexture;
-import com.lowdragmc.lowdraglib.gui.texture.TextTexture;
-import com.lowdragmc.lowdraglib.gui.widget.WidgetGroup;
-
-import net.minecraft.client.gui.GuiGraphics;
-import net.minecraftforge.api.distmarker.Dist;
-import net.minecraftforge.api.distmarker.OnlyIn;
-
-public class UIMainPanel extends MainPanel {
-
-    final String description;
-
-    public UIMainPanel(Editor editor, WidgetGroup root, String description) {
-        super(editor, root);
-        this.setBackground(new IGuiTexture() {
-
-            @Override
-            @OnlyIn(Dist.CLIENT)
-            public void draw(GuiGraphics graphics, int mouseX, int mouseY, float x, float y, int width, int height) {
-                if (description != null) {
-                    new TextTexture(description).scale(2.0f).draw(graphics, mouseX, mouseY, x, y,
-                            width - editor.getConfigPanel().getSize().getWidth(), height);
-                }
-                var border = 4;
-                var background = GuiTextures.BACKGROUND;
-                var position = root.getPosition();
-                var size = root.getSize();
-                var w = Math.max(size.width + border * 2, 172);
-                var h = Math.max(size.height + border * 2, 86);
-                background.draw(graphics, mouseX, mouseY,
-                        position.x - (w - size.width) / 2f,
-                        position.y - (h - size.height) / 2f,
-                        w, h);
-            }
-        });
-        this.description = description;
-    }
-}
diff --git a/src/main/java/com/gregtechceu/gtceu/api/gui/factory/CoverUIFactory.java b/src/main/java/com/gregtechceu/gtceu/api/gui/factory/CoverUIFactory.java
deleted file mode 100644
index 62bdd2601ad..00000000000
--- a/src/main/java/com/gregtechceu/gtceu/api/gui/factory/CoverUIFactory.java
+++ /dev/null
@@ -1,54 +0,0 @@
-package com.gregtechceu.gtceu.api.gui.factory;
-
-import com.gregtechceu.gtceu.GTCEu;
-import com.gregtechceu.gtceu.api.capability.GTCapabilityHelper;
-import com.gregtechceu.gtceu.api.cover.CoverBehavior;
-import com.gregtechceu.gtceu.api.cover.IUICover;
-
-import com.lowdragmc.lowdraglib.gui.factory.UIFactory;
-import com.lowdragmc.lowdraglib.gui.modular.ModularUI;
-
-import net.minecraft.client.Minecraft;
-import net.minecraft.core.Direction;
-import net.minecraft.network.FriendlyByteBuf;
-import net.minecraft.world.entity.player.Player;
-import net.minecraft.world.level.Level;
-import net.minecraftforge.api.distmarker.Dist;
-import net.minecraftforge.api.distmarker.OnlyIn;
-
-public class CoverUIFactory extends UIFactory<CoverBehavior> {
-
-    public static final CoverUIFactory INSTANCE = new CoverUIFactory();
-
-    public CoverUIFactory() {
-        super(GTCEu.id("cover"));
-    }
-
-    @Override
-    protected ModularUI createUITemplate(CoverBehavior holder, Player entityPlayer) {
-        if (holder instanceof IUICover cover) {
-            return cover.createUI(entityPlayer);
-        }
-        return null;
-    }
-
-    @OnlyIn(Dist.CLIENT)
-    @Override
-    protected CoverBehavior readHolderFromSyncData(FriendlyByteBuf syncData) {
-        Level world = Minecraft.getInstance().level;
-        if (world == null) return null;
-        var pos = syncData.readBlockPos();
-        var side = syncData.readEnum(Direction.class);
-        var coverable = GTCapabilityHelper.getCoverable(world, pos, side);
-        if (coverable != null) {
-            return coverable.getCoverAtSide(side);
-        }
-        return null;
-    }
-
-    @Override
-    protected void writeHolderToSyncData(FriendlyByteBuf syncData, CoverBehavior holder) {
-        syncData.writeBlockPos(holder.coverHolder.getBlockPos());
-        syncData.writeEnum(holder.attachedSide);
-    }
-}
diff --git a/src/main/java/com/gregtechceu/gtceu/api/gui/factory/GTUIEditorFactory.java b/src/main/java/com/gregtechceu/gtceu/api/gui/factory/GTUIEditorFactory.java
deleted file mode 100644
index 814491d6e60..00000000000
--- a/src/main/java/com/gregtechceu/gtceu/api/gui/factory/GTUIEditorFactory.java
+++ /dev/null
@@ -1,52 +0,0 @@
-package com.gregtechceu.gtceu.api.gui.factory;
-
-import com.gregtechceu.gtceu.GTCEu;
-import com.gregtechceu.gtceu.api.gui.editor.GTUIEditor;
-
-import com.lowdragmc.lowdraglib.LDLib;
-import com.lowdragmc.lowdraglib.gui.factory.UIFactory;
-import com.lowdragmc.lowdraglib.gui.modular.IUIHolder;
-import com.lowdragmc.lowdraglib.gui.modular.ModularUI;
-
-import net.minecraft.network.FriendlyByteBuf;
-import net.minecraft.world.entity.player.Player;
-
-public class GTUIEditorFactory extends UIFactory<GTUIEditorFactory> implements IUIHolder {
-
-    public static final GTUIEditorFactory INSTANCE = new GTUIEditorFactory();
-
-    private GTUIEditorFactory() {
-        super(LDLib.location("gt_ui_editor"));
-    }
-
-    @Override
-    protected ModularUI createUITemplate(GTUIEditorFactory holder, Player entityPlayer) {
-        return createUI(entityPlayer);
-    }
-
-    @Override
-    protected GTUIEditorFactory readHolderFromSyncData(FriendlyByteBuf syncData) {
-        return this;
-    }
-
-    @Override
-    protected void writeHolderToSyncData(FriendlyByteBuf syncData, GTUIEditorFactory holder) {}
-
-    @Override
-    public ModularUI createUI(Player entityPlayer) {
-        return new ModularUI(this, entityPlayer).widget(new GTUIEditor());
-    }
-
-    @Override
-    public boolean isInvalid() {
-        return false;
-    }
-
-    @Override
-    public boolean isRemote() {
-        return GTCEu.isClientThread();
-    }
-
-    @Override
-    public void markAsDirty() {}
-}
diff --git a/src/main/java/com/gregtechceu/gtceu/api/gui/factory/MachineUIFactory.java b/src/main/java/com/gregtechceu/gtceu/api/gui/factory/MachineUIFactory.java
deleted file mode 100644
index 220c3a9c4d0..00000000000
--- a/src/main/java/com/gregtechceu/gtceu/api/gui/factory/MachineUIFactory.java
+++ /dev/null
@@ -1,48 +0,0 @@
-package com.gregtechceu.gtceu.api.gui.factory;
-
-import com.gregtechceu.gtceu.GTCEu;
-import com.gregtechceu.gtceu.api.machine.MetaMachine;
-import com.gregtechceu.gtceu.api.machine.feature.IUIMachine;
-
-import com.lowdragmc.lowdraglib.gui.factory.UIFactory;
-import com.lowdragmc.lowdraglib.gui.modular.ModularUI;
-
-import net.minecraft.client.Minecraft;
-import net.minecraft.network.FriendlyByteBuf;
-import net.minecraft.world.entity.player.Player;
-import net.minecraft.world.level.Level;
-import net.minecraftforge.api.distmarker.Dist;
-import net.minecraftforge.api.distmarker.OnlyIn;
-
-public class MachineUIFactory extends UIFactory<MetaMachine> {
-
-    public static final MachineUIFactory INSTANCE = new MachineUIFactory();
-
-    public MachineUIFactory() {
-        super(GTCEu.id("machine"));
-    }
-
-    @Override
-    protected ModularUI createUITemplate(MetaMachine holder, Player entityPlayer) {
-        if (holder instanceof IUIMachine machine) {
-            return machine.createUI(entityPlayer);
-        }
-        return null;
-    }
-
-    @OnlyIn(Dist.CLIENT)
-    @Override
-    protected MetaMachine readHolderFromSyncData(FriendlyByteBuf syncData) {
-        Level world = Minecraft.getInstance().level;
-        if (world == null) return null;
-        if (world.getBlockEntity(syncData.readBlockPos()) instanceof MetaMachine holder) {
-            return holder;
-        }
-        return null;
-    }
-
-    @Override
-    protected void writeHolderToSyncData(FriendlyByteBuf syncData, MetaMachine holder) {
-        syncData.writeBlockPos(holder.getBlockPos());
-    }
-}
diff --git a/src/main/java/com/gregtechceu/gtceu/api/gui/fancy/ConfiguratorPanel.java b/src/main/java/com/gregtechceu/gtceu/api/gui/fancy/ConfiguratorPanel.java
deleted file mode 100644
index 6ab93be46bc..00000000000
--- a/src/main/java/com/gregtechceu/gtceu/api/gui/fancy/ConfiguratorPanel.java
+++ /dev/null
@@ -1,449 +0,0 @@
-package com.gregtechceu.gtceu.api.gui.fancy;
-
-import com.gregtechceu.gtceu.api.gui.GuiTextures;
-import com.gregtechceu.gtceu.config.ConfigHolder;
-
-import com.lowdragmc.lowdraglib.gui.animation.Animation;
-import com.lowdragmc.lowdraglib.gui.animation.Transform;
-import com.lowdragmc.lowdraglib.gui.texture.IGuiTexture;
-import com.lowdragmc.lowdraglib.gui.texture.TextTexture;
-import com.lowdragmc.lowdraglib.gui.util.ClickData;
-import com.lowdragmc.lowdraglib.gui.widget.ButtonWidget;
-import com.lowdragmc.lowdraglib.gui.widget.ImageWidget;
-import com.lowdragmc.lowdraglib.gui.widget.Widget;
-import com.lowdragmc.lowdraglib.gui.widget.WidgetGroup;
-import com.lowdragmc.lowdraglib.utils.Position;
-import com.lowdragmc.lowdraglib.utils.Size;
-import com.lowdragmc.lowdraglib.utils.interpolate.Eases;
-
-import net.minecraft.client.gui.GuiGraphics;
-import net.minecraft.network.FriendlyByteBuf;
-import net.minecraft.world.item.ItemStack;
-import net.minecraftforge.api.distmarker.Dist;
-import net.minecraftforge.api.distmarker.OnlyIn;
-
-import com.mojang.blaze3d.systems.RenderSystem;
-import lombok.Getter;
-import lombok.Setter;
-import org.jetbrains.annotations.NotNull;
-import org.jetbrains.annotations.Nullable;
-
-import java.util.ArrayList;
-import java.util.Collections;
-import java.util.List;
-
-public class ConfiguratorPanel extends WidgetGroup {
-
-    @Getter
-    protected List<Tab> tabs = new ArrayList<>();
-    @Getter
-    @Nullable
-    protected Tab expanded;
-    @Setter
-    protected int border = 4;
-    @Setter
-    protected IGuiTexture texture = GuiTextures.BACKGROUND;
-
-    public ConfiguratorPanel(int x, int y) {
-        super(x, y, 24, 0);
-    }
-
-    public void clear() {
-        clearAllWidgets();
-        tabs.clear();
-        expanded = null;
-    }
-
-    public int getTabSize() {
-        return getSize().width;
-    }
-
-    public void attachConfigurators(IFancyConfigurator... fancyConfigurators) {
-        for (IFancyConfigurator fancyConfigurator : fancyConfigurators) {
-            var tab = new Tab(fancyConfigurator);
-            tab.setBackground(texture);
-            tabs.add(tab);
-            addWidgetAnima(tab, new Transform()
-                    .scale(0)
-                    .duration(getAnimationTime())
-                    .ease(Eases.EaseQuadOut));
-        }
-        setSize(new Size(getSize().width, Math.max(0, tabs.size() * (getTabSize() + 2) - 2)));
-    }
-
-    public void expandTab(Tab tab) {
-        tab.expand();
-        int i = 0;
-        for (Tab otherTab : tabs) {
-            if (otherTab != tab) {
-                otherTab.collapseTo(0, i++ * (getTabSize() + 2));
-            }
-        }
-        expanded = tab;
-    }
-
-    public void collapseTab() {
-        if (expanded != null) {
-            for (int i = 0; i < tabs.size(); i++) {
-                tabs.get(i).collapseTo(0, i * (getTabSize() + 2));
-            }
-            if (expanded instanceof FloatingTab) {
-                expanded.collapseTo(0, 0);
-            }
-        }
-        expanded = null;
-    }
-
-    @Override
-    @OnlyIn(Dist.CLIENT)
-    protected void drawWidgetsBackground(@NotNull GuiGraphics graphics, int mouseX, int mouseY, float partialTicks) {
-        for (Widget widget : widgets) {
-            if (widget.isVisible() && widget != expanded) {
-                RenderSystem.setShaderColor(1, 1, 1, 1);
-                RenderSystem.enableBlend();
-                if (widget.inAnimate()) {
-                    widget.getAnimation().drawInBackground(graphics, mouseX, mouseY, partialTicks);
-                } else {
-                    widget.drawInBackground(graphics, mouseX, mouseY, partialTicks);
-                }
-            }
-        }
-        if (expanded != null && expanded.isVisible()) {
-            graphics.pose().pushPose();
-            graphics.pose().translate(0, 0, 300);
-            RenderSystem.setShaderColor(1, 1, 1, 1);
-            RenderSystem.enableBlend();
-            if (expanded.inAnimate()) {
-                expanded.getAnimation().drawInBackground(graphics, mouseX, mouseY, partialTicks);
-            } else {
-                expanded.drawInBackground(graphics, mouseX, mouseY, partialTicks);
-            }
-            graphics.pose().popPose();
-        }
-    }
-
-    @Override
-    @OnlyIn(Dist.CLIENT)
-
-    protected void drawWidgetsForeground(@NotNull GuiGraphics graphics, int mouseX, int mouseY, float partialTicks) {
-        // remove previous tooltip
-        if (isMouseOverElement(mouseX, mouseY)) {
-            gui.getModularUIGui().setHoverTooltip(Collections.emptyList(), ItemStack.EMPTY, null, null);
-        }
-        for (Widget widget : widgets) {
-            if (widget.isVisible() && widget != expanded) {
-                RenderSystem.setShaderColor(1, 1, 1, 1);
-                RenderSystem.enableBlend();
-                if (widget.inAnimate()) {
-                    widget.getAnimation().drawInForeground(graphics, mouseX, mouseY, partialTicks);
-                } else {
-                    widget.drawInForeground(graphics, mouseX, mouseY, partialTicks);
-                }
-            }
-        }
-        if (expanded != null && expanded.isVisible()) {
-            RenderSystem.setShaderColor(1, 1, 1, 1);
-            RenderSystem.enableBlend();
-            if (expanded.inAnimate()) {
-                expanded.getAnimation().drawInForeground(graphics, mouseX, mouseY, partialTicks);
-            } else {
-                expanded.drawInForeground(graphics, mouseX, mouseY, partialTicks);
-            }
-        }
-    }
-
-    @Override
-    @OnlyIn(Dist.CLIENT)
-    public boolean mouseClicked(double mouseX, double mouseY, int button) {
-        if (expanded != null && expanded.isVisible() && expanded.isActive() &&
-                expanded.mouseClicked(mouseX, mouseY, button)) {
-            return true;
-        }
-        return super.mouseClicked(mouseX, mouseY, button);
-    }
-
-    public FloatingTab createFloatingTab(IFancyConfigurator configurator) {
-        return new FloatingTab(configurator);
-    }
-
-    public class Tab extends WidgetGroup {
-
-        protected final IFancyConfigurator configurator;
-        protected final ButtonWidget button;
-        @Nullable
-        protected final WidgetGroup view;
-        // dragging
-        protected double lastDeltaX, lastDeltaY;
-        protected int dragOffsetX, dragOffsetY;
-        protected boolean isDragging;
-
-        public Tab(IFancyConfigurator configurator) {
-            super(0, tabs.size() * (getTabSize() + 2), getTabSize(), getTabSize());
-            this.configurator = configurator;
-            this.button = new ButtonWidget(0, 0, getTabSize(), getTabSize(), null, this::onClick) {
-
-                @Override
-                public boolean mouseWheelMove(double mouseX, double mouseY, double wheelDelta) {
-                    if (!(configurator instanceof IFancyCustomMouseWheelAction hasActions)) return false;
-                    if (isMouseOverElement(mouseX, mouseY))
-                        return hasActions.mouseWheelMove(this::writeClientAction, mouseX, mouseY, wheelDelta);
-                    return false;
-                }
-
-                @Override
-                public void handleClientAction(int id, FriendlyByteBuf buffer) {
-                    if (configurator instanceof IFancyCustomClientActionHandler handler && id > 1)
-                        handler.handleClientAction(id, buffer);
-                    else
-                        super.handleClientAction(id, buffer);
-                }
-            };
-            if (configurator instanceof IFancyConfiguratorButton) {
-                this.view = null;
-                this.addWidget(button);
-            } else {
-                var widget = configurator.createConfigurator();
-                widget.setSelfPosition(new Position(border, getTabSize()));
-
-                this.view = new WidgetGroup(0, 0, 0, 0) {
-
-                    @Override
-                    protected void onChildSizeUpdate(Widget child) {
-                        super.onChildSizeUpdate(child);
-                        if (widget == child) {
-                            this.setSize(new Size(widget.getSize().width + border * 2,
-                                    widget.getSize().height + getTabSize() + border));
-                        }
-                    }
-                };
-
-                this.view.setVisible(false);
-                this.view.setActive(false);
-                this.view.setSize(new Size(widget.getSize().width + border * 2,
-                        widget.getSize().height + button.getSize().height + border));
-                this.view.addWidget(widget);
-                this.view.addWidget(new ImageWidget(border + 5, border, widget.getSize().width - getTabSize() - 5,
-                        getTabSize() - border,
-                        new TextTexture(configurator.getTitle().getString())
-                                .setType(TextTexture.TextType.LEFT_HIDE)
-                                .setWidth(widget.getSize().width - getTabSize())));
-                this.addWidget(button);
-                this.addWidget(view);
-            }
-        }
-
-        @Override
-        public void writeInitialData(FriendlyByteBuf buffer) {
-            super.writeInitialData(buffer);
-            configurator.writeInitialData(buffer);
-        }
-
-        @Override
-        public void readInitialData(FriendlyByteBuf buffer) {
-            super.readInitialData(buffer);
-            configurator.readInitialData(buffer);
-        }
-
-        @Override
-        public void detectAndSendChanges() {
-            super.detectAndSendChanges();
-            configurator.detectAndSendChange((id, sender) -> writeUpdateInfo(0, buf -> {
-                buf.writeVarInt(id);
-                sender.accept(buf);
-            }));
-        }
-
-        @Override
-        public void readUpdateInfo(int id, FriendlyByteBuf buffer) {
-            if (id == 0) {
-                configurator.readUpdateInfo(buffer.readVarInt(), buffer);
-            } else {
-                super.readUpdateInfo(id, buffer);
-            }
-        }
-
-        @Override
-        protected void onChildSizeUpdate(Widget child) {
-            if (this.view != null && this.view == child) {
-                if (expanded == this) {
-                    var size = view.getSize();
-                    animation(new Animation()
-                            .duration(getAnimationTime())
-                            .position(new Position(dragOffsetX + (-size.width + (tabs.size() > 1 ? -2 : getTabSize())),
-                                    dragOffsetY))
-                            .size(size)
-                            .ease(Eases.EaseQuadOut)
-                            .onFinish(() -> {
-                                view.setVisible(true);
-                                view.setActive(true);
-                            }));
-                }
-            }
-        }
-
-        private void onClick(ClickData clickData) {
-            if (clickData.button == 2 && configurator instanceof IFancyCustomMiddleClickAction middleAction) {
-                middleAction.onMiddleClick(this::writeClientAction);
-            } else if (configurator instanceof IFancyConfiguratorButton fancyButton) {
-                fancyButton.onClick(clickData);
-            } else {
-                if (expanded == this) {
-                    collapseTab();
-                } else {
-                    expandTab(this);
-                }
-            }
-        }
-
-        @Override
-        public void setSize(Size size) {
-            super.setSize(size);
-            button.setSelfPosition(new Position(size.width - getTabSize(), 0));
-        }
-
-        private void expand() {
-            if (view == null) return;
-            var size = view.getSize();
-            this.dragOffsetX = 0;
-            this.dragOffsetY = 0;
-            if (isRemote()) {
-                if (getParentPosition().x - size.width + (tabs.size() > 1 ? -2 : getTabSize()) < 0) {
-                    this.dragOffsetX -= (view.getParentPosition().x - size.width +
-                            (tabs.size() > 1 ? -2 : getTabSize()));
-                }
-                if (getParentPosition().y + size.height > gui.getScreenHeight()) {
-                    this.dragOffsetY -= view.getParentPosition().y + size.height - gui.getScreenHeight();
-                }
-            }
-            Position position = new Position(dragOffsetX - size.width + (tabs.size() > 1 ? -2 : getTabSize()),
-                    dragOffsetY);
-
-            animation(new Animation()
-                    .duration(getAnimationTime())
-                    .position(position)
-                    .size(size)
-                    .ease(Eases.EaseQuadOut)
-                    .onFinish(() -> {
-                        view.setVisible(true);
-                        view.setActive(true);
-                    }));
-        }
-
-        protected void collapseTo(int x, int y) {
-            if (view != null) {
-                view.setVisible(false);
-                view.setActive(false);
-            }
-            animation(new Animation()
-                    .duration(getAnimationTime())
-                    .position(new Position(x, y))
-                    .size(new Size(getTabSize(), getTabSize()))
-                    .ease(Eases.EaseQuadOut));
-        }
-
-        @Override
-        @OnlyIn(Dist.CLIENT)
-        public void drawInBackground(@NotNull GuiGraphics graphics, int mouseX, int mouseY, float partialTicks) {
-            drawBackgroundTexture(graphics, mouseX, mouseY);
-            var position = getPosition();
-            var size = getSize();
-            if (inAnimate()) {
-                graphics.enableScissor(position.x + border - 1, position.y + border - 1,
-                        position.x + border - 1 + size.width - (border - 1) * 2,
-                        position.y + border - 1 + size.height - (border - 1) * 2);
-                drawWidgetsBackground(graphics, mouseX, mouseY, partialTicks);
-                graphics.disableScissor();
-            } else {
-                drawWidgetsBackground(graphics, mouseX, mouseY, partialTicks);
-            }
-            configurator.getIcon().draw(graphics, mouseX, mouseY, position.x + size.width - 20, position.y + 4, 16, 16);
-        }
-
-        @Override
-        @OnlyIn(Dist.CLIENT)
-        public void drawInForeground(@NotNull GuiGraphics graphics, int mouseX, int mouseY, float partialTicks) {
-            super.drawInForeground(graphics, mouseX, mouseY, partialTicks);
-            if (isMouseOver(getPosition().x + getSize().width - 20, getPosition().y + 4, 16, 16, mouseX, mouseY) &&
-                    gui != null && gui.getModularUIGui() != null) {
-                gui.getModularUIGui().setHoverTooltip(configurator.getTooltips(), ItemStack.EMPTY, null, null);
-            }
-        }
-
-        @Override
-        @OnlyIn(Dist.CLIENT)
-        public boolean mouseClicked(double mouseX, double mouseY, int button) {
-            this.lastDeltaX = 0;
-            this.lastDeltaY = 0;
-            this.isDragging = false;
-            if (expanded == this && isMouseOver(getPosition().x, getPosition().y, getSize().width - getTabSize(),
-                    getTabSize(), mouseX, mouseY)) {
-                isDragging = true;
-                return true;
-            }
-            return super.mouseClicked(mouseX, mouseY, button) || isMouseOverElement(mouseX, mouseY);
-        }
-
-        @Override
-        @OnlyIn(Dist.CLIENT)
-        public boolean mouseDragged(double mouseX, double mouseY, int button, double dragX, double dragY) {
-            double dx = dragX + lastDeltaX;
-            double dy = dragY + lastDeltaY;
-            dragX = (int) dx;
-            dragY = (int) dy;
-            lastDeltaX = dx - dragX;
-            lastDeltaY = dy - dragY;
-            if (isDragging) {
-                this.dragOffsetX += (int) dragX;
-                this.dragOffsetY += (int) dragY;
-                this.addSelfPosition((int) dragX, (int) dragY);
-            }
-            return super.mouseDragged(mouseX, mouseY, button, dragX, dragY) || isMouseOverElement(mouseX, mouseY);
-        }
-
-        @Override
-        @OnlyIn(Dist.CLIENT)
-        public boolean mouseReleased(double mouseX, double mouseY, int button) {
-            this.lastDeltaX = 0;
-            this.lastDeltaY = 0;
-            this.isDragging = false;
-            return super.mouseReleased(mouseX, mouseY, button) || isMouseOverElement(mouseX, mouseY);
-        }
-
-        @Override
-        @OnlyIn(Dist.CLIENT)
-        public boolean mouseWheelMove(double mouseX, double mouseY, double wheelDelta) {
-            return super.mouseWheelMove(mouseX, mouseY, wheelDelta) || isMouseOverElement(mouseX, mouseY);
-        }
-
-        @Override
-        @OnlyIn(Dist.CLIENT)
-        public boolean mouseMoved(double mouseX, double mouseY) {
-            return super.mouseMoved(mouseX, mouseY) || isMouseOverElement(mouseX, mouseY);
-        }
-    }
-
-    public class FloatingTab extends Tab {
-
-        protected Runnable closeCallback = () -> {};
-
-        public FloatingTab(IFancyConfigurator configurator) {
-            super(configurator);
-            this.view.setBackground(GuiTextures.BACKGROUND);
-        }
-
-        @Override
-        public void collapseTo(int x, int y) {
-            super.collapseTo(x, y);
-            ConfiguratorPanel.this.removeWidget(this);
-            closeCallback.run();
-        }
-
-        public void onClose(Runnable closeCallback) {
-            this.closeCallback = closeCallback;
-        }
-    }
-
-    private static int getAnimationTime() {
-        return ConfigHolder.INSTANCE.client.animationTime;
-    }
-}
diff --git a/src/main/java/com/gregtechceu/gtceu/api/gui/fancy/FancyMachineUIWidget.java b/src/main/java/com/gregtechceu/gtceu/api/gui/fancy/FancyMachineUIWidget.java
deleted file mode 100644
index 5e62d3bf958..00000000000
--- a/src/main/java/com/gregtechceu/gtceu/api/gui/fancy/FancyMachineUIWidget.java
+++ /dev/null
@@ -1,242 +0,0 @@
-package com.gregtechceu.gtceu.api.gui.fancy;
-
-import com.gregtechceu.gtceu.GTCEu;
-import com.gregtechceu.gtceu.api.gui.GuiTextures;
-import com.gregtechceu.gtceu.config.ConfigHolder;
-
-import com.lowdragmc.lowdraglib.gui.texture.IGuiTexture;
-import com.lowdragmc.lowdraglib.gui.util.ClickData;
-import com.lowdragmc.lowdraglib.gui.widget.WidgetGroup;
-import com.lowdragmc.lowdraglib.gui.widget.custom.PlayerInventoryWidget;
-import com.lowdragmc.lowdraglib.utils.Position;
-import com.lowdragmc.lowdraglib.utils.Size;
-
-import lombok.Getter;
-import lombok.Setter;
-import org.jetbrains.annotations.Nullable;
-
-import java.util.ArrayDeque;
-import java.util.Deque;
-import java.util.List;
-import java.util.stream.Stream;
-
-@Getter
-public class FancyMachineUIWidget extends WidgetGroup {
-
-    protected final TitleBarWidget titleBar;
-    protected final VerticalTabsWidget sideTabsWidget;
-    protected final WidgetGroup pageContainer;
-    protected final PageSwitcher pageSwitcher;
-    protected final ConfiguratorPanel configuratorPanel;
-    protected final TooltipsPanel tooltipsPanel;
-
-    @Nullable
-    protected final PlayerInventoryWidget playerInventory;
-    @Setter
-    protected int border = 4;
-
-    protected final IFancyUIProvider mainPage;
-
-    /*
-     * Current Page: The page visible in the UI
-     * Current Home Page: The currently selected multiblock part's home page.
-     */
-    protected IFancyUIProvider currentPage;
-    protected IFancyUIProvider currentHomePage;
-
-    protected List<IFancyUIProvider> allPages;
-
-    protected Deque<NavigationEntry> previousPages = new ArrayDeque<>();
-
-    protected record NavigationEntry(IFancyUIProvider page, IFancyUIProvider homePage, Runnable onNavigation) {}
-
-    public FancyMachineUIWidget(IFancyUIProvider mainPage, int width, int height) {
-        super(0, 0, width, height);
-        this.mainPage = mainPage;
-
-        addWidget(this.pageContainer = new WidgetGroup(0, 0, width, height));
-
-        if (mainPage.hasPlayerInventory()) {
-            addWidget(this.playerInventory = new PlayerInventoryWidget());
-            this.playerInventory.setSelfPosition(new Position(2, height - 86));
-            this.playerInventory.setBackground((IGuiTexture) null);
-        } else {
-            playerInventory = null;
-        }
-
-        addWidget(this.titleBar = new TitleBarWidget(width, this::navigateBack, this::openPageSwitcher));
-        addWidget(this.sideTabsWidget = new VerticalTabsWidget(this::navigate, -20, 0, 24, height));
-        addWidget(this.tooltipsPanel = new TooltipsPanel());
-        addWidget(this.configuratorPanel = new ConfiguratorPanel(-(24 + 2), height));
-        this.pageSwitcher = new PageSwitcher(this::switchPage);
-
-        setBackground(GuiTextures.BACKGROUND.copy()
-                .setColor(Long.decode(ConfigHolder.INSTANCE.client.defaultUIColor).intValue() | 0xFF000000));
-    }
-
-    @Override
-    public void initWidget() {
-        super.initWidget();
-
-        if (this.playerInventory != null) {
-            this.playerInventory.setPlayer(gui.entityPlayer);
-        }
-
-        this.allPages = Stream.concat(Stream.of(this.mainPage), this.mainPage.getSubTabs().stream()).toList();
-
-        performNavigation(this.mainPage, this.mainPage);
-    }
-
-    ////////////////////////////////////////
-    // ********* NAVIGATION *********//
-    ////////////////////////////////////////
-
-    protected void navigate(IFancyUIProvider newPage) {
-        navigate(newPage, this.currentHomePage);
-    }
-
-    protected void navigate(IFancyUIProvider nextPage, IFancyUIProvider nextHomePage) {
-        if (nextPage != mainPage) {
-            if (!this.previousPages.isEmpty() && this.previousPages.peek().page == nextPage) {
-                // In case the user manually navigates back one step, just remove it from the navigation stack
-                this.previousPages.pop();
-            } else if (this.currentPage != null) {
-                this.previousPages.push(new NavigationEntry(this.currentPage, this.currentHomePage, () -> {}));
-            }
-        } else {
-            this.previousPages.clear();
-        }
-
-        performNavigation(nextPage, nextHomePage);
-    }
-
-    protected void navigateBack(ClickData clickData) {
-        NavigationEntry navigationEntry = previousPages.pop();
-
-        performNavigation(navigationEntry.page, navigationEntry.homePage);
-        navigationEntry.onNavigation.run();
-    }
-
-    protected void performNavigation(IFancyUIProvider nextPage, IFancyUIProvider nextHomePage) {
-        if (currentHomePage != nextHomePage)
-            setupSideTabs(nextHomePage);
-
-        this.currentPage = nextPage;
-        this.currentHomePage = nextHomePage;
-
-        if (currentPage != currentHomePage) {
-            // Ensure the home page's basic layout is applied before navigating to another page:
-            setupFancyUI(currentHomePage);
-        }
-
-        setupFancyUI(nextPage, nextPage.hasPlayerInventory());
-    }
-
-    ///////////////////////////////////////////////
-    // *********** PAGE SWITCHER ***********//
-    ///////////////////////////////////////////////
-
-    protected void openPageSwitcher(ClickData clickData) {
-        pageSwitcher.setPageList(allPages, currentHomePage);
-
-        // If we're in another tab of the current page, ensure nav to its main tab when closing the page switcher:
-        if (currentPage != currentHomePage && !previousPages.isEmpty()) {
-            previousPages.pop();
-        }
-
-        this.sideTabsWidget.setVisible(false);
-        this.sideTabsWidget.setActive(false);
-
-        this.previousPages.push(new NavigationEntry(currentHomePage, currentHomePage, () -> {
-            sideTabsWidget.setVisible(true);
-            sideTabsWidget.setActive(true);
-        }));
-
-        this.currentPage = this.pageSwitcher;
-        this.currentHomePage = this.pageSwitcher;
-
-        setupFancyUI(this.pageSwitcher);
-    }
-
-    protected void switchPage(IFancyUIProvider nextHomePage) {
-        // Ensure that the back button always leads back to the main page:
-        this.currentHomePage = mainPage;
-        this.currentPage = mainPage;
-        this.previousPages.clear();
-
-        sideTabsWidget.setVisible(true);
-        sideTabsWidget.setActive(true);
-
-        setupSideTabs(this.currentHomePage);
-        navigate(nextHomePage, nextHomePage);
-    }
-
-    //////////////////////////////////////////////
-    // *********** UI RENDERING ***********//
-    //////////////////////////////////////////////
-
-    protected void setupFancyUI(IFancyUIProvider fancyUI) {
-        this.setupFancyUI(fancyUI, fancyUI.hasPlayerInventory());
-    }
-
-    protected void setupFancyUI(IFancyUIProvider fancyUI, boolean showInventory) {
-        clearUI();
-
-        sideTabsWidget.selectTab(fancyUI);
-        titleBar.updateState(
-                fancyUI,
-                !this.previousPages.isEmpty(),
-                this.allPages.size() > 1 && this.currentPage != this.pageSwitcher);
-
-        var page = fancyUI.createMainPage(this);
-
-        // layout
-        var size = new Size(Math.max(172, page.getSize().width + border * 2),
-                Math.max(86, page.getSize().height + border * 2));
-        setSize(new Size(size.width,
-                size.height + (!showInventory || playerInventory == null ? 0 : playerInventory.getSize().height)));
-        if (GTCEu.isClientSide() && getGui() != null) {
-            getGui().setSize(getSize().width, getSize().height);
-        }
-        this.sideTabsWidget.setSize(new Size(24, size.height));
-        this.pageContainer.setSize(size);
-        this.tooltipsPanel.setSelfPosition(new Position(size.width + 2, 2));
-
-        setupInventoryPosition(showInventory, size);
-
-        // setup
-        this.pageContainer.addWidget(page);
-        page.setSelfPosition(new Position(
-                (pageContainer.getSize().width - page.getSize().width) / 2,
-                (pageContainer.getSize().height - page.getSize().height) / 2));
-        fancyUI.attachConfigurators(configuratorPanel);
-        configuratorPanel
-                .setSelfPosition(new Position(-24 - 2, getGui().getHeight() - configuratorPanel.getSize().height - 4));
-        fancyUI.attachTooltips(tooltipsPanel);
-
-        titleBar.setSize(new Size(this.getSize().width, titleBar.getSize().height));
-    }
-
-    private void setupInventoryPosition(boolean showInventory, Size parentSize) {
-        if (this.playerInventory == null)
-            return;
-
-        this.playerInventory.setSelfPosition(new Position(
-                (parentSize.width - playerInventory.getSize().width) / 2,
-                parentSize.height));
-
-        this.playerInventory.setActive(showInventory);
-        this.playerInventory.setVisible(showInventory);
-    }
-
-    protected void clearUI() {
-        this.pageContainer.clearAllWidgets();
-        this.configuratorPanel.clear();
-        this.tooltipsPanel.clear();
-    }
-
-    protected void setupSideTabs(IFancyUIProvider currentHomePage) {
-        this.sideTabsWidget.clearSubTabs();
-        currentHomePage.attachSideTabs(sideTabsWidget);
-    }
-}
diff --git a/src/main/java/com/gregtechceu/gtceu/api/gui/fancy/IFancyConfigurator.java b/src/main/java/com/gregtechceu/gtceu/api/gui/fancy/IFancyConfigurator.java
deleted file mode 100644
index c60ff187844..00000000000
--- a/src/main/java/com/gregtechceu/gtceu/api/gui/fancy/IFancyConfigurator.java
+++ /dev/null
@@ -1,32 +0,0 @@
-package com.gregtechceu.gtceu.api.gui.fancy;
-
-import com.lowdragmc.lowdraglib.gui.texture.IGuiTexture;
-import com.lowdragmc.lowdraglib.gui.widget.Widget;
-
-import net.minecraft.network.FriendlyByteBuf;
-import net.minecraft.network.chat.Component;
-
-import java.util.List;
-import java.util.function.BiConsumer;
-import java.util.function.Consumer;
-
-public interface IFancyConfigurator {
-
-    Component getTitle();
-
-    IGuiTexture getIcon();
-
-    Widget createConfigurator();
-
-    default List<Component> getTooltips() {
-        return List.of(getTitle());
-    }
-
-    default void detectAndSendChange(BiConsumer<Integer, Consumer<FriendlyByteBuf>> sender) {}
-
-    default void readUpdateInfo(int id, FriendlyByteBuf buf) {}
-
-    default void writeInitialData(FriendlyByteBuf buffer) {}
-
-    default void readInitialData(FriendlyByteBuf buffer) {}
-}
diff --git a/src/main/java/com/gregtechceu/gtceu/api/gui/fancy/IFancyConfiguratorButton.java b/src/main/java/com/gregtechceu/gtceu/api/gui/fancy/IFancyConfiguratorButton.java
deleted file mode 100644
index 0708b49eccc..00000000000
--- a/src/main/java/com/gregtechceu/gtceu/api/gui/fancy/IFancyConfiguratorButton.java
+++ /dev/null
@@ -1,96 +0,0 @@
-package com.gregtechceu.gtceu.api.gui.fancy;
-
-import com.lowdragmc.lowdraglib.gui.texture.IGuiTexture;
-import com.lowdragmc.lowdraglib.gui.util.ClickData;
-import com.lowdragmc.lowdraglib.gui.widget.Widget;
-
-import net.minecraft.network.FriendlyByteBuf;
-import net.minecraft.network.chat.Component;
-
-import lombok.Setter;
-import lombok.experimental.Accessors;
-import org.apache.commons.lang3.NotImplementedException;
-
-import java.util.Collections;
-import java.util.List;
-import java.util.function.BiConsumer;
-import java.util.function.BooleanSupplier;
-import java.util.function.Consumer;
-import java.util.function.Function;
-
-public interface IFancyConfiguratorButton extends IFancyConfigurator {
-
-    void onClick(ClickData clickData);
-
-    @Override
-    default Component getTitle() {
-        throw new NotImplementedException();
-    }
-
-    @Override
-    default Widget createConfigurator() {
-        throw new NotImplementedException();
-    }
-
-    @Accessors(chain = true)
-    class Toggle implements IFancyConfiguratorButton {
-
-        IGuiTexture base;
-        IGuiTexture pressed;
-        BiConsumer<ClickData, Boolean> onClick;
-        BooleanSupplier booleanSupplier;
-        boolean isPressed;
-        @Setter
-        Function<Boolean, List<Component>> tooltipsSupplier = isPressed -> Collections.emptyList();
-
-        public Toggle(IGuiTexture base, IGuiTexture pressed, BooleanSupplier booleanSupplier,
-                      BiConsumer<ClickData, Boolean> onClick) {
-            this.base = base;
-            this.pressed = pressed;
-            this.booleanSupplier = booleanSupplier;
-            this.onClick = onClick;
-        }
-
-        @Override
-        public List<Component> getTooltips() {
-            return tooltipsSupplier.apply(isPressed);
-        }
-
-        @Override
-        public void detectAndSendChange(BiConsumer<Integer, Consumer<FriendlyByteBuf>> sender) {
-            var newIsPressed = booleanSupplier.getAsBoolean();
-            if (newIsPressed != isPressed) {
-                isPressed = newIsPressed;
-                sender.accept(0, buf -> buf.writeBoolean(isPressed));
-            }
-        }
-
-        @Override
-        public void readUpdateInfo(int id, FriendlyByteBuf buf) {
-            if (id == 0) {
-                isPressed = buf.readBoolean();
-            }
-        }
-
-        @Override
-        public void writeInitialData(FriendlyByteBuf buffer) {
-            this.isPressed = booleanSupplier.getAsBoolean();
-            buffer.writeBoolean(this.isPressed);
-        }
-
-        @Override
-        public void readInitialData(FriendlyByteBuf buffer) {
-            this.isPressed = buffer.readBoolean();
-        }
-
-        @Override
-        public IGuiTexture getIcon() {
-            return isPressed ? pressed : base;
-        }
-
-        @Override
-        public void onClick(ClickData clickData) {
-            onClick.accept(clickData, !isPressed);
-        }
-    }
-}
diff --git a/src/main/java/com/gregtechceu/gtceu/api/gui/fancy/IFancyCustomClientActionHandler.java b/src/main/java/com/gregtechceu/gtceu/api/gui/fancy/IFancyCustomClientActionHandler.java
deleted file mode 100644
index f9b354cf1f9..00000000000
--- a/src/main/java/com/gregtechceu/gtceu/api/gui/fancy/IFancyCustomClientActionHandler.java
+++ /dev/null
@@ -1,8 +0,0 @@
-package com.gregtechceu.gtceu.api.gui.fancy;
-
-import net.minecraft.network.FriendlyByteBuf;
-
-public interface IFancyCustomClientActionHandler {
-
-    default void handleClientAction(int id, FriendlyByteBuf buffer) {}
-}
diff --git a/src/main/java/com/gregtechceu/gtceu/api/gui/fancy/IFancyCustomMiddleClickAction.java b/src/main/java/com/gregtechceu/gtceu/api/gui/fancy/IFancyCustomMiddleClickAction.java
deleted file mode 100644
index 489f6e091f8..00000000000
--- a/src/main/java/com/gregtechceu/gtceu/api/gui/fancy/IFancyCustomMiddleClickAction.java
+++ /dev/null
@@ -1,11 +0,0 @@
-package com.gregtechceu.gtceu.api.gui.fancy;
-
-import net.minecraft.network.FriendlyByteBuf;
-
-import java.util.function.BiConsumer;
-import java.util.function.Consumer;
-
-public interface IFancyCustomMiddleClickAction extends IFancyCustomClientActionHandler {
-
-    default void onMiddleClick(BiConsumer<Integer, Consumer<FriendlyByteBuf>> writeClientAction) {}
-}
diff --git a/src/main/java/com/gregtechceu/gtceu/api/gui/fancy/IFancyCustomMouseWheelAction.java b/src/main/java/com/gregtechceu/gtceu/api/gui/fancy/IFancyCustomMouseWheelAction.java
deleted file mode 100644
index fb5213912a9..00000000000
--- a/src/main/java/com/gregtechceu/gtceu/api/gui/fancy/IFancyCustomMouseWheelAction.java
+++ /dev/null
@@ -1,14 +0,0 @@
-package com.gregtechceu.gtceu.api.gui.fancy;
-
-import net.minecraft.network.FriendlyByteBuf;
-
-import java.util.function.BiConsumer;
-import java.util.function.Consumer;
-
-public interface IFancyCustomMouseWheelAction extends IFancyCustomClientActionHandler {
-
-    default boolean mouseWheelMove(BiConsumer<Integer, Consumer<FriendlyByteBuf>> writeClientAction, double mouseX,
-                                   double mouseY, double wheelDelta) {
-        return false;
-    }
-}
diff --git a/src/main/java/com/gregtechceu/gtceu/api/gui/fancy/IFancyTooltip.java b/src/main/java/com/gregtechceu/gtceu/api/gui/fancy/IFancyTooltip.java
deleted file mode 100644
index a0af005a9cf..00000000000
--- a/src/main/java/com/gregtechceu/gtceu/api/gui/fancy/IFancyTooltip.java
+++ /dev/null
@@ -1,53 +0,0 @@
-package com.gregtechceu.gtceu.api.gui.fancy;
-
-import com.lowdragmc.lowdraglib.gui.texture.IGuiTexture;
-
-import net.minecraft.network.chat.Component;
-import net.minecraft.world.inventory.tooltip.TooltipComponent;
-
-import org.jetbrains.annotations.Nullable;
-
-import java.util.List;
-import java.util.function.BooleanSupplier;
-import java.util.function.Supplier;
-
-public interface IFancyTooltip {
-
-    IGuiTexture getFancyTooltipIcon();
-
-    List<Component> getFancyTooltip();
-
-    default boolean showFancyTooltip() {
-        return true;
-    }
-
-    @Nullable
-    default TooltipComponent getFancyComponent() {
-        return null;
-    }
-
-    record Basic(Supplier<IGuiTexture> icon, Supplier<List<Component>> content, BooleanSupplier predicate,
-                 Supplier<TooltipComponent> componentSupplier)
-            implements IFancyTooltip {
-
-        @Override
-        public IGuiTexture getFancyTooltipIcon() {
-            return icon.get();
-        }
-
-        @Override
-        public List<Component> getFancyTooltip() {
-            return content.get();
-        }
-
-        @Override
-        public @Nullable TooltipComponent getFancyComponent() {
-            return componentSupplier.get();
-        }
-
-        @Override
-        public boolean showFancyTooltip() {
-            return predicate.getAsBoolean();
-        }
-    }
-}
diff --git a/src/main/java/com/gregtechceu/gtceu/api/gui/fancy/IFancyUIProvider.java b/src/main/java/com/gregtechceu/gtceu/api/gui/fancy/IFancyUIProvider.java
deleted file mode 100644
index b5d878fcdc5..00000000000
--- a/src/main/java/com/gregtechceu/gtceu/api/gui/fancy/IFancyUIProvider.java
+++ /dev/null
@@ -1,78 +0,0 @@
-package com.gregtechceu.gtceu.api.gui.fancy;
-
-import com.lowdragmc.lowdraglib.gui.texture.IGuiTexture;
-import com.lowdragmc.lowdraglib.gui.widget.Widget;
-
-import net.minecraft.network.chat.Component;
-import net.minecraft.world.inventory.tooltip.TooltipComponent;
-
-import org.jetbrains.annotations.Nullable;
-
-import java.util.Collections;
-import java.util.List;
-
-public interface IFancyUIProvider {
-
-    /**
-     * Create the main page ui.
-     */
-    Widget createMainPage(FancyMachineUIWidget widget);
-
-    /**
-     * Get the tab icon of this page.
-     */
-    IGuiTexture getTabIcon();
-
-    /**
-     * Get the title of this page.
-     */
-    Component getTitle();
-
-    /**
-     * Attach configurators to the left subtab list.
-     */
-    default void attachSideTabs(TabsWidget configuratorPanel) {}
-
-    /**
-     * Attach configurators to the left panel.
-     */
-    default void attachConfigurators(ConfiguratorPanel configuratorPanel) {}
-
-    /**
-     * Attach tooltips to the right panel
-     */
-    default void attachTooltips(TooltipsPanel tooltipsPanel) {}
-
-    default boolean hasPlayerInventory() {
-        return true;
-    }
-
-    /**
-     * Get sub tabs, for example, multiblock will show all its parts tabs.
-     */
-    default List<IFancyUIProvider> getSubTabs() {
-        return Collections.emptyList();
-    }
-
-    /**
-     * Get tab's Tooltips
-     */
-    default List<Component> getTabTooltips() {
-        return Collections.emptyList();
-    }
-
-    /**
-     * Get tab's Tooltips Component
-     */
-    @Nullable
-    default TooltipComponent getTabTooltipComponent() {
-        return null;
-    }
-
-    @Nullable
-    default PageGroupingData getPageGroupingData() {
-        return null;
-    }
-
-    record PageGroupingData(@Nullable String groupKey, int groupPositionWeight) {}
-}
diff --git a/src/main/java/com/gregtechceu/gtceu/api/gui/fancy/PageSwitcher.java b/src/main/java/com/gregtechceu/gtceu/api/gui/fancy/PageSwitcher.java
deleted file mode 100644
index 20c76d3945d..00000000000
--- a/src/main/java/com/gregtechceu/gtceu/api/gui/fancy/PageSwitcher.java
+++ /dev/null
@@ -1,100 +0,0 @@
-package com.gregtechceu.gtceu.api.gui.fancy;
-
-import com.gregtechceu.gtceu.api.gui.GuiTextures;
-
-import com.lowdragmc.lowdraglib.gui.texture.IGuiTexture;
-import com.lowdragmc.lowdraglib.gui.texture.TextTexture;
-import com.lowdragmc.lowdraglib.gui.widget.*;
-
-import net.minecraft.ChatFormatting;
-import net.minecraft.MethodsReturnNonnullByDefault;
-import net.minecraft.network.chat.Component;
-
-import org.apache.commons.lang3.mutable.MutableInt;
-
-import java.util.Comparator;
-import java.util.List;
-import java.util.Objects;
-import java.util.function.Consumer;
-import java.util.stream.Collectors;
-
-import javax.annotation.ParametersAreNonnullByDefault;
-
-@MethodsReturnNonnullByDefault
-@ParametersAreNonnullByDefault
-public class PageSwitcher implements IFancyUIProvider {
-
-    private final Consumer<IFancyUIProvider> onPageSwitched;
-
-    private List<IFancyUIProvider> pages = List.of();
-    private IFancyUIProvider currentPage = null;
-
-    public PageSwitcher(Consumer<IFancyUIProvider> onPageSwitched) {
-        this.onPageSwitched = onPageSwitched;
-    }
-
-    public void setPageList(List<IFancyUIProvider> allPages, IFancyUIProvider currentPage) {
-        this.pages = allPages;
-        this.currentPage = currentPage;
-    }
-
-    @Override
-    public Widget createMainPage(FancyMachineUIWidget widget) {
-        var container = new WidgetGroup(0, 0, 176, 166);
-
-        var scrollableGroup = new DraggableScrollableWidgetGroup(10, 10, 156, 146);
-        scrollableGroup.setYScrollBarWidth(8);
-        scrollableGroup.setYBarStyle(GuiTextures.SLIDER_BACKGROUND_VERTICAL, GuiTextures.BUTTON);
-        container.addWidget(scrollableGroup);
-
-        var groupedPages = pages.stream().collect(Collectors.groupingBy(
-                page -> Objects.requireNonNullElse(page.getPageGroupingData(), new PageGroupingData(null, -1))));
-
-        final MutableInt currentY = new MutableInt(0);
-        groupedPages.keySet().stream()
-                .sorted(Comparator.comparingInt(PageGroupingData::groupPositionWeight))
-                .forEachOrdered(group -> {
-                    if (group.groupKey() != null) {
-                        scrollableGroup.addWidget(
-                                new LabelWidget(0, currentY.getAndAdd(12), group.groupKey()).setDropShadow(false));
-                    }
-
-                    final var currentPage = new MutableInt(0);
-                    currentY.subtract(30); // To account for adding it back on the first page inside this group
-
-                    groupedPages.get(group).forEach(page -> {
-                        var index = currentPage.getAndIncrement();
-                        var y = currentY.addAndGet(index % 5 == 0 ? 30 : 0); // Jump to the next row every 5 parts
-
-                        var pageWidget = new WidgetGroup((index % 5) * 30, y, 25, 25);
-                        pageWidget.addWidget(new ButtonWidget(0, 0, 25, 25, GuiTextures.BACKGROUND,
-                                clickData -> onPageSwitched.accept(page)));
-                        pageWidget.addWidget(new ImageWidget(4, 4, 17, 17, page.getTabIcon()));
-                        // For some reason, this doesn't work in any other way:
-                        pageWidget.widgets.get(0).setHoverTooltips(page.getTitle().getString());
-                        scrollableGroup.addWidget(pageWidget);
-                    });
-
-                    if (!groupedPages.get(group).isEmpty()) {
-                        currentY.add(30);
-                    }
-                });
-
-        return container;
-    }
-
-    @Override
-    public IGuiTexture getTabIcon() {
-        return new TextTexture("+").setDropShadow(false).setColor(ChatFormatting.BLACK.getColor());
-    }
-
-    @Override
-    public Component getTitle() {
-        return Component.translatable("gtceu.gui.title_bar.page_switcher");
-    }
-
-    @Override
-    public boolean hasPlayerInventory() {
-        return false;
-    }
-}
diff --git a/src/main/java/com/gregtechceu/gtceu/api/gui/fancy/TabsWidget.java b/src/main/java/com/gregtechceu/gtceu/api/gui/fancy/TabsWidget.java
deleted file mode 100644
index e30d94a8280..00000000000
--- a/src/main/java/com/gregtechceu/gtceu/api/gui/fancy/TabsWidget.java
+++ /dev/null
@@ -1,261 +0,0 @@
-package com.gregtechceu.gtceu.api.gui.fancy;
-
-import com.gregtechceu.gtceu.api.gui.GuiTextures;
-
-import com.lowdragmc.lowdraglib.gui.editor.Icons;
-import com.lowdragmc.lowdraglib.gui.texture.GuiTextureGroup;
-import com.lowdragmc.lowdraglib.gui.texture.IGuiTexture;
-import com.lowdragmc.lowdraglib.gui.texture.ResourceTexture;
-import com.lowdragmc.lowdraglib.gui.widget.Widget;
-
-import net.minecraft.client.gui.GuiGraphics;
-import net.minecraft.network.FriendlyByteBuf;
-import net.minecraft.util.Mth;
-import net.minecraft.world.item.ItemStack;
-import net.minecraftforge.api.distmarker.Dist;
-import net.minecraftforge.api.distmarker.OnlyIn;
-
-import lombok.Getter;
-import lombok.Setter;
-import org.jetbrains.annotations.NotNull;
-import org.jetbrains.annotations.Nullable;
-
-import java.util.ArrayList;
-import java.util.List;
-import java.util.function.BiConsumer;
-import java.util.function.Consumer;
-
-@Getter
-public class TabsWidget extends Widget {
-
-    protected final Consumer<IFancyUIProvider> onTabClick;
-    protected IFancyUIProvider mainTab;
-    protected List<IFancyUIProvider> subTabs;
-    @Nullable
-    protected IFancyUIProvider selectedTab;
-    @Setter
-    protected IGuiTexture leftButtonTexture = new GuiTextureGroup(GuiTextures.BUTTON, Icons.LEFT.copy().scale(0.7f)),
-            leftButtonHoverTexture = new GuiTextureGroup(GuiTextures.BUTTON,
-                    Icons.LEFT.copy().setColor(0xffaaaaaa).scale(0.7f));
-    @Setter
-    protected IGuiTexture rightButtonTexture = new GuiTextureGroup(GuiTextures.BUTTON, Icons.RIGHT.copy().scale(0.7f)),
-            rightButtonHoverTexture = new GuiTextureGroup(GuiTextures.BUTTON,
-                    Icons.RIGHT.copy().setColor(0xffaaaaaa).scale(0.7f));
-    @Setter
-    protected IGuiTexture tabTexture = new ResourceTexture("gtceu:textures/gui/tab/tabs_top.png").getSubTexture(1 / 3f,
-            0, 1 / 3f, 0.5f);
-    @Setter
-    protected IGuiTexture tabHoverTexture = new ResourceTexture("gtceu:textures/gui/tab/tabs_top.png")
-            .getSubTexture(1 / 3f, 0.5f, 1 / 3f, 0.5f);
-    @Setter
-    protected IGuiTexture tabPressedTexture = tabHoverTexture;
-    @Getter
-    protected int offset;
-    /**
-     * (old tab, new tab)
-     */
-    @Setter
-    @Nullable
-    protected BiConsumer<IFancyUIProvider, IFancyUIProvider> onTabSwitch;
-
-    public TabsWidget(Consumer<IFancyUIProvider> onTabClick) {
-        this(onTabClick, 0, -20, 200, 24);
-    }
-
-    public TabsWidget(Consumer<IFancyUIProvider> onTabClick, int x, int y, int width, int height) {
-        super(x, y, width, height);
-        this.subTabs = new ArrayList<>();
-        this.onTabClick = onTabClick;
-    }
-
-    public void setMainTab(IFancyUIProvider mainTab) {
-        this.mainTab = mainTab;
-        if (this.selectedTab == null) {
-            this.selectedTab = this.mainTab;
-        }
-    }
-
-    public void clearSubTabs() {
-        subTabs.clear();
-    }
-
-    public void attachSubTab(IFancyUIProvider subTab) {
-        subTabs.add(subTab);
-    }
-
-    public boolean hasButton() {
-        return (subTabs.size() + 1) * 24 + 16 > getSize().width;
-    }
-
-    @Override
-    public void handleClientAction(int id, FriendlyByteBuf buffer) {
-        super.handleClientAction(id, buffer);
-        if (id == 0) {
-            var index = buffer.readVarInt();
-            var old = selectedTab;
-            if (index < 0) {
-                selectedTab = mainTab;
-            } else if (index < subTabs.size()) {
-                selectedTab = subTabs.get(index);
-            } else {
-                return;
-            }
-            if (onTabSwitch != null) {
-                onTabSwitch.accept(old, selectedTab);
-            }
-            onTabClick.accept(selectedTab);
-        }
-    }
-
-    public int getSubTabsWidth() {
-        return getSize().width - 8 - 24 - 4 - 16 - 8 - 16;
-    }
-
-    @Override
-    @OnlyIn(Dist.CLIENT)
-    public boolean mouseClicked(double mouseX, double mouseY, int button) {
-        if (isMouseOverElement(mouseX, mouseY)) {
-            var hoveredTab = getHoveredTab(mouseX, mouseY);
-            // click tab
-            if (hoveredTab != null && hoveredTab != selectedTab) {
-                if (onTabSwitch != null) {
-                    onTabSwitch.accept(selectedTab, hoveredTab);
-                }
-                selectedTab = hoveredTab;
-                writeClientAction(0,
-                        buf -> buf.writeVarInt(selectedTab == mainTab ? -1 : subTabs.indexOf(selectedTab)));
-                onTabClick.accept(selectedTab);
-                playButtonClickSound();
-            }
-            // click button
-            if (hasButton()) {
-                if (isHoverLeftButton(mouseX, mouseY)) {
-                    offset = Mth.clamp(offset - 24, 0, subTabs.size() * 24 - getSubTabsWidth());
-                    playButtonClickSound();
-                } else if (isHoverRightButton(mouseX, mouseY)) {
-                    offset = Mth.clamp(offset + 24, 0, subTabs.size() * 24 - getSubTabsWidth());
-                    playButtonClickSound();
-                }
-            }
-        }
-        return super.mouseClicked(mouseX, mouseY, button);
-    }
-
-    @Override
-    @OnlyIn(Dist.CLIENT)
-    public boolean mouseWheelMove(double mouseX, double mouseY, double wheelDelta) {
-        var sx = getPosition().x + 8 + 24 + 4 + 16;
-        if (isMouseOver(sx, getPosition().y, getSubTabsWidth(), 24, mouseX, mouseY)) {
-            offset = Mth.clamp(offset + 5 * (wheelDelta > 0 ? -1 : 1), 0, subTabs.size() * 24 - getSubTabsWidth());
-        }
-        return super.mouseWheelMove(mouseX, mouseY, wheelDelta);
-    }
-
-    @Override
-    @OnlyIn(Dist.CLIENT)
-    public void drawInBackground(@NotNull GuiGraphics graphics, int mouseX, int mouseY, float partialTicks) {
-        super.drawInBackground(graphics, mouseX, mouseY, partialTicks);
-        var position = getPosition();
-        var size = getSize();
-        var hoveredTab = getHoveredTab(mouseX, mouseY);
-        // main tab
-        drawTab(mainTab, graphics, mouseX, mouseY, position.x + 8, position.y, 24, 24, hoveredTab);
-        // render sub tabs
-        if (hasButton()) { // need a scrollable bar
-            // render buttons
-            if (isHoverLeftButton(mouseX, mouseY)) {
-                leftButtonHoverTexture.draw(graphics, mouseX, mouseY, position.x + 8 + 24 + 4, position.y, 16, 24);
-            } else {
-                leftButtonTexture.draw(graphics, mouseX, mouseY, position.x + 8 + 24 + 4, position.y, 16, 24);
-            }
-            if (isHoverRightButton(mouseX, mouseY)) {
-                rightButtonHoverTexture.draw(graphics, mouseX, mouseY, position.x + size.width - 8 - 16, position.y, 16,
-                        24);
-            } else {
-                rightButtonTexture.draw(graphics, mouseX, mouseY, position.x + size.width - 8 - 16, position.y, 16, 24);
-            }
-            // render sub tabs
-            var sx = position.x + 8 + 24 + 4 + 16;
-            graphics.enableScissor(sx, position.y - 1, sx + getSubTabsWidth(), position.y - 1 + 24 + 2);
-            for (int i = 0; i < subTabs.size(); i++) {
-                drawTab(subTabs.get(i), graphics, mouseX, mouseY, sx + i * 24 - offset, position.y, 24, 24, hoveredTab);
-            }
-            graphics.disableScissor();
-        } else {
-            for (int i = subTabs.size() - 1; i >= 0; i--) {
-                drawTab(subTabs.get(i), graphics, mouseX, mouseY,
-                        position.x + size.width - 8 - 24 * (subTabs.size() - i), position.y, 24, 24, hoveredTab);
-            }
-        }
-    }
-
-    @Override
-    @OnlyIn(Dist.CLIENT)
-    public void drawInForeground(@NotNull GuiGraphics graphics, int mouseX, int mouseY, float partialTicks) {
-        var hoveredTab = getHoveredTab(mouseX, mouseY);
-        if (hoveredTab != null && gui != null && gui.getModularUIGui() != null) {
-            gui.getModularUIGui().setHoverTooltip(hoveredTab.getTabTooltips(), ItemStack.EMPTY, null,
-                    hoveredTab.getTabTooltipComponent());
-        }
-        super.drawInForeground(graphics, mouseX, mouseY, partialTicks);
-    }
-
-    @OnlyIn(Dist.CLIENT)
-    public boolean isHoverLeftButton(double mouseX, double mouseY) {
-        return isMouseOver(getPosition().x + 8 + 24 + 4, getPosition().y, 16, 24, mouseX, mouseY);
-    }
-
-    @OnlyIn(Dist.CLIENT)
-    public boolean isHoverRightButton(double mouseX, double mouseY) {
-        return isMouseOver(getPosition().x + getSize().width - 8 - 16, getPosition().y, 16, 24, mouseX, mouseY);
-    }
-
-    @OnlyIn(Dist.CLIENT)
-    @Nullable
-    public IFancyUIProvider getHoveredTab(double mouseX, double mouseY) {
-        if (isMouseOverElement(mouseX, mouseY)) {
-            var position = getPosition();
-            var size = getSize();
-            // main tab
-            if (isMouseOver(position.x + 8, position.y, 24, 24, mouseX, mouseY)) {
-                return mainTab;
-            }
-            // others
-            if (hasButton()) { // need a scrollable bar
-                var sx = position.x + 8 + 24 + 4 + 16;
-                if (isMouseOver(sx, position.y, getSubTabsWidth(), 24, mouseX, mouseY)) {
-                    var i = ((int) mouseX - sx + getOffset()) / 24;
-                    if (i < subTabs.size()) {
-                        return subTabs.get(i);
-                    }
-                }
-            } else {
-                int i = (position.x + size.width - 8 - (int) mouseX) / 24;
-                if (i < subTabs.size()) {
-                    return subTabs.get(subTabs.size() - 1 - i);
-                }
-            }
-        }
-        return null;
-    }
-
-    @OnlyIn(Dist.CLIENT)
-    public void drawTab(IFancyUIProvider tab, @NotNull GuiGraphics graphics, int mouseX, int mouseY, int x, int y,
-                        int width, int height, IFancyUIProvider hoveredTab) {
-        // render background
-        if (tab == selectedTab) {
-            tabPressedTexture.draw(graphics, mouseX, mouseY, x, y, width, height);
-        } else if (tab == hoveredTab) {
-            tabHoverTexture.draw(graphics, mouseX, mouseY, x, y, width, height);
-        } else {
-            tabTexture.draw(graphics, mouseX, mouseY, x, y, width, height);
-        }
-        // render icon
-        tab.getTabIcon().draw(graphics, mouseX, mouseY, x + (width - 16) / 2f, y + (height - 16) / 2f, 16, 16);
-    }
-
-    public void selectTab(IFancyUIProvider selectedTab) {
-        this.selectedTab = selectedTab;
-        this.detectAndSendChanges();
-    }
-}
diff --git a/src/main/java/com/gregtechceu/gtceu/api/gui/fancy/TitleBarWidget.java b/src/main/java/com/gregtechceu/gtceu/api/gui/fancy/TitleBarWidget.java
deleted file mode 100644
index b40d56fc467..00000000000
--- a/src/main/java/com/gregtechceu/gtceu/api/gui/fancy/TitleBarWidget.java
+++ /dev/null
@@ -1,121 +0,0 @@
-package com.gregtechceu.gtceu.api.gui.fancy;
-
-import com.gregtechceu.gtceu.api.gui.GuiTextures;
-
-import com.lowdragmc.lowdraglib.gui.texture.IGuiTexture;
-import com.lowdragmc.lowdraglib.gui.texture.TextTexture;
-import com.lowdragmc.lowdraglib.gui.util.ClickData;
-import com.lowdragmc.lowdraglib.gui.widget.ButtonWidget;
-import com.lowdragmc.lowdraglib.gui.widget.ImageWidget;
-import com.lowdragmc.lowdraglib.gui.widget.Widget;
-import com.lowdragmc.lowdraglib.gui.widget.WidgetGroup;
-import com.lowdragmc.lowdraglib.utils.Position;
-import com.lowdragmc.lowdraglib.utils.Size;
-
-import net.minecraft.ChatFormatting;
-import net.minecraft.MethodsReturnNonnullByDefault;
-
-import java.util.function.Consumer;
-
-import javax.annotation.ParametersAreNonnullByDefault;
-
-@MethodsReturnNonnullByDefault
-@ParametersAreNonnullByDefault
-public class TitleBarWidget extends WidgetGroup {
-
-    private static final int BORDER_WIDTH = 3;
-    private static final int HORIZONTAL_MARGIN = 8;
-    private static final int HEIGHT = 16;
-    private static final int BTN_WIDTH = 18;
-
-    private static final float ROLL_SPEED = 0.7f;
-
-    private int width;
-    private boolean showBackButton = false;
-    private boolean showMenuButton = false;
-    private final int innerHeight;
-
-    /**
-     * The button group is rendered behind the main section and contains the back and menu buttons.
-     * <p>
-     * For easier texture reuse, the background is applied to the group itself, instead of the individual buttons.<br>
-     * The button group therefore needs to be rendered behind the main section.
-     */
-    private final WidgetGroup buttonGroup;
-    private final Widget backButton;
-    private final Widget menuButton;
-
-    /**
-     * The main section contains the current tab's icon and title text
-     */
-    private final WidgetGroup mainSection;
-    private final ImageWidget tabIcon;
-    private final ImageWidget tabTitle;
-    private TextTexture titleText;
-
-    public TitleBarWidget(int parentWidth, Consumer<ClickData> onBackClicked, Consumer<ClickData> onMenuClicked) {
-        super(HORIZONTAL_MARGIN, -HEIGHT, parentWidth, HEIGHT);
-        this.innerHeight = HEIGHT - BORDER_WIDTH;
-        this.width = parentWidth - (2 * HORIZONTAL_MARGIN);
-
-        addWidget(this.buttonGroup = new WidgetGroup(0, BORDER_WIDTH, width, innerHeight));
-        buttonGroup.setBackground(GuiTextures.TITLE_BAR_BACKGROUND);
-        buttonGroup.addWidget(this.backButton = new ButtonWidget(0, BORDER_WIDTH, BTN_WIDTH, HEIGHT - BORDER_WIDTH,
-                new TextTexture(" <").setDropShadow(false).setColor(ChatFormatting.BLACK.getColor()), onBackClicked)
-                .setHoverTooltips("gtceu.gui.title_bar.back"));
-        buttonGroup.addWidget(this.menuButton = new ButtonWidget(width - BTN_WIDTH, BORDER_WIDTH, BTN_WIDTH,
-                HEIGHT - BORDER_WIDTH,
-                new TextTexture("+").setDropShadow(false).setColor(ChatFormatting.BLACK.getColor()), onMenuClicked)
-                .setHoverTooltips("gtceu.gui.title_bar.page_switcher"));
-
-        addWidget(this.mainSection = new WidgetGroup(BTN_WIDTH, 0, width, HEIGHT));
-        mainSection.setBackground(GuiTextures.TITLE_BAR_BACKGROUND);
-        mainSection.addWidget(this.tabIcon = new ImageWidget(
-                BORDER_WIDTH + 1, BORDER_WIDTH + 1,
-                innerHeight - 2, innerHeight - 2,
-                IGuiTexture.EMPTY));
-        mainSection.addWidget(this.tabTitle = new ImageWidget(
-                BORDER_WIDTH + innerHeight, BORDER_WIDTH, 0, 0, IGuiTexture.EMPTY));
-    }
-
-    public void updateState(IFancyUIProvider currentPage, boolean showBackButton, boolean showMenuButton) {
-        this.showBackButton = showBackButton;
-        this.showMenuButton = showMenuButton;
-
-        titleText = new TextTexture(ChatFormatting.BLACK.toString() + currentPage.getTitle().copy().getString())
-                .setDropShadow(false)
-                .setType(TextTexture.TextType.ROLL);
-        titleText.setRollSpeed(ROLL_SPEED);
-
-        tabIcon.setImage(currentPage.getTabIcon());
-        tabTitle.setImage(titleText);
-
-        backButton.setVisible(showBackButton);
-        backButton.setActive(showBackButton);
-
-        menuButton.setVisible(showMenuButton);
-        menuButton.setActive(showMenuButton);
-
-        onSizeUpdate();
-    }
-
-    @Override
-    protected void onSizeUpdate() {
-        this.width = getSize().getWidth() - (2 * HORIZONTAL_MARGIN);
-
-        var hiddenButtons = 2;
-        if (showBackButton) hiddenButtons--;
-        if (showMenuButton) hiddenButtons--;
-
-        int buttonGroupWidth = this.width - (BTN_WIDTH * hiddenButtons);
-        buttonGroup.setSize(new Size(buttonGroupWidth, innerHeight));
-        buttonGroup.setSelfPosition(new Position(showBackButton ? 0 : BTN_WIDTH, BORDER_WIDTH));
-        menuButton.setSelfPosition(new Position(buttonGroupWidth - BTN_WIDTH, BORDER_WIDTH));
-
-        int mainSectionWidth = this.width - (BTN_WIDTH * 2);
-        int titleWidth = mainSectionWidth - (2 * BORDER_WIDTH) - innerHeight;
-        mainSection.setSize(new Size(mainSectionWidth, HEIGHT));
-        titleText.setWidth(titleWidth);
-        tabTitle.setSize(new Size(titleWidth, HEIGHT - BORDER_WIDTH));
-    }
-}
diff --git a/src/main/java/com/gregtechceu/gtceu/api/gui/fancy/TooltipsPanel.java b/src/main/java/com/gregtechceu/gtceu/api/gui/fancy/TooltipsPanel.java
deleted file mode 100644
index 5e5e01d7975..00000000000
--- a/src/main/java/com/gregtechceu/gtceu/api/gui/fancy/TooltipsPanel.java
+++ /dev/null
@@ -1,72 +0,0 @@
-package com.gregtechceu.gtceu.api.gui.fancy;
-
-import com.lowdragmc.lowdraglib.gui.widget.Widget;
-import com.lowdragmc.lowdraglib.utils.Size;
-
-import net.minecraft.client.gui.GuiGraphics;
-import net.minecraft.world.item.ItemStack;
-import net.minecraftforge.api.distmarker.Dist;
-import net.minecraftforge.api.distmarker.OnlyIn;
-
-import lombok.Getter;
-import org.jetbrains.annotations.NotNull;
-
-import java.util.ArrayList;
-import java.util.Arrays;
-import java.util.List;
-
-public class TooltipsPanel extends Widget {
-
-    @Getter
-    protected List<IFancyTooltip> tooltips = new ArrayList<>();
-
-    public TooltipsPanel() {
-        super(202, 2, 20, 0);
-    }
-
-    public void clear() {
-        tooltips.clear();
-    }
-
-    public void attachTooltips(IFancyTooltip... tooltips) {
-        this.tooltips.addAll(Arrays.asList(tooltips));
-    }
-
-    @Override
-    @OnlyIn(Dist.CLIENT)
-    public void drawInBackground(@NotNull GuiGraphics graphics, int mouseX, int mouseY, float partialTicks) {
-        super.drawInBackground(graphics, mouseX, mouseY, partialTicks);
-        var position = getPosition();
-        var size = getSize();
-        int offsetY = 0;
-        for (IFancyTooltip tooltip : this.tooltips) {
-            if (tooltip.showFancyTooltip()) {
-                // draw icon
-                tooltip.getFancyTooltipIcon().draw(graphics, mouseX, mouseY, position.x, position.y + offsetY,
-                        size.width, size.width);
-                offsetY += size.getWidth() + 2;
-            }
-        }
-        setSize(new Size(getSize().width, Math.max(0, offsetY)));
-    }
-
-    @Override
-    @OnlyIn(Dist.CLIENT)
-    public void drawInForeground(@NotNull GuiGraphics graphics, int mouseX, int mouseY, float partialTicks) {
-        if (getHoverElement(mouseX, mouseY) == this && gui != null && gui.getModularUIGui() != null) {
-            var position = getPosition();
-            var size = getSize();
-            int offsetY = 0;
-            for (IFancyTooltip tooltip : this.tooltips) {
-                if (tooltip.showFancyTooltip()) {
-                    if (isMouseOver(position.x, position.y + offsetY, size.width, size.width, mouseX, mouseY)) {
-                        gui.getModularUIGui().setHoverTooltip(tooltip.getFancyTooltip(), ItemStack.EMPTY, null,
-                                tooltip.getFancyComponent());
-                        return;
-                    }
-                    offsetY += size.getWidth() + 2;
-                }
-            }
-        }
-    }
-}
diff --git a/src/main/java/com/gregtechceu/gtceu/api/gui/fancy/VerticalTabsWidget.java b/src/main/java/com/gregtechceu/gtceu/api/gui/fancy/VerticalTabsWidget.java
deleted file mode 100644
index 0fe2fc77f5f..00000000000
--- a/src/main/java/com/gregtechceu/gtceu/api/gui/fancy/VerticalTabsWidget.java
+++ /dev/null
@@ -1,62 +0,0 @@
-package com.gregtechceu.gtceu.api.gui.fancy;
-
-import com.lowdragmc.lowdraglib.gui.texture.ResourceTexture;
-
-import net.minecraft.client.gui.GuiGraphics;
-import net.minecraftforge.api.distmarker.Dist;
-import net.minecraftforge.api.distmarker.OnlyIn;
-
-import org.jetbrains.annotations.NotNull;
-import org.jetbrains.annotations.Nullable;
-
-import java.util.function.Consumer;
-
-public class VerticalTabsWidget extends TabsWidget {
-
-    public VerticalTabsWidget(Consumer<IFancyUIProvider> onTabClick, int x, int y, int width, int height) {
-        super(onTabClick, x, y, width, height);
-        ResourceTexture tabsLeft = new ResourceTexture("gtceu:textures/gui/tab/tabs_left.png");
-        setTabTexture(tabsLeft.getSubTexture(0, 1 / 3f, 0.5f, 1 / 3f));
-        setTabHoverTexture(tabsLeft.getSubTexture(0.5f, 1 / 3f, 0.5f, 1 / 3f));
-        setTabPressedTexture(tabsLeft.getSubTexture(0.5f, 1 / 3f, 0.5f, 1 / 3f));
-    }
-
-    @Override
-    public boolean hasButton() {
-        return false;
-    }
-
-    @Override
-    @OnlyIn(Dist.CLIENT)
-    public void drawInBackground(@NotNull GuiGraphics graphics, int mouseX, int mouseY, float partialTicks) {
-        drawBackgroundTexture(graphics, mouseX, mouseY);
-        var position = getPosition();
-        var size = getSize();
-        var hoveredTab = getHoveredTab(mouseX, mouseY);
-        // main tab
-        drawTab(mainTab, graphics, mouseX, mouseY, position.x, position.y + 8, 24, 24, hoveredTab);
-        for (int i = 0; i < subTabs.size(); ++i) {
-            drawTab(subTabs.get(i), graphics, mouseX, mouseY, position.x, position.y + 8 + 24 * (i + 1), 24, 24,
-                    hoveredTab);
-        }
-    }
-
-    @OnlyIn(Dist.CLIENT)
-    @Nullable
-    public IFancyUIProvider getHoveredTab(double mouseX, double mouseY) {
-        if (isMouseOverElement(mouseX, mouseY)) {
-            var position = getPosition();
-            var size = getSize();
-            // main tab
-            if (isMouseOver(position.x, position.y + 8, 24, 24, mouseX, mouseY)) {
-                return mainTab;
-            }
-            // others
-            int i = ((int) mouseY - position.y - 24 - 8) / 24;
-            if (i >= 0 && i < subTabs.size()) {
-                return subTabs.get(i);
-            }
-        }
-        return null;
-    }
-}
diff --git a/src/main/java/com/gregtechceu/gtceu/api/gui/misc/IGhostFluidTarget.java b/src/main/java/com/gregtechceu/gtceu/api/gui/misc/IGhostFluidTarget.java
deleted file mode 100644
index 3324b34e811..00000000000
--- a/src/main/java/com/gregtechceu/gtceu/api/gui/misc/IGhostFluidTarget.java
+++ /dev/null
@@ -1,80 +0,0 @@
-package com.gregtechceu.gtceu.api.gui.misc;
-
-import com.gregtechceu.gtceu.GTCEu;
-
-import com.lowdragmc.lowdraglib.gui.ingredient.IGhostIngredientTarget;
-import com.lowdragmc.lowdraglib.gui.ingredient.Target;
-
-import net.minecraft.client.renderer.Rect2i;
-import net.minecraft.world.level.material.Fluid;
-import net.minecraftforge.api.distmarker.Dist;
-import net.minecraftforge.api.distmarker.OnlyIn;
-import net.minecraftforge.fluids.FluidStack;
-
-import com.google.common.collect.Lists;
-import dev.emi.emi.api.stack.EmiStack;
-import org.jetbrains.annotations.NotNull;
-
-import java.util.Collections;
-import java.util.List;
-
-import static com.gregtechceu.gtceu.api.gui.widget.PhantomFluidWidget.drainFrom;
-
-public interface IGhostFluidTarget extends IGhostIngredientTarget {
-
-    @OnlyIn(Dist.CLIENT)
-    Rect2i getRectangleBox();
-
-    @OnlyIn(Dist.CLIENT)
-    void acceptFluid(FluidStack fluidStack);
-
-    @OnlyIn(Dist.CLIENT)
-    @Override
-    default List<Target> getPhantomTargets(Object ingredient) {
-        ingredient = convertIngredient(ingredient);
-        if (!(ingredient instanceof FluidStack) && drainFrom(ingredient) == null) {
-            return Collections.emptyList();
-        } else {
-            final Rect2i rectangle = getRectangleBox();
-            return Lists.newArrayList(new Target[] { new Target() {
-
-                @NotNull
-                public Rect2i getArea() {
-                    return rectangle;
-                }
-
-                public void accept(@NotNull Object ingredient) {
-                    ingredient = convertIngredient(ingredient);
-
-                    FluidStack ingredientStack;
-                    if (ingredient instanceof FluidStack fluidStack) {
-                        ingredientStack = fluidStack;
-                    } else {
-                        ingredientStack = drainFrom(ingredient);
-                    }
-
-                    if (ingredientStack != null) {
-                        acceptFluid(ingredientStack);
-                    }
-                }
-            } });
-        }
-    }
-
-    default Object convertIngredient(Object ingredient) {
-        if (GTCEu.Mods.isREILoaded() && ingredient instanceof dev.architectury.fluid.FluidStack fluidStack) {
-            ingredient = new FluidStack(fluidStack.getFluid(), (int) fluidStack.getAmount(), fluidStack.getTag());
-        }
-
-        if (GTCEu.Mods.isEMILoaded() && ingredient instanceof EmiStack fluidEmiStack) {
-            Fluid fluid = fluidEmiStack.getKeyOfType(Fluid.class);
-            ingredient = fluid == null ? FluidStack.EMPTY :
-                    new FluidStack(fluid, (int) fluidEmiStack.getAmount(), fluidEmiStack.getNbt());
-        }
-
-        if (GTCEu.Mods.isJEILoaded() && ingredient instanceof net.minecraftforge.fluids.FluidStack fluidStack) {
-            ingredient = new FluidStack(fluidStack.getFluid(), fluidStack.getAmount(), fluidStack.getTag());
-        }
-        return ingredient;
-    }
-}
diff --git a/src/main/java/com/gregtechceu/gtceu/api/gui/misc/IGhostItemTarget.java b/src/main/java/com/gregtechceu/gtceu/api/gui/misc/IGhostItemTarget.java
deleted file mode 100644
index e26f1e30520..00000000000
--- a/src/main/java/com/gregtechceu/gtceu/api/gui/misc/IGhostItemTarget.java
+++ /dev/null
@@ -1,70 +0,0 @@
-package com.gregtechceu.gtceu.api.gui.misc;
-
-import com.gregtechceu.gtceu.GTCEu;
-
-import com.lowdragmc.lowdraglib.gui.ingredient.IGhostIngredientTarget;
-import com.lowdragmc.lowdraglib.gui.ingredient.Target;
-
-import net.minecraft.client.renderer.Rect2i;
-import net.minecraft.world.item.Item;
-import net.minecraft.world.item.ItemStack;
-import net.minecraftforge.api.distmarker.Dist;
-import net.minecraftforge.api.distmarker.OnlyIn;
-
-import com.google.common.collect.Lists;
-import dev.emi.emi.api.stack.EmiStack;
-import mezz.jei.api.ingredients.ITypedIngredient;
-import org.jetbrains.annotations.NotNull;
-
-import java.util.Collections;
-import java.util.List;
-
-public interface IGhostItemTarget extends IGhostIngredientTarget {
-
-    @OnlyIn(Dist.CLIENT)
-    Rect2i getRectangleBox();
-
-    @OnlyIn(Dist.CLIENT)
-    void acceptItem(ItemStack itemStack);
-
-    @OnlyIn(Dist.CLIENT)
-    @Override
-    default List<Target> getPhantomTargets(Object ingredient) {
-        if (!(convertIngredient(ingredient) instanceof ItemStack)) {
-            return Collections.emptyList();
-        } else {
-            final Rect2i rectangle = getRectangleBox();
-            return Lists.newArrayList(new Target[] { new Target() {
-
-                @NotNull
-                public Rect2i getArea() {
-                    return rectangle;
-                }
-
-                public void accept(@NotNull Object ingredient) {
-                    ingredient = convertIngredient(ingredient);
-
-                    if (ingredient instanceof ItemStack stack) {
-                        acceptItem(stack);
-                    }
-                }
-            } });
-        }
-    }
-
-    default Object convertIngredient(Object ingredient) {
-        if (GTCEu.Mods.isEMILoaded() && ingredient instanceof EmiStack itemEmiStack) {
-            Item item = itemEmiStack.getKeyOfType(Item.class);
-            ItemStack itemStack = item == null ? ItemStack.EMPTY : new ItemStack(item, (int) itemEmiStack.getAmount());
-            if (!itemStack.isEmpty()) {
-                itemStack.setTag(itemEmiStack.getNbt());
-            }
-            ingredient = itemStack;
-        }
-
-        if (GTCEu.Mods.isJEILoaded() && ingredient instanceof ITypedIngredient<?> itemJeiStack) {
-            return itemJeiStack.getItemStack().orElse(ItemStack.EMPTY);
-        }
-        return ingredient;
-    }
-}
diff --git a/src/main/java/com/gregtechceu/gtceu/api/gui/util/TimedProgressSupplier.java b/src/main/java/com/gregtechceu/gtceu/api/gui/util/TimedProgressSupplier.java
deleted file mode 100644
index e958d11e59d..00000000000
--- a/src/main/java/com/gregtechceu/gtceu/api/gui/util/TimedProgressSupplier.java
+++ /dev/null
@@ -1,37 +0,0 @@
-package com.gregtechceu.gtceu.api.gui.util;
-
-import java.util.function.DoubleSupplier;
-
-public class TimedProgressSupplier implements DoubleSupplier {
-
-    private final int msPerCycle;
-    private final int maxValue;
-    private final boolean countDown;
-    private long startTime;
-
-    public TimedProgressSupplier(int ticksPerCycle, int maxValue, boolean countDown) {
-        this.msPerCycle = ticksPerCycle * 50;
-        this.maxValue = maxValue;
-        this.countDown = countDown;
-        this.startTime = System.currentTimeMillis();
-    }
-
-    public void resetCountdown() {
-        startTime = System.currentTimeMillis();
-    }
-
-    @Override
-    public double getAsDouble() {
-        return calculateTime();
-    }
-
-    private double calculateTime() {
-        long currentTime = System.currentTimeMillis();
-        long msPassed = (currentTime - startTime) % msPerCycle;
-        double currentValue = (1.0 * msPassed * maxValue) / msPerCycle;
-        if (countDown) {
-            return (maxValue - currentValue) / maxValue;
-        }
-        return currentValue / maxValue;
-    }
-}
diff --git a/src/main/java/com/gregtechceu/gtceu/api/gui/widget/BlockableSlotWidget.java b/src/main/java/com/gregtechceu/gtceu/api/gui/widget/BlockableSlotWidget.java
deleted file mode 100644
index a4a2732243b..00000000000
--- a/src/main/java/com/gregtechceu/gtceu/api/gui/widget/BlockableSlotWidget.java
+++ /dev/null
@@ -1,67 +0,0 @@
-package com.gregtechceu.gtceu.api.gui.widget;
-
-import com.lowdragmc.lowdraglib.utils.Position;
-import com.lowdragmc.lowdraglib.utils.Size;
-
-import net.minecraft.client.gui.GuiGraphics;
-import net.minecraft.world.Container;
-import net.minecraftforge.items.IItemHandlerModifiable;
-
-import com.mojang.blaze3d.systems.RenderSystem;
-import org.jetbrains.annotations.NotNull;
-
-import java.util.function.BooleanSupplier;
-
-/** Basically just your normal SlotWidget, but can render the slot as "grayed-out" with a Supplier value. */
-public class BlockableSlotWidget extends SlotWidget {
-
-    private static final int OVERLAY_COLOR = 0x80404040;
-
-    private BooleanSupplier isBlocked = () -> false;
-
-    public BlockableSlotWidget(Container inventory, int slotIndex, int xPosition, int yPosition, boolean canTakeItems,
-                               boolean canPutItems) {
-        super(inventory, slotIndex, xPosition, yPosition, canTakeItems, canPutItems);
-    }
-
-    public BlockableSlotWidget(IItemHandlerModifiable itemHandler, int slotIndex, int xPosition, int yPosition,
-                               boolean canTakeItems, boolean canPutItems) {
-        super(itemHandler, slotIndex, xPosition, yPosition, canTakeItems,
-                canPutItems);
-    }
-
-    public BlockableSlotWidget(IItemHandlerModifiable itemHandler, int slotIndex, int xPosition, int yPosition) {
-        super(itemHandler, slotIndex, xPosition, yPosition);
-    }
-
-    public BlockableSlotWidget(Container inventory, int slotIndex, int xPosition, int yPosition) {
-        super(inventory, slotIndex, xPosition, yPosition);
-    }
-
-    public BlockableSlotWidget setIsBlocked(BooleanSupplier isBlocked) {
-        this.isBlocked = isBlocked;
-        return this;
-    }
-
-    @Override
-    public void drawInBackground(@NotNull GuiGraphics graphics, int mouseX, int mouseY, float partialTicks) {
-        super.drawInBackground(graphics, mouseX, mouseY, partialTicks);
-        if (isBlocked.getAsBoolean()) {
-            Position pos = getPosition();
-            Size size = getSize();
-            RenderSystem.disableDepthTest();
-            RenderSystem.colorMask(true, true, true, false);
-            graphics.fill(pos.getX() + 1, pos.getY() + 1, pos.getX() + 1 + size.getWidth() - 2,
-                    pos.getY() + 1 + size.getHeight() - 2, OVERLAY_COLOR);
-            RenderSystem.colorMask(true, true, true, true);
-            RenderSystem.enableDepthTest();
-            RenderSystem.enableBlend();
-        }
-    }
-
-    @Override
-    public boolean isMouseOverElement(double mouseX, double mouseY) {
-        // prevent slot removal and hover highlighting when slot is blocked
-        return super.isMouseOverElement(mouseX, mouseY) && !isBlocked.getAsBoolean();
-    }
-}
diff --git a/src/main/java/com/gregtechceu/gtceu/api/gui/widget/ColorBlockWidget.java b/src/main/java/com/gregtechceu/gtceu/api/gui/widget/ColorBlockWidget.java
deleted file mode 100644
index 5e7bbf3e412..00000000000
--- a/src/main/java/com/gregtechceu/gtceu/api/gui/widget/ColorBlockWidget.java
+++ /dev/null
@@ -1,65 +0,0 @@
-package com.gregtechceu.gtceu.api.gui.widget;
-
-import com.lowdragmc.lowdraglib.gui.util.DrawerHelper;
-import com.lowdragmc.lowdraglib.gui.widget.Widget;
-
-import net.minecraft.client.gui.GuiGraphics;
-import net.minecraftforge.api.distmarker.Dist;
-import net.minecraftforge.api.distmarker.OnlyIn;
-
-import lombok.Getter;
-import lombok.Setter;
-import lombok.experimental.Accessors;
-import org.jetbrains.annotations.NotNull;
-
-import java.util.function.IntSupplier;
-
-@Setter
-@Accessors(chain = true)
-public class ColorBlockWidget extends Widget {
-
-    private IntSupplier colorSupplier;
-    @Getter
-    private int currentColor;
-    private static boolean isShowAlpha = false;
-
-    public ColorBlockWidget(int x, int y, int width, int height) {
-        super(x, y, width, height);
-        this.currentColor = 0xFFFFFFFF;
-    }
-
-    @Override
-    public void updateScreen() {
-        super.updateScreen();
-        if (isClientSideWidget && colorSupplier != null) {
-            currentColor = colorSupplier.getAsInt();
-        }
-    }
-
-    @Override
-    public boolean mouseClicked(double mouseX, double mouseY, int button) {
-        if (isMouseOverElement(mouseX, mouseY)) {
-            playButtonClickSound();
-            isShowAlpha = !isShowAlpha;
-            return true;
-        }
-        return super.mouseClicked(mouseX, mouseY, button);
-    }
-
-    @OnlyIn(Dist.CLIENT)
-    @Override
-    public void drawInBackground(@NotNull GuiGraphics graphics, int mouseX, int mouseY, float partialTicks) {
-        int x = getPosition().x + 1;
-        int y = getPosition().y + 1;
-        int width = getSize().width - 2;
-        int height = getSize().height - 2;
-
-        if (colorSupplier != null) {
-            currentColor = colorSupplier.getAsInt();
-        }
-        final int BORDER_COLOR = 0xFF000000;
-        int opaqueColor = isShowAlpha ? currentColor : currentColor | 0xFF000000;
-        graphics.fill(x, y, x + width, y + height, opaqueColor);
-        DrawerHelper.drawBorder(graphics, x, y, width, height, BORDER_COLOR, 1);
-    }
-}
diff --git a/src/main/java/com/gregtechceu/gtceu/api/gui/widget/ConfirmTextInputWidget.java b/src/main/java/com/gregtechceu/gtceu/api/gui/widget/ConfirmTextInputWidget.java
deleted file mode 100644
index 9a77e5e26c1..00000000000
--- a/src/main/java/com/gregtechceu/gtceu/api/gui/widget/ConfirmTextInputWidget.java
+++ /dev/null
@@ -1,73 +0,0 @@
-package com.gregtechceu.gtceu.api.gui.widget;
-
-import com.gregtechceu.gtceu.api.gui.GuiTextures;
-
-import com.lowdragmc.lowdraglib.gui.texture.GuiTextureGroup;
-import com.lowdragmc.lowdraglib.gui.widget.ButtonWidget;
-import com.lowdragmc.lowdraglib.gui.widget.TextFieldWidget;
-import com.lowdragmc.lowdraglib.gui.widget.WidgetGroup;
-
-import lombok.AccessLevel;
-import lombok.Getter;
-import lombok.Setter;
-import lombok.experimental.Accessors;
-import org.jetbrains.annotations.Nullable;
-
-import java.util.function.Consumer;
-import java.util.function.Function;
-
-@Accessors(chain = true)
-public class ConfirmTextInputWidget extends WidgetGroup {
-
-    private final Consumer<String> textResponder;
-    @Nullable
-    private final Function<String, String> returnValidator;
-    private Function<String, String> validator = (s) -> s;
-    @Getter(AccessLevel.PRIVATE)
-    @Setter(AccessLevel.PRIVATE)
-    private String inputText = "";
-    @Setter
-    private String tooltip = "";
-
-    public ConfirmTextInputWidget(int x, int y, int width, int height, String text,
-                                  Consumer<String> textResponder,
-                                  @Nullable Function<String, String> validator,
-                                  @Nullable Function<String, String> returnValidator) {
-        super(x, y, width, height);
-        this.textResponder = textResponder;
-        this.returnValidator = returnValidator;
-        if (validator != null) {
-            this.validator = validator;
-        }
-        if (text != null) {
-            this.inputText = text;
-        }
-    }
-
-    @Override
-    public void initWidget() {
-        super.initWidget();
-        this.addWidget(new ButtonWidget(
-                getSizeWidth() - getSizeHeight(),
-                0,
-                getSizeHeight(),
-                getSizeHeight(),
-                pressed -> {
-                    if (returnValidator != null) {
-                        inputText = returnValidator.apply(inputText);
-                    }
-                    textResponder.accept(inputText);
-                })
-                .setButtonTexture(
-                        new GuiTextureGroup(GuiTextures.VANILLA_BUTTON, GuiTextures.BUTTON_CHECK)));
-        this.addWidget(new TextFieldWidget(
-                1,
-                1,
-                getSizeWidth() - getSizeHeight() - 4,
-                getSizeHeight() - 2,
-                this::getInputText,
-                this::setInputText)
-                .setValidator(validator)
-                .setHoverTooltips(tooltip));
-    }
-}
diff --git a/src/main/java/com/gregtechceu/gtceu/api/gui/widget/CoverConfigurator.java b/src/main/java/com/gregtechceu/gtceu/api/gui/widget/CoverConfigurator.java
deleted file mode 100644
index a7253922ede..00000000000
--- a/src/main/java/com/gregtechceu/gtceu/api/gui/widget/CoverConfigurator.java
+++ /dev/null
@@ -1,58 +0,0 @@
-package com.gregtechceu.gtceu.api.gui.widget;
-
-import com.gregtechceu.gtceu.api.capability.ICoverable;
-import com.gregtechceu.gtceu.api.cover.CoverBehavior;
-import com.gregtechceu.gtceu.api.cover.IUICover;
-import com.gregtechceu.gtceu.api.gui.GuiTextures;
-import com.gregtechceu.gtceu.api.gui.fancy.IFancyConfigurator;
-import com.gregtechceu.gtceu.common.data.GTItems;
-
-import com.lowdragmc.lowdraglib.gui.texture.IGuiTexture;
-import com.lowdragmc.lowdraglib.gui.texture.ItemStackTexture;
-import com.lowdragmc.lowdraglib.gui.widget.Widget;
-import com.lowdragmc.lowdraglib.gui.widget.WidgetGroup;
-import com.lowdragmc.lowdraglib.utils.Position;
-import com.lowdragmc.lowdraglib.utils.Size;
-
-import net.minecraft.core.Direction;
-import net.minecraft.network.chat.Component;
-
-import lombok.AllArgsConstructor;
-import org.jetbrains.annotations.Nullable;
-
-@AllArgsConstructor
-public class CoverConfigurator implements IFancyConfigurator {
-
-    protected final ICoverable coverable;
-    // runtime
-    @Nullable
-    protected final Direction side;
-    @Nullable
-    protected final CoverBehavior coverBehavior;
-
-    @Override
-    public Component getTitle() {
-        return Component.translatable("gtceu.gui.cover_setting.title");
-    }
-
-    @Override
-    public IGuiTexture getIcon() {
-        return new ItemStackTexture(GTItems.ITEM_FILTER.get());
-    }
-
-    @Override
-    public Widget createConfigurator() {
-        WidgetGroup group = new WidgetGroup(new Position(0, 0));
-        if (side != null) {
-            if (coverable.getCoverAtSide(side) instanceof IUICover iuiCover) {
-                Widget coverConfigurator = iuiCover.createUIWidget();
-                coverConfigurator.setBackground(GuiTextures.BACKGROUND);
-                coverConfigurator.setSelfPosition(new Position(4, -4));
-                group.addWidget(coverConfigurator);
-                group.setSize(new Size(Math.max(120, coverConfigurator.getSize().width + 8),
-                        Math.max(80, 80 + coverConfigurator.getSize().height)));
-            }
-        }
-        return group;
-    }
-}
diff --git a/src/main/java/com/gregtechceu/gtceu/api/gui/widget/EnumSelectorWidget.java b/src/main/java/com/gregtechceu/gtceu/api/gui/widget/EnumSelectorWidget.java
deleted file mode 100644
index 86d8c1bb2e5..00000000000
--- a/src/main/java/com/gregtechceu/gtceu/api/gui/widget/EnumSelectorWidget.java
+++ /dev/null
@@ -1,134 +0,0 @@
-package com.gregtechceu.gtceu.api.gui.widget;
-
-import com.gregtechceu.gtceu.GTCEu;
-import com.gregtechceu.gtceu.api.gui.GuiTextures;
-import com.gregtechceu.gtceu.data.lang.LangHandler;
-
-import com.lowdragmc.lowdraglib.gui.texture.GuiTextureGroup;
-import com.lowdragmc.lowdraglib.gui.texture.IGuiTexture;
-import com.lowdragmc.lowdraglib.gui.widget.CycleButtonWidget;
-import com.lowdragmc.lowdraglib.gui.widget.WidgetGroup;
-
-import net.minecraft.MethodsReturnNonnullByDefault;
-import net.minecraft.network.FriendlyByteBuf;
-import net.minecraft.network.chat.Component;
-
-import org.jetbrains.annotations.NotNull;
-
-import java.util.Arrays;
-import java.util.List;
-import java.util.NoSuchElementException;
-import java.util.function.BiFunction;
-import java.util.function.Consumer;
-
-import javax.annotation.ParametersAreNonnullByDefault;
-
-/**
- * A widget for selecting a value from an enum or a subset of its values.
- */
-@ParametersAreNonnullByDefault
-@MethodsReturnNonnullByDefault
-public class EnumSelectorWidget<T extends Enum<T> & EnumSelectorWidget.SelectableEnum> extends WidgetGroup {
-
-    public interface SelectableEnum {
-
-        String getTooltip();
-
-        IGuiTexture getIcon();
-    }
-
-    public final CycleButtonWidget buttonWidget;
-
-    public final List<T> values;
-    public final Consumer<T> onChanged;
-
-    public int selected = 0;
-
-    private BiFunction<T, IGuiTexture, IGuiTexture> textureSupplier = (value, texture) -> new GuiTextureGroup(
-            GuiTextures.VANILLA_BUTTON, texture);
-
-    private BiFunction<T, String, List<Component>> tooltipSupplier = (value, key) -> List
-            .copyOf(LangHandler.getSingleOrMultiLang(key));
-
-    public EnumSelectorWidget(int xPosition, int yPosition, int width, int height, T[] values, T initialValue,
-                              Consumer<T> onChanged) {
-        this(xPosition, yPosition, width, height, Arrays.asList(values), initialValue, onChanged);
-    }
-
-    public EnumSelectorWidget(int xPosition, int yPosition, int width, int height, List<T> values, T initialValue,
-                              Consumer<T> onChanged) {
-        super(xPosition, yPosition, width, height);
-
-        this.values = values;
-        this.onChanged = onChanged;
-
-        this.buttonWidget = new CycleButtonWidget(0, 0, width, height, values.size(), this::getTexture,
-                this::onSelected);
-        this.addWidget(buttonWidget);
-
-        setSelected(initialValue);
-    }
-
-    @Override
-    public void writeInitialData(FriendlyByteBuf buffer) {
-        super.writeInitialData(buffer);
-        buffer.writeInt(selected);
-    }
-
-    @Override
-    public void readInitialData(FriendlyByteBuf buffer) {
-        super.readInitialData(buffer);
-        onSelected(buffer.readInt());
-    }
-
-    public T getCurrentValue() {
-        return values.get(selected);
-    }
-
-    public IGuiTexture getTexture(int selected) {
-        var selectedValue = values.get(selected);
-        return textureSupplier.apply(selectedValue, selectedValue.getIcon());
-    }
-
-    private void onSelected(int selected) {
-        T selectedValue = values.get(selected);
-        setSelected(selectedValue);
-    }
-
-    public EnumSelectorWidget<T> setTextureSupplier(BiFunction<T, IGuiTexture, IGuiTexture> textureSupplier) {
-        this.textureSupplier = textureSupplier;
-
-        T selectedValue = getCurrentValue();
-        buttonWidget.setBackground(textureSupplier.apply(selectedValue, selectedValue.getIcon()));
-
-        return this;
-    }
-
-    public EnumSelectorWidget<T> setTooltipSupplier(BiFunction<T, String, List<Component>> tooltipSupplier) {
-        this.tooltipSupplier = tooltipSupplier;
-
-        return this;
-    }
-
-    public void setSelected(@NotNull T value) {
-        var selectedIndex = values.indexOf(value);
-
-        if (selectedIndex == -1)
-            throw new NoSuchElementException(value + " is not a possible value for this selector.");
-
-        this.selected = selectedIndex;
-        this.buttonWidget.setIndex(selectedIndex);
-
-        updateTooltip();
-
-        onChanged.accept(value);
-    }
-
-    private void updateTooltip() {
-        if (!GTCEu.isClientThread())
-            return;
-
-        T selectedValue = getCurrentValue();
-        buttonWidget.setHoverTooltips(tooltipSupplier.apply(selectedValue, selectedValue.getTooltip()));
-    }
-}
diff --git a/src/main/java/com/gregtechceu/gtceu/api/gui/widget/ExtendedProgressWidget.java b/src/main/java/com/gregtechceu/gtceu/api/gui/widget/ExtendedProgressWidget.java
deleted file mode 100644
index 80bbda0ad43..00000000000
--- a/src/main/java/com/gregtechceu/gtceu/api/gui/widget/ExtendedProgressWidget.java
+++ /dev/null
@@ -1,88 +0,0 @@
-package com.gregtechceu.gtceu.api.gui.widget;
-
-import com.lowdragmc.lowdraglib.gui.texture.ProgressTexture;
-import com.lowdragmc.lowdraglib.gui.texture.ResourceTexture;
-import com.lowdragmc.lowdraglib.gui.widget.ProgressWidget;
-
-import net.minecraft.client.gui.GuiGraphics;
-import net.minecraft.network.FriendlyByteBuf;
-import net.minecraft.network.chat.Component;
-import net.minecraft.world.item.ItemStack;
-
-import lombok.Setter;
-import lombok.experimental.Accessors;
-import org.jetbrains.annotations.NotNull;
-
-import java.util.ArrayList;
-import java.util.List;
-import java.util.function.Consumer;
-import java.util.function.DoubleSupplier;
-
-@Accessors(chain = true)
-public class ExtendedProgressWidget extends ProgressWidget {
-
-    private List<Component> serverTooltips = new ArrayList<>();
-    @Setter
-    private Consumer<List<Component>> serverTooltipSupplier;
-
-    public ExtendedProgressWidget() {
-        super(JEIProgress, 0, 0, 40, 40, new ProgressTexture());
-    }
-
-    public ExtendedProgressWidget(DoubleSupplier progressSupplier, int x, int y, int width, int height,
-                                  ResourceTexture fullImage) {
-        super(progressSupplier, x, y, width, height, fullImage);
-    }
-
-    public ExtendedProgressWidget(DoubleSupplier progressSupplier, int x, int y, int width, int height,
-                                  ProgressTexture progressBar) {
-        super(progressSupplier, x, y, width, height, progressBar);
-    }
-
-    public ExtendedProgressWidget(DoubleSupplier progressSupplier, int x, int y, int width, int height) {
-        super(progressSupplier, x, y, width, height);
-    }
-
-    @Override
-    public void detectAndSendChanges() {
-        super.detectAndSendChanges();
-
-        if (serverTooltipSupplier != null) {
-            List<Component> textBuffer = new ArrayList<>();
-            serverTooltipSupplier.accept(textBuffer);
-            if (!serverTooltips.equals(textBuffer)) {
-                this.serverTooltips = textBuffer;
-                writeUpdateInfo(1, buffer -> {
-                    buffer.writeVarInt(serverTooltips.size());
-                    for (Component component : serverTooltips) {
-                        buffer.writeComponent(component);
-                    }
-                });
-            }
-        }
-    }
-
-    @Override
-    public void readUpdateInfo(int id, FriendlyByteBuf buffer) {
-        if (id == 1) {
-            this.serverTooltips.clear();
-            int count = buffer.readVarInt();
-            for (int i = 0; i < count; i++) {
-                Component component = buffer.readComponent();
-                this.serverTooltips.add(component);
-            }
-        } else {
-            super.readUpdateInfo(id, buffer);
-        }
-    }
-
-    @Override
-    public void drawInForeground(@NotNull GuiGraphics graphics, int mouseX, int mouseY, float partialTicks) {
-        if ((!tooltipTexts.isEmpty() || !serverTooltips.isEmpty()) && isMouseOverElement(mouseX, mouseY) &&
-                getHoverElement(mouseX, mouseY) == this && gui != null && gui.getModularUIGui() != null) {
-            var tips = new ArrayList<>(tooltipTexts);
-            tips.addAll(serverTooltips);
-            gui.getModularUIGui().setHoverTooltip(tips, ItemStack.EMPTY, null, null);
-        }
-    }
-}
diff --git a/src/main/java/com/gregtechceu/gtceu/api/gui/widget/GhostCircuitSlotWidget.java b/src/main/java/com/gregtechceu/gtceu/api/gui/widget/GhostCircuitSlotWidget.java
deleted file mode 100644
index 26a37530d1c..00000000000
--- a/src/main/java/com/gregtechceu/gtceu/api/gui/widget/GhostCircuitSlotWidget.java
+++ /dev/null
@@ -1,203 +0,0 @@
-package com.gregtechceu.gtceu.api.gui.widget;
-
-import com.gregtechceu.gtceu.api.gui.GuiTextures;
-import com.gregtechceu.gtceu.common.item.behavior.IntCircuitBehaviour;
-import com.gregtechceu.gtceu.config.ConfigHolder;
-
-import com.lowdragmc.lowdraglib.gui.texture.GuiTextureGroup;
-import com.lowdragmc.lowdraglib.gui.texture.IGuiTexture;
-import com.lowdragmc.lowdraglib.gui.texture.ItemStackTexture;
-import com.lowdragmc.lowdraglib.gui.widget.ButtonWidget;
-import com.lowdragmc.lowdraglib.gui.widget.LabelWidget;
-import com.lowdragmc.lowdraglib.gui.widget.Widget;
-import com.lowdragmc.lowdraglib.gui.widget.WidgetGroup;
-
-import net.minecraft.client.gui.screens.Screen;
-import net.minecraft.network.FriendlyByteBuf;
-import net.minecraft.world.item.ItemStack;
-import net.minecraftforge.items.IItemHandlerModifiable;
-
-import lombok.Getter;
-import org.jetbrains.annotations.Nullable;
-
-/**
- * Used for setting a "ghost" IC for a machine
- */
-public class GhostCircuitSlotWidget extends SlotWidget {
-
-    private static final int SET_TO_ZERO = 1;
-    private static final int SET_TO_EMPTY = 2;
-    private static final int SET_TO_N = 3;
-
-    private static final int NO_CONFIG = -1;
-
-    @Getter
-    private IItemHandlerModifiable circuitInventory;
-    @Nullable
-    private Widget configurator;
-
-    public GhostCircuitSlotWidget() {
-        super();
-    }
-
-    public void setCircuitInventory(IItemHandlerModifiable circuitInventory) {
-        this.circuitInventory = circuitInventory;
-        setHandlerSlot(circuitInventory, 0);
-    }
-
-    public boolean isConfiguratorOpen() {
-        return configurator != null;
-    }
-
-    @Override
-    public boolean mouseClicked(double mouseX, double mouseY, int button) {
-        if (isMouseOverElement(mouseX, mouseY) && gui != null) {
-            if (button == 0 && Screen.hasShiftDown()) {
-                // open popup on shift-left-click
-                if (!isConfiguratorOpen()) {
-                    this.gui.widget(configurator = createConfigurator());
-                } else {
-                    this.gui.mainGroup.removeWidget(configurator);
-                    configurator = null;
-                }
-            } else if (button == 0) {
-                // increment on left-click
-                int newValue = getNextValue(true);
-                setCircuitValue(newValue);
-            } else if (button == 1 && Screen.hasShiftDown()) {
-                // clear on shift-right-click
-                this.circuitInventory.setStackInSlot(0, ItemStack.EMPTY);
-                writeClientAction(SET_TO_EMPTY, buf -> {});
-            } else if (button == 1) {
-                // decrement on right-click
-                int newValue = getNextValue(false);
-                setCircuitValue(newValue);
-            }
-            return true;
-        }
-        return false;
-    }
-
-    private int getNextValue(boolean increment) {
-        int currentValue = IntCircuitBehaviour.getCircuitConfiguration(this.circuitInventory.getStackInSlot(0));
-        if (increment) {
-            // if at max, loop around to no circuit
-            if (currentValue == IntCircuitBehaviour.CIRCUIT_MAX) {
-                return 0;
-            }
-            // if at no circuit, skip 0 and return 1
-            if (this.circuitInventory.getStackInSlot(0).isEmpty()) {
-                return 1;
-            }
-            // normal case: increment by 1
-            return currentValue + 1;
-        } else {
-            // if at no circuit, loop around to max
-            if (this.circuitInventory.getStackInSlot(0).isEmpty()) {
-                return IntCircuitBehaviour.CIRCUIT_MAX;
-            }
-            // if at 1, skip 0 and return no circuit
-            if (currentValue == 1) {
-                return NO_CONFIG;
-            }
-            // normal case: decrement by 1
-            return currentValue - 1;
-        }
-    }
-
-    @Override
-    public boolean mouseWheelMove(double mouseX, double mouseY, double wheelDelta) {
-        if (isConfiguratorOpen()) return true;
-        if (isMouseOverElement(mouseX, mouseY) && gui != null) {
-            int newValue = getNextValue(wheelDelta >= 0);
-            setCircuitValue(newValue);
-            return true;
-        }
-        return false;
-    }
-
-    @Override
-    public boolean mouseDragged(double mouseX, double mouseY, int button, double dragX, double dragY) {
-        return false;
-    }
-
-    @Override
-    public boolean canMergeSlot(ItemStack stack) {
-        return false;
-    }
-
-    public void setCircuitValue(int newValue) {
-        if (newValue == NO_CONFIG) {
-            this.circuitInventory.setStackInSlot(0, ItemStack.EMPTY);
-            writeClientAction(SET_TO_EMPTY, buf -> {});
-        } else {
-            this.circuitInventory.setStackInSlot(0, IntCircuitBehaviour.stack(newValue));
-            writeClientAction(SET_TO_N, buf -> buf.writeVarInt(newValue));
-        }
-    }
-
-    @Override
-    public void handleClientAction(int id, FriendlyByteBuf buffer) {
-        switch (id) {
-            case SET_TO_ZERO -> this.circuitInventory.setStackInSlot(0, IntCircuitBehaviour.stack(0));
-            case SET_TO_EMPTY -> this.circuitInventory.setStackInSlot(0, ItemStack.EMPTY);
-            case SET_TO_N -> this.circuitInventory.setStackInSlot(0, IntCircuitBehaviour.stack(buffer.readVarInt()));
-        }
-    }
-
-    public Widget createConfigurator() {
-        var group = new WidgetGroup(0, 0, 174, 132);
-        group.addWidget(new LabelWidget(9, 8, "Programmed Circuit Configuration"));
-        group.addWidget(new SlotWidget(this.circuitInventory, 0, (group.getSize().width - 18) / 2, 20,
-                !ConfigHolder.INSTANCE.machines.ghostCircuit, !ConfigHolder.INSTANCE.machines.ghostCircuit)
-                .setBackground(new GuiTextureGroup(GuiTextures.SLOT, GuiTextures.INT_CIRCUIT_OVERLAY)));
-        if (ConfigHolder.INSTANCE.machines.ghostCircuit) {
-            group.addWidget(new ButtonWidget((group.getSize().width - 18) / 2, 20, 18, 18, IGuiTexture.EMPTY,
-                    clickData -> {
-                        if (!clickData.isRemote) {
-                            circuitInventory.setStackInSlot(0, ItemStack.EMPTY);
-                        }
-                    }));
-        }
-        int idx = 0;
-        for (int x = 0; x <= 2; x++) {
-            for (int y = 0; y <= 8; y++) {
-                int finalIdx = idx;
-                group.addWidget(new ButtonWidget(5 + (18 * y), 48 + (18 * x), 18, 18,
-                        new GuiTextureGroup(GuiTextures.SLOT,
-                                new ItemStackTexture(IntCircuitBehaviour.stack(finalIdx)).scale(16f / 18)),
-                        clickData -> {
-                            if (!clickData.isRemote) {
-                                ItemStack stack = circuitInventory.getStackInSlot(0).copy();
-                                if (IntCircuitBehaviour.isIntegratedCircuit(stack)) {
-                                    IntCircuitBehaviour.setCircuitConfiguration(stack, finalIdx);
-                                    circuitInventory.setStackInSlot(0, stack);
-                                } else if (ConfigHolder.INSTANCE.machines.ghostCircuit) {
-                                    circuitInventory.setStackInSlot(0, IntCircuitBehaviour.stack(finalIdx));
-                                }
-                            }
-                        }));
-                idx++;
-            }
-        }
-        for (int x = 0; x <= 5; x++) {
-            int finalIdx = x + 27;
-            group.addWidget(new ButtonWidget(5 + (18 * x), 102, 18, 18,
-                    new GuiTextureGroup(GuiTextures.SLOT,
-                            new ItemStackTexture(IntCircuitBehaviour.stack(finalIdx)).scale(16f / 18)),
-                    clickData -> {
-                        if (!clickData.isRemote) {
-                            ItemStack stack = circuitInventory.getStackInSlot(0).copy();
-                            if (IntCircuitBehaviour.isIntegratedCircuit(stack)) {
-                                IntCircuitBehaviour.setCircuitConfiguration(stack, finalIdx);
-                                circuitInventory.setStackInSlot(0, stack);
-                            } else if (ConfigHolder.INSTANCE.machines.ghostCircuit) {
-                                circuitInventory.setStackInSlot(0, IntCircuitBehaviour.stack(finalIdx));
-                            }
-                        }
-                    }));
-        }
-        group.setBackground(GuiTextures.BACKGROUND);
-        return group;
-    }
-}
diff --git a/src/main/java/com/gregtechceu/gtceu/api/gui/widget/IntInputWidget.java b/src/main/java/com/gregtechceu/gtceu/api/gui/widget/IntInputWidget.java
deleted file mode 100644
index 887c9c9f6ae..00000000000
--- a/src/main/java/com/gregtechceu/gtceu/api/gui/widget/IntInputWidget.java
+++ /dev/null
@@ -1,88 +0,0 @@
-package com.gregtechceu.gtceu.api.gui.widget;
-
-import com.lowdragmc.lowdraglib.gui.widget.TextFieldWidget;
-import com.lowdragmc.lowdraglib.utils.Position;
-import com.lowdragmc.lowdraglib.utils.Size;
-
-import net.minecraft.util.Mth;
-
-import java.util.function.Consumer;
-import java.util.function.Supplier;
-
-/**
- * A widget containing an integer input field, as well as adjacent buttons for increasing or decreasing the value.
- *
- * <p>
- * The buttons' change amount can be altered with Ctrl, Shift, or both.<br>
- * The input is limited by a minimum and maximum value.
- * </p>
- */
-public class IntInputWidget extends NumberInputWidget<Integer> {
-
-    public IntInputWidget(Supplier<Integer> valueSupplier, Consumer<Integer> onChanged) {
-        super(valueSupplier, onChanged);
-    }
-
-    public IntInputWidget(Position position, Supplier<Integer> valueSupplier, Consumer<Integer> onChanged) {
-        super(position, valueSupplier, onChanged);
-    }
-
-    public IntInputWidget(Position position, Size size, Supplier<Integer> valueSupplier, Consumer<Integer> onChanged) {
-        super(position, size, valueSupplier, onChanged);
-    }
-
-    public IntInputWidget(int x, int y, int width, int height, Supplier<Integer> valueSupplier,
-                          Consumer<Integer> onChanged) {
-        super(x, y, width, height, valueSupplier, onChanged);
-    }
-
-    @Override
-    protected Integer defaultMin() {
-        return 0;
-    }
-
-    @Override
-    protected Integer defaultMax() {
-        return Integer.MAX_VALUE;
-    }
-
-    @Override
-    protected String toText(Integer value) {
-        return String.valueOf(value);
-    }
-
-    @Override
-    protected Integer fromText(String value) {
-        return Integer.parseInt(value);
-    }
-
-    @Override
-    protected NumberInputWidget.ChangeValues<Integer> getChangeValues() {
-        return new NumberInputWidget.ChangeValues<>(1, 8, 64, 512);
-    }
-
-    @Override
-    protected Integer getOne(boolean positive) {
-        return positive ? 1 : -1;
-    }
-
-    @Override
-    protected Integer add(Integer a, Integer b) {
-        return a + b;
-    }
-
-    @Override
-    protected Integer multiply(Integer a, Integer b) {
-        return a * b;
-    }
-
-    @Override
-    protected Integer clamp(Integer value, Integer min, Integer max) {
-        return Mth.clamp(value, min, max);
-    }
-
-    @Override
-    protected void setTextFieldRange(TextFieldWidget textField, Integer min, Integer max) {
-        textField.setNumbersOnly(min, max);
-    }
-}
diff --git a/src/main/java/com/gregtechceu/gtceu/api/gui/widget/LongInputWidget.java b/src/main/java/com/gregtechceu/gtceu/api/gui/widget/LongInputWidget.java
deleted file mode 100644
index e7a761a2775..00000000000
--- a/src/main/java/com/gregtechceu/gtceu/api/gui/widget/LongInputWidget.java
+++ /dev/null
@@ -1,88 +0,0 @@
-package com.gregtechceu.gtceu.api.gui.widget;
-
-import com.gregtechceu.gtceu.utils.GTMath;
-
-import com.lowdragmc.lowdraglib.gui.widget.TextFieldWidget;
-import com.lowdragmc.lowdraglib.utils.Position;
-import com.lowdragmc.lowdraglib.utils.Size;
-
-import java.util.function.Consumer;
-import java.util.function.Supplier;
-
-/**
- * A widget containing an integer input field, as well as adjacent buttons for increasing or decreasing the value.
- *
- * <p>
- * The buttons' change amount can be altered with Ctrl, Shift, or both.<br>
- * The input is limited by a minimum and maximum value.
- * </p>
- */
-public class LongInputWidget extends NumberInputWidget<Long> {
-
-    public LongInputWidget(Supplier<Long> valueSupplier, Consumer<Long> onChanged) {
-        super(valueSupplier, onChanged);
-    }
-
-    public LongInputWidget(Position position, Supplier<Long> valueSupplier, Consumer<Long> onChanged) {
-        super(position, valueSupplier, onChanged);
-    }
-
-    public LongInputWidget(Position position, Size size, Supplier<Long> valueSupplier, Consumer<Long> onChanged) {
-        super(position, size, valueSupplier, onChanged);
-    }
-
-    public LongInputWidget(int x, int y, int width, int height, Supplier<Long> valueSupplier,
-                           Consumer<Long> onChanged) {
-        super(x, y, width, height, valueSupplier, onChanged);
-    }
-
-    @Override
-    protected Long defaultMin() {
-        return 0L;
-    }
-
-    @Override
-    protected Long defaultMax() {
-        return Long.MAX_VALUE;
-    }
-
-    @Override
-    protected String toText(Long value) {
-        return String.valueOf(value);
-    }
-
-    @Override
-    protected Long fromText(String value) {
-        return Long.parseLong(value);
-    }
-
-    @Override
-    protected ChangeValues<Long> getChangeValues() {
-        return new ChangeValues<>(1L, 8L, 64L, 512L);
-    }
-
-    @Override
-    protected Long add(Long a, Long b) {
-        return a + b;
-    }
-
-    @Override
-    protected Long multiply(Long a, Long b) {
-        return a * b;
-    }
-
-    @Override
-    protected Long clamp(Long value, Long min, Long max) {
-        return GTMath.clamp(value, min, max);
-    }
-
-    @Override
-    protected void setTextFieldRange(TextFieldWidget textField, Long min, Long max) {
-        textField.setNumbersOnly(min, max);
-    }
-
-    @Override
-    protected Long getOne(boolean positive) {
-        return positive ? 1L : -1L;
-    }
-}
diff --git a/src/main/java/com/gregtechceu/gtceu/api/gui/widget/NumberInputWidget.java b/src/main/java/com/gregtechceu/gtceu/api/gui/widget/NumberInputWidget.java
deleted file mode 100644
index fdcd8bf9884..00000000000
--- a/src/main/java/com/gregtechceu/gtceu/api/gui/widget/NumberInputWidget.java
+++ /dev/null
@@ -1,208 +0,0 @@
-package com.gregtechceu.gtceu.api.gui.widget;
-
-import com.gregtechceu.gtceu.GTCEu;
-import com.gregtechceu.gtceu.api.gui.GuiTextures;
-import com.gregtechceu.gtceu.utils.GTUtil;
-
-import com.lowdragmc.lowdraglib.gui.texture.GuiTextureGroup;
-import com.lowdragmc.lowdraglib.gui.texture.IGuiTexture;
-import com.lowdragmc.lowdraglib.gui.texture.TextTexture;
-import com.lowdragmc.lowdraglib.gui.util.ClickData;
-import com.lowdragmc.lowdraglib.gui.widget.ButtonWidget;
-import com.lowdragmc.lowdraglib.gui.widget.TextFieldWidget;
-import com.lowdragmc.lowdraglib.gui.widget.Widget;
-import com.lowdragmc.lowdraglib.gui.widget.WidgetGroup;
-import com.lowdragmc.lowdraglib.utils.Position;
-import com.lowdragmc.lowdraglib.utils.Size;
-
-import net.minecraft.client.Minecraft;
-import net.minecraft.network.FriendlyByteBuf;
-import net.minecraft.util.Mth;
-
-import lombok.Getter;
-
-import java.util.function.Consumer;
-import java.util.function.Supplier;
-
-/**
- * A widget containing an integer input field, as well as adjacent buttons for increasing or decreasing the value.
- *
- * <p>
- * The buttons' change amount can be altered with Ctrl, Shift, or both.<br>
- * The input is limited by a minimum and maximum value.
- * </p>
- */
-public abstract class NumberInputWidget<T extends Number> extends WidgetGroup {
-
-    protected abstract T defaultMin();
-
-    protected abstract T defaultMax();
-
-    protected abstract String toText(T value);
-
-    protected abstract T fromText(String value);
-
-    protected record ChangeValues<T extends Number>(T regular, T shift, T ctrl, T ctrlShift) {}
-
-    protected abstract ChangeValues<T> getChangeValues();
-
-    protected abstract T add(T a, T b);
-
-    protected abstract T multiply(T a, T b);
-
-    protected abstract T clamp(T value, T min, T max);
-
-    protected abstract void setTextFieldRange(TextFieldWidget textField, T min, T max);
-
-    protected abstract T getOne(boolean positive);
-
-    /////////////////////////////////////////////////
-    // *********** IMPLEMENTATION ***********//
-    /////////////////////////////////////////////////
-
-    private final ChangeValues<T> CHANGE_VALUES = getChangeValues();
-    private final T ONE_POSITIVE = getOne(true);
-    private final T ONE_NEGATIVE = getOne(false);
-
-    @Getter
-    private Supplier<T> valueSupplier;
-    @Getter
-    private T min = defaultMin();
-    @Getter
-    private T max = defaultMax();
-
-    private final Consumer<T> onChanged;
-
-    private TextFieldWidget textField;
-
-    public NumberInputWidget(Supplier<T> valueSupplier, Consumer<T> onChanged) {
-        this(0, 0, 100, 20, valueSupplier, onChanged);
-    }
-
-    public NumberInputWidget(Position position, Supplier<T> valueSupplier, Consumer<T> onChanged) {
-        this(position, new Size(100, 20), valueSupplier, onChanged);
-    }
-
-    public NumberInputWidget(Position position, Size size, Supplier<T> valueSupplier, Consumer<T> onChanged) {
-        this(position.x, position.y, size.width, size.height, valueSupplier, onChanged);
-    }
-
-    public NumberInputWidget(int x, int y, int width, int height, Supplier<T> valueSupplier, Consumer<T> onChanged) {
-        super(x, y, width, height);
-        this.valueSupplier = valueSupplier;
-        this.onChanged = onChanged;
-        buildUI();
-    }
-
-    @Override
-    public void initWidget() {
-        super.initWidget();
-        textField.setCurrentString(toText(valueSupplier.get()));
-    }
-
-    @Override
-    public void writeInitialData(FriendlyByteBuf buffer) {
-        super.writeInitialData(buffer);
-        buffer.writeUtf(toText(valueSupplier.get()));
-    }
-
-    @Override
-    public void readInitialData(FriendlyByteBuf buffer) {
-        super.readInitialData(buffer);
-        textField.setCurrentString(buffer.readUtf());
-    }
-
-    @Override
-    public Widget setHoverTooltips(String... tooltipText) {
-        textField.setHoverTooltips(tooltipText);
-        return super.setHoverTooltips(tooltipText);
-    }
-
-    private void buildUI() {
-        int buttonWidth = Mth.clamp(this.getSize().width / 5, 15, 40);
-        int textFieldWidth = this.getSize().width - (2 * buttonWidth) - 4;
-
-        this.addWidget(new ButtonWidget(0, 0, buttonWidth, 20,
-                new GuiTextureGroup(GuiTextures.VANILLA_BUTTON, getButtonTexture("-", buttonWidth)),
-                this::decrease).setHoverTooltips("gui.widget.incrementButton.default_tooltip"));
-
-        this.textField = new TextFieldWidget(buttonWidth + 2, 0, textFieldWidth, 20,
-                () -> toText(valueSupplier.get()),
-                stringValue -> this.setValue(clamp(fromText(stringValue), min, max)));
-        this.updateTextFieldRange();
-        this.addWidget(this.textField);
-
-        this.addWidget(new ButtonWidget(buttonWidth + textFieldWidth + 4, 0, buttonWidth, 20,
-                new GuiTextureGroup(GuiTextures.VANILLA_BUTTON, getButtonTexture("+", buttonWidth)),
-                this::increase).setHoverTooltips("gui.widget.incrementButton.default_tooltip"));
-    }
-
-    private IGuiTexture getButtonTexture(String prefix, int buttonWidth) {
-        var texture = new TextTexture(prefix + "1");
-
-        if (!GTCEu.isClientThread()) {
-            return texture;
-        }
-
-        // Dynamic text is only necessary on the remote side:
-
-        int maxTextWidth = buttonWidth - 4;
-
-        texture.setSupplier(() -> {
-            T amount = GTUtil.isCtrlDown() ?
-                    GTUtil.isShiftDown() ? CHANGE_VALUES.ctrlShift : CHANGE_VALUES.ctrl :
-                    GTUtil.isShiftDown() ? CHANGE_VALUES.shift : CHANGE_VALUES.regular;
-
-            String text = prefix + toText(amount);
-
-            texture.scale(maxTextWidth / (float) Math.max(Minecraft.getInstance().font.width(text), maxTextWidth));
-
-            return text;
-        });
-
-        return texture;
-    }
-
-    private void increase(ClickData cd) {
-        this.changeValue(cd, ONE_POSITIVE);
-    }
-
-    private void decrease(ClickData cd) {
-        this.changeValue(cd, ONE_NEGATIVE);
-    }
-
-    private void changeValue(ClickData cd, T multiplier) {
-        if (!cd.isRemote) {
-            T amount = cd.isCtrlClick ?
-                    cd.isShiftClick ? CHANGE_VALUES.ctrlShift : CHANGE_VALUES.ctrl :
-                    cd.isShiftClick ? CHANGE_VALUES.shift : CHANGE_VALUES.regular;
-
-            this.setValue(clamp(add(valueSupplier.get(), multiply(amount, multiplier)), min, max));
-        }
-    }
-
-    public NumberInputWidget<T> setMin(T min) {
-        this.min = min;
-        updateTextFieldRange();
-
-        return this;
-    }
-
-    public NumberInputWidget<T> setMax(T max) {
-        this.max = max;
-        updateTextFieldRange();
-
-        return this;
-    }
-
-    public NumberInputWidget<T> setValue(T value) {
-        onChanged.accept(value);
-        return this;
-    }
-
-    protected void updateTextFieldRange() {
-        setTextFieldRange(textField, min, max);
-
-        this.setValue(clamp(valueSupplier.get(), min, max));
-    }
-}
diff --git a/src/main/java/com/gregtechceu/gtceu/api/gui/widget/PatternPreviewWidget.java b/src/main/java/com/gregtechceu/gtceu/api/gui/widget/PatternPreviewWidget.java
index 182707f3530..087670b518f 100644
--- a/src/main/java/com/gregtechceu/gtceu/api/gui/widget/PatternPreviewWidget.java
+++ b/src/main/java/com/gregtechceu/gtceu/api/gui/widget/PatternPreviewWidget.java
@@ -10,7 +10,7 @@
 import com.gregtechceu.gtceu.api.pattern.TraceabilityPredicate;
 import com.gregtechceu.gtceu.api.pattern.predicates.SimplePredicate;
 import com.gregtechceu.gtceu.config.ConfigHolder;
-import com.gregtechceu.gtceu.integration.xei.handlers.item.CycleItemEntryHandler;
+import com.gregtechceu.gtceu.integration.recipeviewer.handlers.item.CycleItemEntryHandler;
 
 import com.lowdragmc.lowdraglib.client.scene.WorldSceneRenderer;
 import com.lowdragmc.lowdraglib.client.utils.RenderUtils;
diff --git a/src/main/java/com/gregtechceu/gtceu/api/gui/widget/PhantomSlotWidget.java b/src/main/java/com/gregtechceu/gtceu/api/gui/widget/PhantomSlotWidget.java
deleted file mode 100644
index 190de3930ff..00000000000
--- a/src/main/java/com/gregtechceu/gtceu/api/gui/widget/PhantomSlotWidget.java
+++ /dev/null
@@ -1,258 +0,0 @@
-package com.gregtechceu.gtceu.api.gui.widget;
-
-import com.gregtechceu.gtceu.GTCEu;
-
-import com.lowdragmc.lowdraglib.gui.editor.annotation.ConfigSetter;
-import com.lowdragmc.lowdraglib.gui.editor.annotation.Configurable;
-import com.lowdragmc.lowdraglib.gui.editor.annotation.LDLRegister;
-import com.lowdragmc.lowdraglib.gui.editor.annotation.NumberRange;
-import com.lowdragmc.lowdraglib.gui.editor.configurator.IConfigurableWidget;
-import com.lowdragmc.lowdraglib.gui.ingredient.IGhostIngredientTarget;
-import com.lowdragmc.lowdraglib.gui.ingredient.Target;
-
-import net.minecraft.client.Minecraft;
-import net.minecraft.client.renderer.Rect2i;
-import net.minecraft.network.FriendlyByteBuf;
-import net.minecraft.world.entity.player.Player;
-import net.minecraft.world.inventory.ClickType;
-import net.minecraft.world.inventory.Slot;
-import net.minecraft.world.item.Item;
-import net.minecraft.world.item.ItemStack;
-import net.minecraftforge.api.distmarker.Dist;
-import net.minecraftforge.api.distmarker.OnlyIn;
-import net.minecraftforge.items.IItemHandlerModifiable;
-
-import com.google.common.collect.Lists;
-import com.mojang.blaze3d.platform.InputConstants;
-import dev.emi.emi.api.stack.EmiStack;
-import mezz.jei.api.ingredients.ITypedIngredient;
-import org.lwjgl.glfw.GLFW;
-
-import java.util.Collections;
-import java.util.List;
-import java.util.function.Predicate;
-
-import javax.annotation.Nonnull;
-
-@LDLRegister(name = "gtm_phantom_item_slot", group = "widget.gtm_container", priority = 50)
-public class PhantomSlotWidget extends SlotWidget implements IGhostIngredientTarget, IConfigurableWidget {
-
-    private boolean clearSlotOnRightClick;
-
-    @Configurable
-    @NumberRange(range = { 0, 64 })
-    private int maxStackSize = 64;
-
-    private Predicate<ItemStack> validator = stack -> true;
-
-    public PhantomSlotWidget() {
-        super();
-    }
-
-    public PhantomSlotWidget(IItemHandlerModifiable itemHandler, int slotIndex, int xPosition, int yPosition) {
-        super(itemHandler, slotIndex, xPosition, yPosition, true, true);
-    }
-
-    public PhantomSlotWidget(IItemHandlerModifiable itemHandler, int slotIndex, int xPosition, int yPosition,
-                             Predicate<ItemStack> validator) {
-        super(itemHandler, slotIndex, xPosition, yPosition, true, true);
-        this.validator = validator;
-    }
-
-    public PhantomSlotWidget setClearSlotOnRightClick(boolean clearSlotOnRightClick) {
-        this.clearSlotOnRightClick = clearSlotOnRightClick;
-        return this;
-    }
-
-    @ConfigSetter(field = "canTakeItems")
-    public PhantomSlotWidget setCanTakeItems(boolean v) {
-        // you cant modify it
-        return this;
-    }
-
-    @ConfigSetter(field = "canPutItems")
-    public PhantomSlotWidget setCanPutItems(boolean v) {
-        // you cant modify it
-        return this;
-    }
-
-    public PhantomSlotWidget setMaxStackSize(int stackSize) {
-        maxStackSize = stackSize;
-        return this;
-    }
-
-    @Override
-    public boolean mouseClicked(double mouseX, double mouseY, int button) {
-        if (slotReference != null && isMouseOverElement(mouseX, mouseY) && gui != null) {
-            if (isClientSideWidget && !gui.getModularUIContainer().getCarried().isEmpty()) {
-                slotReference.set(gui.getModularUIContainer().getCarried());
-            } else if (button == 1 && clearSlotOnRightClick && !slotReference.getItem().isEmpty()) {
-                slotReference.set(ItemStack.EMPTY);
-                writeClientAction(2, buf -> {});
-            } else {
-                HOVER_SLOT = slotReference;
-                gui.getModularUIGui().superMouseClicked(mouseX, mouseY, button);
-                HOVER_SLOT = null;
-            }
-            return true;
-        }
-        return false;
-    }
-
-    @Override
-    public ItemStack slotClick(int dragType, ClickType clickTypeIn, Player player) {
-        if (slotReference != null && gui != null) {
-            ItemStack stackHeld = gui.getModularUIContainer().getCarried();
-            return slotClickPhantom(slotReference, dragType, clickTypeIn, stackHeld);
-        }
-        return ItemStack.EMPTY;
-    }
-
-    @Override
-    public boolean canMergeSlot(ItemStack stack) {
-        return false;
-    }
-
-    @Override
-    public boolean canTakeStack(Player player) {
-        return false;
-    }
-
-    @Override
-    public boolean canPutStack(ItemStack stack) {
-        return false;
-    }
-
-    @Override
-    @OnlyIn(Dist.CLIENT)
-    public List<Target> getPhantomTargets(Object ingredient) {
-        if (GTCEu.Mods.isEMILoaded() && ingredient instanceof EmiStack emiStack) {
-            Item item = emiStack.getKeyOfType(Item.class);
-            if (item != null) {
-                ingredient = new ItemStack(item, (int) emiStack.getAmount());
-                ((ItemStack) ingredient).setTag(emiStack.getNbt());
-            }
-        } else if (GTCEu.Mods.isJEILoaded() && ingredient instanceof ITypedIngredient<?> jeiStack) {
-            ingredient = jeiStack.getItemStack().orElse(null);
-        }
-        if (!(ingredient instanceof ItemStack)) {
-            return Collections.emptyList();
-        }
-
-        Rect2i rectangle = toRectangleBox();
-        return Lists.newArrayList(new Target() {
-
-            @Nonnull
-            @Override
-            public Rect2i getArea() {
-                return rectangle;
-            }
-
-            @Override
-            public void accept(@Nonnull Object ingredient) {
-                if (GTCEu.Mods.isEMILoaded() && ingredient instanceof EmiStack emiStack) {
-                    Item item = emiStack.getKeyOfType(Item.class);
-                    if (item != null) {
-                        ingredient = new ItemStack(item, (int) emiStack.getAmount());
-                        ((ItemStack) ingredient).setTag(emiStack.getNbt());
-                    }
-                } else if (GTCEu.Mods.isJEILoaded() && ingredient instanceof ITypedIngredient<?> jeiStack) {
-                    ingredient = jeiStack.getItemStack().orElse(null);
-                }
-                if (slotReference != null && ingredient instanceof ItemStack stack) {
-                    long id = Minecraft.getInstance().getWindow().getWindow();
-                    boolean shiftDown = InputConstants.isKeyDown(id, GLFW.GLFW_KEY_LEFT_SHIFT);
-                    ClickType clickType = shiftDown ? ClickType.QUICK_MOVE : ClickType.PICKUP;
-                    slotClickPhantom(slotReference, 0, clickType, stack);
-                    writeClientAction(1, buffer -> {
-                        buffer.writeItem(stack);
-                        buffer.writeVarInt(0);
-                        buffer.writeBoolean(shiftDown);
-                    });
-                }
-            }
-        });
-    }
-
-    @Override
-    public void handleClientAction(int id, FriendlyByteBuf buffer) {
-        if (slotReference != null && id == 1) {
-            ItemStack stackHeld = buffer.readItem();
-            int mouseButton = buffer.readVarInt();
-            boolean shiftKeyDown = buffer.readBoolean();
-            ClickType clickType = shiftKeyDown ? ClickType.QUICK_MOVE : ClickType.PICKUP;
-            slotClickPhantom(slotReference, mouseButton, clickType, stackHeld);
-        } else if (slotReference != null && id == 2) {
-            slotReference.set(ItemStack.EMPTY);
-        }
-    }
-
-    public ItemStack slotClickPhantom(Slot slot, int mouseButton, ClickType clickTypeIn, ItemStack stackHeld) {
-        ItemStack stack = ItemStack.EMPTY;
-
-        ItemStack stackSlot = slot.getItem();
-        if (!stackSlot.isEmpty()) {
-            stack = stackSlot.copy();
-        }
-
-        if (mouseButton == 2) {
-            fillPhantomSlot(slot, ItemStack.EMPTY, mouseButton);
-        } else if (mouseButton == 0 || mouseButton == 1) {
-
-            if (stackSlot.isEmpty()) {
-                if (!stackHeld.isEmpty()) {
-                    fillPhantomSlot(slot, stackHeld, mouseButton);
-                }
-            } else if (stackHeld.isEmpty()) {
-                adjustPhantomSlot(slot, mouseButton, clickTypeIn);
-            } else {
-                if (!areItemsEqual(stackSlot, stackHeld)) {
-                    adjustPhantomSlot(slot, mouseButton, clickTypeIn);
-                }
-                fillPhantomSlot(slot, stackHeld, mouseButton);
-            }
-        } else if (mouseButton == 5) {
-            if (!slot.hasItem()) {
-                fillPhantomSlot(slot, stackHeld, mouseButton);
-            }
-        }
-        return stack;
-    }
-
-    private void adjustPhantomSlot(Slot slot, int mouseButton, ClickType clickTypeIn) {
-        ItemStack stackSlot = slot.getItem();
-        int stackSize;
-        if (clickTypeIn == ClickType.QUICK_MOVE) {
-            stackSize = mouseButton == 0 ? (stackSlot.getCount() + 1) / 2 : stackSlot.getCount() * 2;
-        } else {
-            stackSize = mouseButton == 0 ? stackSlot.getCount() - 1 : stackSlot.getCount() + 1;
-        }
-
-        if (stackSize > slot.getMaxStackSize()) {
-            stackSize = slot.getMaxStackSize();
-        }
-
-        stackSlot.setCount(Math.min(maxStackSize, stackSize));
-
-        slot.set(stackSlot);
-    }
-
-    private void fillPhantomSlot(Slot slot, ItemStack stackHeld, int mouseButton) {
-        if (stackHeld.isEmpty()) {
-            slot.set(ItemStack.EMPTY);
-            return;
-        }
-
-        int stackSize = mouseButton == 0 ? stackHeld.getCount() : 1;
-        if (stackSize > slot.getMaxStackSize()) {
-            stackSize = slot.getMaxStackSize();
-        }
-        ItemStack phantomStack = stackHeld.copy();
-        phantomStack.setCount(Math.min(maxStackSize, stackSize));
-        if (validator.test(phantomStack)) slot.set(phantomStack);
-    }
-
-    public boolean areItemsEqual(ItemStack itemStack1, ItemStack itemStack2) {
-        return ItemStack.matches(itemStack1, itemStack2);
-    }
-}
diff --git a/src/main/java/com/gregtechceu/gtceu/api/gui/widget/PredicatedImageWidget.java b/src/main/java/com/gregtechceu/gtceu/api/gui/widget/PredicatedImageWidget.java
deleted file mode 100644
index be26db6e526..00000000000
--- a/src/main/java/com/gregtechceu/gtceu/api/gui/widget/PredicatedImageWidget.java
+++ /dev/null
@@ -1,69 +0,0 @@
-package com.gregtechceu.gtceu.api.gui.widget;
-
-import com.lowdragmc.lowdraglib.gui.texture.IGuiTexture;
-import com.lowdragmc.lowdraglib.gui.widget.ImageWidget;
-
-import net.minecraft.client.gui.GuiGraphics;
-import net.minecraft.network.FriendlyByteBuf;
-import net.minecraftforge.api.distmarker.Dist;
-import net.minecraftforge.api.distmarker.OnlyIn;
-
-import lombok.Setter;
-import lombok.experimental.Accessors;
-import org.jetbrains.annotations.NotNull;
-
-import java.util.function.BooleanSupplier;
-
-@Accessors(chain = true)
-public class PredicatedImageWidget extends ImageWidget {
-
-    @Setter
-    private BooleanSupplier predicate;
-    private boolean isVisible = true;
-
-    public PredicatedImageWidget(int xPosition, int yPosition, int width, int height, IGuiTexture area) {
-        super(xPosition, yPosition, width, height, area);
-    }
-
-    @Override
-    public void writeInitialData(FriendlyByteBuf buffer) {
-        super.writeInitialData(buffer);
-        isVisible = predicate == null || predicate.getAsBoolean();
-        buffer.writeBoolean(isVisible);
-    }
-
-    @Override
-    public void readInitialData(FriendlyByteBuf buffer) {
-        super.readInitialData(buffer);
-        isVisible = buffer.readBoolean();
-    }
-
-    @Override
-    public void detectAndSendChanges() {
-        super.detectAndSendChanges();
-        if (predicate != null) {
-            if (isVisible != predicate.getAsBoolean()) {
-                isVisible = !isVisible;
-                writeUpdateInfo(1, buf -> buf.writeBoolean(isVisible));
-            }
-        }
-    }
-
-    @Override
-    @OnlyIn(Dist.CLIENT)
-    public void readUpdateInfo(int id, FriendlyByteBuf buffer) {
-        if (id == 1) {
-            isVisible = buffer.readBoolean();
-        } else {
-            super.readUpdateInfo(id, buffer);
-        }
-    }
-
-    @Override
-    @OnlyIn(Dist.CLIENT)
-    public void drawInBackground(@NotNull GuiGraphics graphics, int mouseX, int mouseY, float partialTicks) {
-        if (isVisible) {
-            super.drawInBackground(graphics, mouseX, mouseY, partialTicks);
-        }
-    }
-}
diff --git a/src/main/java/com/gregtechceu/gtceu/api/gui/widget/ScrollablePhantomFluidWidget.java b/src/main/java/com/gregtechceu/gtceu/api/gui/widget/ScrollablePhantomFluidWidget.java
deleted file mode 100644
index 93f621d2aaa..00000000000
--- a/src/main/java/com/gregtechceu/gtceu/api/gui/widget/ScrollablePhantomFluidWidget.java
+++ /dev/null
@@ -1,78 +0,0 @@
-package com.gregtechceu.gtceu.api.gui.widget;
-
-import com.gregtechceu.gtceu.api.transfer.fluid.IFluidHandlerModifiable;
-import com.gregtechceu.gtceu.utils.GTUtil;
-
-import net.minecraft.network.FriendlyByteBuf;
-import net.minecraftforge.api.distmarker.Dist;
-import net.minecraftforge.api.distmarker.OnlyIn;
-import net.minecraftforge.fluids.FluidStack;
-
-import org.jetbrains.annotations.Nullable;
-
-import java.util.function.Consumer;
-import java.util.function.Supplier;
-
-public class ScrollablePhantomFluidWidget extends PhantomFluidWidget {
-
-    private static final int SCROLL_ACTION_ID = 0x0001_0001;
-
-    public ScrollablePhantomFluidWidget(@Nullable IFluidHandlerModifiable fluidTank, int tank, int x, int y, int width,
-                                        int height, Supplier<FluidStack> phantomFluidGetter,
-                                        Consumer<FluidStack> phantomFluidSetter) {
-        super(fluidTank, tank, x, y, width, height, phantomFluidGetter, phantomFluidSetter);
-    }
-
-    @Override
-    @OnlyIn(Dist.CLIENT)
-    public boolean mouseWheelMove(double mouseX, double mouseY, double wheelDelta) {
-        if (!isMouseOverElement(mouseX, mouseY))
-            return false;
-
-        var delta = getModifiedChangeAmount((wheelDelta > 0) ? 1 : -1);
-        writeClientAction(SCROLL_ACTION_ID, buf -> buf.writeInt(delta));
-
-        return true;
-    }
-
-    private int getModifiedChangeAmount(int amount) {
-        if (GTUtil.isShiftDown())
-            amount *= 10;
-
-        if (GTUtil.isCtrlDown())
-            amount *= 100;
-
-        if (!GTUtil.isAltDown())
-            amount *= 1000;
-
-        return amount;
-    }
-
-    @Override
-    public void handleClientAction(int id, FriendlyByteBuf buffer) {
-        switch (id) {
-            case SCROLL_ACTION_ID -> handleScrollAction(buffer.readInt());
-            default -> super.handleClientAction(id, buffer);
-        }
-
-        detectAndSendChanges();
-    }
-
-    private void handleScrollAction(int delta) {
-        IFluidHandlerModifiable fluidTank = (IFluidHandlerModifiable) getFluidTank();
-        if (fluidTank == null)
-            return;
-
-        FluidStack fluid = fluidTank.getFluidInTank(tank);
-        if (fluid.isEmpty())
-            return;
-
-        if (fluid.isEmpty())
-            return;
-
-        fluid.setAmount(Math.min(Math.max(fluid.getAmount() + delta, 0), fluidTank.getTankCapacity(tank)));
-        if (fluid.getAmount() <= 0L) {
-            fluidTank.setFluidInTank(tank, FluidStack.EMPTY);
-        }
-    }
-}
diff --git a/src/main/java/com/gregtechceu/gtceu/api/gui/widget/SlotWidget.java b/src/main/java/com/gregtechceu/gtceu/api/gui/widget/SlotWidget.java
index ef7f6b23990..52b383b7ccc 100644
--- a/src/main/java/com/gregtechceu/gtceu/api/gui/widget/SlotWidget.java
+++ b/src/main/java/com/gregtechceu/gtceu/api/gui/widget/SlotWidget.java
@@ -1,10 +1,10 @@
 package com.gregtechceu.gtceu.api.gui.widget;
 
 import com.gregtechceu.gtceu.GTCEu;
-import com.gregtechceu.gtceu.integration.xei.entry.item.ItemEntryList;
-import com.gregtechceu.gtceu.integration.xei.entry.item.ItemStackList;
-import com.gregtechceu.gtceu.integration.xei.entry.item.ItemTagList;
-import com.gregtechceu.gtceu.integration.xei.handlers.item.CycleItemEntryHandler;
+import com.gregtechceu.gtceu.integration.recipeviewer.entry.item.ItemEntryList;
+import com.gregtechceu.gtceu.integration.recipeviewer.entry.item.ItemStackList;
+import com.gregtechceu.gtceu.integration.recipeviewer.entry.item.ItemTagList;
+import com.gregtechceu.gtceu.integration.recipeviewer.handlers.item.CycleItemEntryHandler;
 
 import com.lowdragmc.lowdraglib.gui.editor.annotation.LDLRegister;
 import com.lowdragmc.lowdraglib.gui.editor.configurator.ConfiguratorGroup;
diff --git a/src/main/java/com/gregtechceu/gtceu/api/gui/widget/TankWidget.java b/src/main/java/com/gregtechceu/gtceu/api/gui/widget/TankWidget.java
index 5230f99742d..2e474162c67 100644
--- a/src/main/java/com/gregtechceu/gtceu/api/gui/widget/TankWidget.java
+++ b/src/main/java/com/gregtechceu/gtceu/api/gui/widget/TankWidget.java
@@ -4,10 +4,10 @@
 import com.gregtechceu.gtceu.api.machine.trait.NotifiableFluidTank;
 import com.gregtechceu.gtceu.api.transfer.fluid.IFluidHandlerModifiable;
 import com.gregtechceu.gtceu.client.TooltipsHandler;
-import com.gregtechceu.gtceu.integration.xei.entry.fluid.FluidEntryList;
-import com.gregtechceu.gtceu.integration.xei.entry.fluid.FluidStackList;
-import com.gregtechceu.gtceu.integration.xei.entry.fluid.FluidTagList;
-import com.gregtechceu.gtceu.integration.xei.handlers.fluid.CycleFluidEntryHandler;
+import com.gregtechceu.gtceu.integration.recipeviewer.entry.fluid.FluidEntryList;
+import com.gregtechceu.gtceu.integration.recipeviewer.entry.fluid.FluidStackList;
+import com.gregtechceu.gtceu.integration.recipeviewer.entry.fluid.FluidTagList;
+import com.gregtechceu.gtceu.integration.recipeviewer.handlers.fluid.CycleFluidEntryHandler;
 import com.gregtechceu.gtceu.utils.FormattingUtil;
 import com.gregtechceu.gtceu.utils.GTUtil;
 
diff --git a/src/main/java/com/gregtechceu/gtceu/api/gui/widget/ToggleButtonWidget.java b/src/main/java/com/gregtechceu/gtceu/api/gui/widget/ToggleButtonWidget.java
deleted file mode 100644
index 716725601e1..00000000000
--- a/src/main/java/com/gregtechceu/gtceu/api/gui/widget/ToggleButtonWidget.java
+++ /dev/null
@@ -1,75 +0,0 @@
-package com.gregtechceu.gtceu.api.gui.widget;
-
-import com.gregtechceu.gtceu.api.gui.GuiTextures;
-import com.gregtechceu.gtceu.data.lang.LangHandler;
-
-import com.lowdragmc.lowdraglib.gui.texture.GuiTextureGroup;
-import com.lowdragmc.lowdraglib.gui.texture.IGuiTexture;
-import com.lowdragmc.lowdraglib.gui.texture.ResourceTexture;
-import com.lowdragmc.lowdraglib.gui.widget.SwitchWidget;
-
-import it.unimi.dsi.fastutil.booleans.BooleanConsumer;
-
-import java.util.List;
-import java.util.function.BooleanSupplier;
-
-public class ToggleButtonWidget extends SwitchWidget {
-
-    private final IGuiTexture texture;
-    private String tooltipText;
-    private boolean isMultiLang;
-
-    public ToggleButtonWidget(int xPosition, int yPosition, int width, int height, BooleanSupplier isPressedCondition,
-                              BooleanConsumer setPressedExecutor) {
-        this(xPosition, yPosition, width, height, GuiTextures.VANILLA_BUTTON, isPressedCondition, setPressedExecutor);
-    }
-
-    public ToggleButtonWidget(int xPosition, int yPosition, int width, int height, IGuiTexture buttonTexture,
-                              BooleanSupplier isPressedCondition, BooleanConsumer setPressedExecutor) {
-        super(xPosition, yPosition, width, height, null);
-        texture = buttonTexture;
-        if (buttonTexture instanceof ResourceTexture resourceTexture) {
-            setTexture(resourceTexture.getSubTexture(0, 0, 1, 0.5), resourceTexture.getSubTexture(0, 0.5, 1, 0.5));
-        } else {
-            setTexture(buttonTexture, buttonTexture);
-        }
-
-        setSupplier(isPressedCondition::getAsBoolean);
-        setOnPressCallback((cd, bool) -> {
-            setPressedExecutor.accept(bool.booleanValue());
-            this.updateHoverTooltips();
-        });
-    }
-
-    public ToggleButtonWidget setShouldUseBaseBackground() {
-        if (texture != null) {
-            setTexture(
-                    new GuiTextureGroup(GuiTextures.TOGGLE_BUTTON_BACK.getSubTexture(0, 0, 1, 0.5), texture),
-                    new GuiTextureGroup(GuiTextures.TOGGLE_BUTTON_BACK.getSubTexture(0, 0.5, 1, 0.5), texture));
-        }
-        return this;
-    }
-
-    public ToggleButtonWidget setTooltipText(String tooltipText) {
-        this.tooltipText = tooltipText;
-        updateHoverTooltips();
-        return this;
-    }
-
-    public ToggleButtonWidget isMultiLang() {
-        isMultiLang = true;
-        updateHoverTooltips();
-        return this;
-    }
-
-    protected void updateHoverTooltips() {
-        if (tooltipText != null) {
-            if (!isMultiLang) {
-                setHoverTooltips(tooltipText + (isPressed ? ".enabled" : ".disabled"));
-            } else {
-                setHoverTooltips(
-                        List.copyOf(LangHandler.getMultiLang(tooltipText + (isPressed ? ".enabled" : ".disabled"))));
-            }
-        }
-    }
-}
diff --git a/src/main/java/com/gregtechceu/gtceu/api/gui/widget/directional/CombinedDirectionalConfigurator.java b/src/main/java/com/gregtechceu/gtceu/api/gui/widget/directional/CombinedDirectionalConfigurator.java
deleted file mode 100644
index cf281d96a37..00000000000
--- a/src/main/java/com/gregtechceu/gtceu/api/gui/widget/directional/CombinedDirectionalConfigurator.java
+++ /dev/null
@@ -1,195 +0,0 @@
-package com.gregtechceu.gtceu.api.gui.widget.directional;
-
-import com.gregtechceu.gtceu.api.gui.GuiTextures;
-import com.gregtechceu.gtceu.api.gui.fancy.FancyMachineUIWidget;
-import com.gregtechceu.gtceu.api.machine.MetaMachine;
-import com.gregtechceu.gtceu.utils.GTUtil;
-
-import com.lowdragmc.lowdraglib.client.scene.ISceneBlockRenderHook;
-import com.lowdragmc.lowdraglib.client.scene.WorldSceneRenderer;
-import com.lowdragmc.lowdraglib.gui.editor.ColorPattern;
-import com.lowdragmc.lowdraglib.gui.util.ClickData;
-import com.lowdragmc.lowdraglib.gui.widget.ImageWidget;
-import com.lowdragmc.lowdraglib.gui.widget.SceneWidget;
-import com.lowdragmc.lowdraglib.gui.widget.Widget;
-import com.lowdragmc.lowdraglib.gui.widget.WidgetGroup;
-import com.lowdragmc.lowdraglib.utils.BlockPosFace;
-import com.lowdragmc.lowdraglib.utils.Position;
-import com.lowdragmc.lowdraglib.utils.Size;
-
-import net.minecraft.MethodsReturnNonnullByDefault;
-import net.minecraft.client.renderer.RenderType;
-import net.minecraft.core.BlockPos;
-import net.minecraft.core.Direction;
-import net.minecraft.network.FriendlyByteBuf;
-import net.minecraftforge.api.distmarker.Dist;
-import net.minecraftforge.api.distmarker.OnlyIn;
-
-import com.mojang.blaze3d.platform.GlStateManager;
-import com.mojang.blaze3d.systems.RenderSystem;
-import org.jetbrains.annotations.Nullable;
-
-import java.util.List;
-
-import javax.annotation.ParametersAreNonnullByDefault;
-
-@MethodsReturnNonnullByDefault
-@ParametersAreNonnullByDefault
-public class CombinedDirectionalConfigurator extends WidgetGroup {
-
-    protected final static int MOUSE_CLICK_CLIENT_ACTION_ID = 0x0001_0001;
-    protected final static int UPDATE_UI_ID = 0x0001_0002;
-
-    protected final IDirectionalConfigHandler[] configHandlers;
-    protected final int width, height;
-    private final FancyMachineUIWidget machineUI;
-    private final MetaMachine machine;
-
-    protected SceneWidget sceneWidget;
-    protected ImageWidget imageWidget;
-
-    protected @Nullable BlockPos selectedPos;
-    protected @Nullable Direction selectedSide;
-
-    public CombinedDirectionalConfigurator(FancyMachineUIWidget machineUI, IDirectionalConfigHandler[] configHandlers,
-                                           MetaMachine machine, int width, int height) {
-        super(0, 0, width, height);
-        this.width = width;
-        this.height = height;
-
-        this.machineUI = machineUI;
-        this.configHandlers = configHandlers;
-        this.machine = machine;
-    }
-
-    @Override
-    public void initWidget() {
-        super.initWidget();
-
-        addWidget(imageWidget = new ImageWidget(0, 0, width, height, GuiTextures.BACKGROUND_INVERSE));
-        addWidget(sceneWidget = createSceneWidget());
-
-        for (IDirectionalConfigHandler configHandler : configHandlers) {
-            configHandler.addAdditionalUIElements(this);
-        }
-
-        addConfigWidgets(sceneWidget);
-    }
-
-    private SceneWidget createSceneWidget() {
-        var pos = this.machine.getBlockPos();
-
-        SceneWidget sceneWidget = new SceneWidget(4, 4, width - 8, height - 8, this.machine.getLevel())
-                .setRenderedCore(List.of(pos), null)
-                .setRenderSelect(false)
-                .setOnSelected(this::onSideSelected);
-
-        if (isRemote()) {
-            sceneWidget.getRenderer().addRenderedBlocks(
-                    List.of(pos.above(), pos.below(), pos.north(), pos.south(), pos.east(), pos.west()),
-                    new ISceneBlockRenderHook() {
-
-                        @Override
-                        @OnlyIn(Dist.CLIENT)
-                        public void apply(boolean isTESR, RenderType layer) {
-                            RenderSystem.enableBlend();
-                            RenderSystem.blendFunc(GlStateManager.SourceFactor.ONE, GlStateManager.DestFactor.ONE);
-                        }
-                    });
-
-            sceneWidget.getRenderer().setAfterWorldRender(this::renderOverlays);
-
-            var playerRotation = gui.entityPlayer.getRotationVector();
-            sceneWidget.setCameraYawAndPitch(playerRotation.x, playerRotation.y - 90);
-        }
-        sceneWidget.setBackground(ColorPattern.BLACK.rectTexture());
-        return sceneWidget;
-    }
-
-    private void renderOverlays(WorldSceneRenderer renderer) {
-        sceneWidget.renderBlockOverLay(renderer);
-
-        for (Direction face : GTUtil.DIRECTIONS) {
-            for (IDirectionalConfigHandler configHandler : configHandlers) {
-                configHandler.renderOverlay(sceneWidget, new BlockPosFace(machine.getBlockPos(), face));
-            }
-        }
-    }
-
-    private void addConfigWidgets(SceneWidget sceneWidget) {
-        int yOffsetLeft = 0, yOffsetRight = 0;
-
-        for (IDirectionalConfigHandler configHandler : configHandlers) {
-            Widget widget = configHandler.getSideSelectorWidget(sceneWidget, machineUI);
-
-            if (widget == null)
-                continue;
-
-            final Size widgetSize = widget.getSize();
-            switch (configHandler.getScreenSide()) {
-                case LEFT -> {
-                    widget.setSelfPosition(new Position(6, height - 6 - widgetSize.height - yOffsetLeft));
-                    yOffsetLeft += widgetSize.height + 3;
-                }
-                case RIGHT -> {
-                    widget.setSelfPosition(
-                            new Position(width - widgetSize.width - 6, height - 6 - widgetSize.height - yOffsetRight));
-                    yOffsetRight += widgetSize.height + 3;
-                }
-            }
-
-            this.addWidget(widget);
-        }
-    }
-
-    protected void onSideSelected(BlockPos pos, Direction side) {
-        if (!pos.equals(machine.getBlockPos()))
-            return;
-
-        if (this.selectedSide == side)
-            return; // No need to do anything if the same side is already selected
-
-        this.selectedSide = side;
-
-        for (IDirectionalConfigHandler configWidget : this.configHandlers) {
-            configWidget.onSideSelected(pos, side);
-        }
-    }
-
-    @Override
-    @OnlyIn(Dist.CLIENT)
-    public boolean mouseClicked(double mouseX, double mouseY, int button) {
-        var lastSide = this.selectedSide;
-
-        var result = super.mouseClicked(mouseX, mouseY, button);
-
-        if (isMouseOverElement(mouseX, mouseY) && this.selectedSide == lastSide && this.selectedSide != null) {
-            var hover = sceneWidget.getHoverPosFace();
-
-            if (hover != null && hover.pos.equals(machine.getBlockPos()) && hover.facing == this.selectedSide) {
-                var cd = new ClickData();
-                writeClientAction(MOUSE_CLICK_CLIENT_ACTION_ID, buf -> {
-                    cd.writeToBuf(buf);
-                    buf.writeByte(this.selectedSide.ordinal());
-                });
-            }
-        }
-
-        return result;
-    }
-
-    @Override
-    public void handleClientAction(int id, FriendlyByteBuf buf) {
-        if (id != MOUSE_CLICK_CLIENT_ACTION_ID) {
-            super.handleClientAction(id, buf);
-            return;
-        }
-
-        var clickData = ClickData.readFromBuf(buf);
-        var side = GTUtil.DIRECTIONS[buf.readByte()];
-
-        for (IDirectionalConfigHandler configHandler : configHandlers) {
-            configHandler.handleClick(clickData, side);
-        }
-    }
-}
diff --git a/src/main/java/com/gregtechceu/gtceu/api/gui/widget/directional/IDirectionalConfigHandler.java b/src/main/java/com/gregtechceu/gtceu/api/gui/widget/directional/IDirectionalConfigHandler.java
deleted file mode 100644
index 024b4465873..00000000000
--- a/src/main/java/com/gregtechceu/gtceu/api/gui/widget/directional/IDirectionalConfigHandler.java
+++ /dev/null
@@ -1,50 +0,0 @@
-package com.gregtechceu.gtceu.api.gui.widget.directional;
-
-import com.gregtechceu.gtceu.api.gui.fancy.FancyMachineUIWidget;
-
-import com.lowdragmc.lowdraglib.gui.util.ClickData;
-import com.lowdragmc.lowdraglib.gui.widget.SceneWidget;
-import com.lowdragmc.lowdraglib.gui.widget.Widget;
-import com.lowdragmc.lowdraglib.gui.widget.WidgetGroup;
-import com.lowdragmc.lowdraglib.utils.BlockPosFace;
-
-import net.minecraft.core.BlockPos;
-import net.minecraft.core.Direction;
-import net.minecraftforge.api.distmarker.Dist;
-import net.minecraftforge.api.distmarker.OnlyIn;
-
-public interface IDirectionalConfigHandler {
-
-    /**
-     * Returns the buttons to display inside the side selector
-     */
-    Widget getSideSelectorWidget(SceneWidget scene, FancyMachineUIWidget machineUI);
-
-    /**
-     * Called whenever a side is selected in the side selector GUI
-     */
-    void onSideSelected(BlockPos pos, Direction side);
-
-    /**
-     * Determines which side of the screen the UI element should be placed on.
-     */
-    ScreenSide getScreenSide();
-
-    enum ScreenSide {
-        LEFT,
-        RIGHT,
-    }
-
-    default void handleClick(ClickData cd, Direction direction) {
-        // Do nothing by default
-    }
-
-    @OnlyIn(Dist.CLIENT)
-    default void renderOverlay(SceneWidget sceneWidget, BlockPosFace blockPosFace) {
-        // Do nothing by default
-    }
-
-    default void addAdditionalUIElements(WidgetGroup parent) {
-        // Do nothing by default
-    }
-}
diff --git a/src/main/java/com/gregtechceu/gtceu/api/gui/widget/directional/handlers/AutoOutputFluidConfigHandler.java b/src/main/java/com/gregtechceu/gtceu/api/gui/widget/directional/handlers/AutoOutputFluidConfigHandler.java
deleted file mode 100644
index d291f19880c..00000000000
--- a/src/main/java/com/gregtechceu/gtceu/api/gui/widget/directional/handlers/AutoOutputFluidConfigHandler.java
+++ /dev/null
@@ -1,155 +0,0 @@
-package com.gregtechceu.gtceu.api.gui.widget.directional.handlers;
-
-import com.gregtechceu.gtceu.api.gui.GuiTextures;
-import com.gregtechceu.gtceu.api.gui.fancy.FancyMachineUIWidget;
-import com.gregtechceu.gtceu.api.gui.widget.ToggleButtonWidget;
-import com.gregtechceu.gtceu.api.gui.widget.directional.IDirectionalConfigHandler;
-import com.gregtechceu.gtceu.common.machine.trait.AutoOutputTrait;
-import com.gregtechceu.gtceu.data.lang.LangHandler;
-
-import com.lowdragmc.lowdraglib.gui.texture.GuiTextureGroup;
-import com.lowdragmc.lowdraglib.gui.texture.IGuiTexture;
-import com.lowdragmc.lowdraglib.gui.util.ClickData;
-import com.lowdragmc.lowdraglib.gui.widget.*;
-import com.lowdragmc.lowdraglib.utils.BlockPosFace;
-import com.lowdragmc.lowdraglib.utils.Position;
-
-import net.minecraft.MethodsReturnNonnullByDefault;
-import net.minecraft.core.BlockPos;
-import net.minecraft.core.Direction;
-import net.minecraft.network.chat.Component;
-import net.minecraftforge.api.distmarker.Dist;
-import net.minecraftforge.api.distmarker.OnlyIn;
-
-import com.mojang.blaze3d.vertex.PoseStack;
-
-import javax.annotation.ParametersAreNonnullByDefault;
-
-@MethodsReturnNonnullByDefault
-@ParametersAreNonnullByDefault
-public class AutoOutputFluidConfigHandler implements IDirectionalConfigHandler {
-
-    private static final IGuiTexture TEXTURE_OFF = new GuiTextureGroup(
-            GuiTextures.VANILLA_BUTTON,
-            GuiTextures.IO_CONFIG_FLUID_MODES_BUTTON.getSubTexture(0, 0, 1, 1 / 3f));
-    private static final IGuiTexture TEXTURE_OUTPUT = new GuiTextureGroup(
-            GuiTextures.VANILLA_BUTTON,
-            GuiTextures.IO_CONFIG_FLUID_MODES_BUTTON.getSubTexture(0, 1 / 3f, 1, 1 / 3f));
-    private static final IGuiTexture TEXTURE_AUTO = new GuiTextureGroup(
-            GuiTextures.VANILLA_BUTTON,
-            GuiTextures.IO_CONFIG_FLUID_MODES_BUTTON.getSubTexture(0, 2 / 3f, 1, 1 / 3f));
-
-    private final AutoOutputTrait trait;
-    private Direction side;
-    private ButtonWidget ioModeButton;
-
-    public AutoOutputFluidConfigHandler(AutoOutputTrait trait) {
-        this.trait = trait;
-    }
-
-    @Override
-    public Widget getSideSelectorWidget(SceneWidget scene, FancyMachineUIWidget machineUI) {
-        WidgetGroup group = new WidgetGroup(0, 0, (18 * 2) + 1, 18);
-
-        group.addWidget(ioModeButton = new ButtonWidget(0, 0, 18, 18, this::onIOModePressed) {
-
-            @Override
-            public void updateScreen() {
-                super.updateScreen();
-                if (side == null) {
-                    setButtonTexture(TEXTURE_OFF);
-                    setHoverTooltips(LangHandler.getMultiLang("gtceu.gui.fluid_auto_output.unselected")
-                            .toArray(Component[]::new));
-                } else if (trait.getFluidOutputDirection() == side) {
-                    if (trait.isAutoOutputFluids()) {
-                        setButtonTexture(TEXTURE_AUTO);
-                        setHoverTooltips("gtceu.gui.fluid_auto_output.enabled");
-                    } else {
-                        setButtonTexture(TEXTURE_OUTPUT);
-                        setHoverTooltips("gtceu.gui.fluid_auto_output.disabled");
-                    }
-                } else {
-                    setButtonTexture(TEXTURE_OFF);
-                    setHoverTooltips(LangHandler.getMultiLang("gtceu.gui.fluid_auto_output.other_direction")
-                            .toArray(Component[]::new));
-                }
-            }
-        });
-
-        group.addWidget(new ToggleButtonWidget(
-                19, 0, 18, 18, GuiTextures.BUTTON_FLUID_OUTPUT,
-                trait::allowsFluidInputFromOutputSide, trait::setAllowFluidInputFromOutputSide)
-                .setShouldUseBaseBackground().setTooltipText("gtceu.gui.fluid_auto_output.allow_input"));
-
-        return group;
-    }
-
-    private void onIOModePressed(ClickData cd) {
-        if (this.side == null)
-            return;
-
-        if (trait.getFluidOutputDirection() == this.side) {
-            trait.setAllowAutoOutputFluids(!trait.isAutoOutputFluids());
-        } else {
-            trait.setAllowAutoOutputFluids(false);
-            trait.setFluidOutputDirection(this.side);
-        }
-    }
-
-    @Override
-    public void onSideSelected(BlockPos pos, Direction side) {
-        this.side = side;
-    }
-
-    @Override
-    public ScreenSide getScreenSide() {
-        return ScreenSide.LEFT;
-    }
-
-    @Override
-    public void handleClick(ClickData cd, Direction direction) {
-        if (!canHandleClick(cd) || !trait.supportsAutoOutputFluids())
-            return;
-
-        if (trait.getFluidOutputDirection() != side) {
-            trait.setFluidOutputDirection(side);
-            trait.setAllowAutoOutputFluids(false);
-        } else {
-            trait.setAllowAutoOutputFluids(!trait.isAutoOutputFluids());
-        }
-    }
-
-    @SuppressWarnings("RedundantIfStatement") // Cleaner code this way
-    private boolean canHandleClick(ClickData cd) {
-        if (cd.button == 1)
-            return true;
-
-        return false;
-    }
-
-    @Override
-    @OnlyIn(Dist.CLIENT)
-    public void renderOverlay(SceneWidget sceneWidget, BlockPosFace blockPosFace) {
-        if (trait.getFluidOutputDirection() != blockPosFace.facing)
-            return;
-
-        sceneWidget.drawFacingBorder(new PoseStack(), blockPosFace,
-                trait.isAutoOutputFluids() ? 0xff00b4ff : 0x8f00b4ff, 2);
-    }
-
-    @Override
-    public void addAdditionalUIElements(WidgetGroup parent) {
-        LabelWidget text = new LabelWidget(4, 4, "gtceu.gui.auto_output.name") {
-
-            @Override
-            public boolean isVisible() {
-                return trait.isAutoOutputFluids() && trait.getFluidOutputDirection() != null;
-            }
-        };
-
-        text.setSelfPosition(new Position(parent.getSize().width - 4 - text.getSize().width, 4));
-
-        text.setTextColor(0xff00b4ff).setDropShadow(false);
-        parent.addWidget(text);
-    }
-}
diff --git a/src/main/java/com/gregtechceu/gtceu/api/gui/widget/directional/handlers/AutoOutputItemConfigHandler.java b/src/main/java/com/gregtechceu/gtceu/api/gui/widget/directional/handlers/AutoOutputItemConfigHandler.java
deleted file mode 100644
index b2e9bdc19b2..00000000000
--- a/src/main/java/com/gregtechceu/gtceu/api/gui/widget/directional/handlers/AutoOutputItemConfigHandler.java
+++ /dev/null
@@ -1,153 +0,0 @@
-package com.gregtechceu.gtceu.api.gui.widget.directional.handlers;
-
-import com.gregtechceu.gtceu.api.gui.GuiTextures;
-import com.gregtechceu.gtceu.api.gui.fancy.FancyMachineUIWidget;
-import com.gregtechceu.gtceu.api.gui.widget.ToggleButtonWidget;
-import com.gregtechceu.gtceu.api.gui.widget.directional.IDirectionalConfigHandler;
-import com.gregtechceu.gtceu.common.machine.trait.AutoOutputTrait;
-import com.gregtechceu.gtceu.data.lang.LangHandler;
-
-import com.lowdragmc.lowdraglib.gui.texture.GuiTextureGroup;
-import com.lowdragmc.lowdraglib.gui.texture.IGuiTexture;
-import com.lowdragmc.lowdraglib.gui.util.ClickData;
-import com.lowdragmc.lowdraglib.gui.widget.*;
-import com.lowdragmc.lowdraglib.utils.BlockPosFace;
-
-import net.minecraft.MethodsReturnNonnullByDefault;
-import net.minecraft.core.BlockPos;
-import net.minecraft.core.Direction;
-import net.minecraft.network.chat.Component;
-import net.minecraftforge.api.distmarker.Dist;
-import net.minecraftforge.api.distmarker.OnlyIn;
-
-import com.mojang.blaze3d.vertex.PoseStack;
-
-import javax.annotation.ParametersAreNonnullByDefault;
-
-@MethodsReturnNonnullByDefault
-@ParametersAreNonnullByDefault
-public class AutoOutputItemConfigHandler implements IDirectionalConfigHandler {
-
-    private static final IGuiTexture TEXTURE_OFF = new GuiTextureGroup(
-            GuiTextures.VANILLA_BUTTON,
-            GuiTextures.IO_CONFIG_ITEM_MODES_BUTTON.getSubTexture(0, 0, 1, 1 / 3f));
-    private static final IGuiTexture TEXTURE_OUTPUT = new GuiTextureGroup(
-            GuiTextures.VANILLA_BUTTON,
-            GuiTextures.IO_CONFIG_ITEM_MODES_BUTTON.getSubTexture(0, 1 / 3f, 1, 1 / 3f));
-    private static final IGuiTexture TEXTURE_AUTO = new GuiTextureGroup(
-            GuiTextures.VANILLA_BUTTON,
-            GuiTextures.IO_CONFIG_ITEM_MODES_BUTTON.getSubTexture(0, 2 / 3f, 1, 1 / 3f));
-
-    private final AutoOutputTrait trait;
-    private Direction side;
-    private ButtonWidget ioModeButton;
-
-    public AutoOutputItemConfigHandler(AutoOutputTrait trait) {
-        this.trait = trait;
-    }
-
-    @Override
-    public Widget getSideSelectorWidget(SceneWidget scene, FancyMachineUIWidget machineUI) {
-        WidgetGroup group = new WidgetGroup(0, 0, (18 * 2) + 1, 18);
-
-        group.addWidget(ioModeButton = new ButtonWidget(0, 0, 18, 18, this::onIOModePressed) {
-
-            @Override
-            public void updateScreen() {
-                super.updateScreen();
-
-                if (side == null) {
-                    setButtonTexture(TEXTURE_OFF);
-                    setHoverTooltips(LangHandler.getMultiLang("gtceu.gui.item_auto_output.unselected")
-                            .toArray(Component[]::new));
-                } else if (trait.getItemOutputDirection() == side) {
-                    if (trait.isAutoOutputItems()) {
-                        setButtonTexture(TEXTURE_AUTO);
-                        setHoverTooltips("gtceu.gui.item_auto_output.enabled");
-                    } else {
-                        setButtonTexture(TEXTURE_OUTPUT);
-                        setHoverTooltips("gtceu.gui.item_auto_output.disabled");
-                    }
-                } else {
-                    setButtonTexture(TEXTURE_OFF);
-                    setHoverTooltips(LangHandler.getMultiLang("gtceu.gui.item_auto_output.other_direction")
-                            .toArray(Component[]::new));
-                }
-            }
-        });
-
-        group.addWidget(new ToggleButtonWidget(
-                19, 0, 18, 18, GuiTextures.BUTTON_ITEM_OUTPUT,
-                trait::allowsItemInputFromOutputSide, trait::setAllowItemInputFromOutputSide)
-                .setShouldUseBaseBackground().setTooltipText("gtceu.gui.item_auto_output.allow_input"));
-
-        return group;
-    }
-
-    private void onIOModePressed(ClickData cd) {
-        if (this.side == null)
-            return;
-
-        if (trait.getItemOutputDirection() == this.side) {
-            trait.setAllowAutoOutputItems(!trait.isAutoOutputItems());
-        } else {
-            trait.setAllowAutoOutputItems(false);
-            trait.setItemOutputDirection(this.side);
-        }
-    }
-
-    @Override
-    public void onSideSelected(BlockPos pos, Direction side) {
-        this.side = side;
-    }
-
-    @Override
-    public ScreenSide getScreenSide() {
-        return ScreenSide.LEFT;
-    }
-
-    @Override
-    public void handleClick(ClickData cd, Direction direction) {
-        if (!canHandleClick(cd) || !trait.supportsAutoOutputItems())
-            return;
-
-        if (trait.getItemOutputDirection() != side) {
-            trait.setItemOutputDirection(side);
-            trait.setAllowAutoOutputItems(false);
-        } else {
-            trait.setAllowAutoOutputItems(!trait.isAutoOutputItems());
-        }
-    }
-
-    @SuppressWarnings("RedundantIfStatement") // Cleaner code this way
-    private boolean canHandleClick(ClickData cd) {
-        if (cd.button == 0)
-            return true;
-
-        return false;
-    }
-
-    @Override
-    @OnlyIn(Dist.CLIENT)
-    public void renderOverlay(SceneWidget sceneWidget, BlockPosFace blockPosFace) {
-        if (trait.getItemOutputDirection() != blockPosFace.facing)
-            return;
-
-        sceneWidget.drawFacingBorder(new PoseStack(), blockPosFace,
-                trait.isAutoOutputItems() ? 0xffff6e0f : 0x8fff6e0f, 1);
-    }
-
-    @Override
-    public void addAdditionalUIElements(WidgetGroup parent) {
-        LabelWidget text = new LabelWidget(4, 4, "gtceu.gui.auto_output.name") {
-
-            @Override
-            public boolean isVisible() {
-                return trait.isAutoOutputItems() && trait.getItemOutputDirection() != null;
-            }
-        };
-
-        text.setTextColor(0xffff6e0f).setDropShadow(false);
-        parent.addWidget(text);
-    }
-}
diff --git a/src/main/java/com/gregtechceu/gtceu/api/gui/widget/directional/handlers/CoverableConfigHandler.java b/src/main/java/com/gregtechceu/gtceu/api/gui/widget/directional/handlers/CoverableConfigHandler.java
deleted file mode 100644
index d20d95c0003..00000000000
--- a/src/main/java/com/gregtechceu/gtceu/api/gui/widget/directional/handlers/CoverableConfigHandler.java
+++ /dev/null
@@ -1,218 +0,0 @@
-package com.gregtechceu.gtceu.api.gui.widget.directional.handlers;
-
-import com.gregtechceu.gtceu.api.capability.ICoverable;
-import com.gregtechceu.gtceu.api.cover.CoverBehavior;
-import com.gregtechceu.gtceu.api.cover.IUICover;
-import com.gregtechceu.gtceu.api.gui.GuiTextures;
-import com.gregtechceu.gtceu.api.gui.fancy.ConfiguratorPanel;
-import com.gregtechceu.gtceu.api.gui.fancy.FancyMachineUIWidget;
-import com.gregtechceu.gtceu.api.gui.widget.CoverConfigurator;
-import com.gregtechceu.gtceu.api.gui.widget.PredicatedButtonWidget;
-import com.gregtechceu.gtceu.api.gui.widget.SlotWidget;
-import com.gregtechceu.gtceu.api.gui.widget.directional.IDirectionalConfigHandler;
-import com.gregtechceu.gtceu.api.item.IComponentItem;
-import com.gregtechceu.gtceu.api.item.component.IItemComponent;
-import com.gregtechceu.gtceu.api.transfer.item.CustomItemStackHandler;
-import com.gregtechceu.gtceu.common.item.behavior.CoverPlaceBehavior;
-
-import com.lowdragmc.lowdraglib.gui.texture.GuiTextureGroup;
-import com.lowdragmc.lowdraglib.gui.texture.IGuiTexture;
-import com.lowdragmc.lowdraglib.gui.util.ClickData;
-import com.lowdragmc.lowdraglib.gui.widget.SceneWidget;
-import com.lowdragmc.lowdraglib.gui.widget.Widget;
-import com.lowdragmc.lowdraglib.gui.widget.WidgetGroup;
-import com.lowdragmc.lowdraglib.utils.Position;
-import com.lowdragmc.lowdraglib.utils.Size;
-
-import net.minecraft.MethodsReturnNonnullByDefault;
-import net.minecraft.core.BlockPos;
-import net.minecraft.core.Direction;
-import net.minecraft.network.chat.Component;
-import net.minecraft.server.level.ServerPlayer;
-import net.minecraft.world.item.ItemStack;
-
-import javax.annotation.ParametersAreNonnullByDefault;
-
-@MethodsReturnNonnullByDefault
-@ParametersAreNonnullByDefault
-public class CoverableConfigHandler implements IDirectionalConfigHandler {
-
-    private static final IGuiTexture CONFIG_BTN_TEXTURE = new GuiTextureGroup(GuiTextures.IO_CONFIG_COVER_SETTINGS);
-
-    private final ICoverable machine;
-    private CustomItemStackHandler handler;
-    private Direction side;
-
-    private ConfiguratorPanel panel;
-    private ConfiguratorPanel.FloatingTab coverConfigurator;
-
-    private SlotWidget slotWidget;
-    private CoverBehavior coverBehavior;
-
-    public CoverableConfigHandler(ICoverable machine) {
-        this.machine = machine;
-        this.handler = createItemStackHandler();
-    }
-
-    private CustomItemStackHandler createItemStackHandler() {
-        var handler = new CustomItemStackHandler(1) {
-
-            @Override
-            public int getSlotLimit(int slot) {
-                return 1;
-            }
-        };
-
-        handler.setFilter(itemStack -> {
-            if (itemStack.isEmpty()) return true;
-            if (this.side == null) return false;
-            return CoverPlaceBehavior.isCoverBehaviorItem(itemStack, () -> false,
-                    coverDef -> ICoverable.canPlaceCover(coverDef, this.machine));
-        });
-
-        return handler;
-    }
-
-    @Override
-    public Widget getSideSelectorWidget(SceneWidget scene, FancyMachineUIWidget machineUI) {
-        WidgetGroup group = new WidgetGroup(0, 0, (18 * 2) + 1, 18);
-        this.panel = machineUI.getConfiguratorPanel();
-
-        group.addWidget(slotWidget = new SlotWidget(handler, 0, 19, 0) {
-
-            @Override
-            public boolean canPutStack(ItemStack stack) {
-                return super.canPutStack(stack) && CoverPlaceBehavior.isCoverBehaviorItem(stack, () -> false,
-                        def -> def.createCoverBehavior(machine, side).canAttach());
-            }
-        }
-                .setChangeListener(this::coverItemChanged)
-                .setBackgroundTexture(new GuiTextureGroup(GuiTextures.SLOT, GuiTextures.IO_CONFIG_COVER_SLOT_OVERLAY)));
-        group.addWidget(new PredicatedButtonWidget(0, 0, 18, 18, CONFIG_BTN_TEXTURE, this::toggleConfigTab,
-                () -> side != null && coverBehavior != null && machine.getCoverAtSide(side) instanceof IUICover));
-
-        checkCoverBehaviour();
-
-        return group;
-    }
-
-    // FIXME: This gets called twice in a single tick, causing two covers to exist simultaneously
-    private void coverItemChanged() {
-        closeConfigTab();
-
-        if (!(panel.getGui().entityPlayer instanceof ServerPlayer serverPlayer) || side == null)
-            return;
-
-        var item = handler.getStackInSlot(0);
-        if (machine.getCoverAtSide(side) != null) {
-            machine.removeCover(false, side, serverPlayer);
-        }
-
-        if (!item.isEmpty() && machine.getCoverAtSide(side) == null) {
-            if (item.getItem() instanceof IComponentItem componentItem) {
-                for (IItemComponent component : componentItem.getComponents()) {
-                    if (component instanceof CoverPlaceBehavior placeBehavior) {
-                        machine.placeCoverOnSide(side, item, placeBehavior.coverDefinition(), serverPlayer);
-                        break;
-                    }
-                }
-            }
-        }
-
-        checkCoverBehaviour();
-    }
-
-    @Override
-    public void onSideSelected(BlockPos pos, Direction side) {
-        this.side = side;
-        checkCoverBehaviour();
-        closeConfigTab();
-    }
-
-    private void updateWidgetVisibility() {
-        var sideSelected = this.side != null;
-        slotWidget.setVisible(sideSelected);
-        slotWidget.setActive(sideSelected);
-    }
-
-    public void checkCoverBehaviour() {
-        if (side == null)
-            return;
-
-        var coverBehaviour = machine.getCoverAtSide(side);
-        if (coverBehaviour != this.coverBehavior) {
-            this.coverBehavior = coverBehaviour;
-
-            var attachItem = coverBehaviour == null ? ItemStack.EMPTY : coverBehaviour.getAttachItem();
-            handler.setStackInSlot(0, attachItem);
-            handler.onContentsChanged(0);
-        }
-
-        updateWidgetVisibility();
-    }
-
-    private void toggleConfigTab(ClickData cd) {
-        if (this.coverConfigurator == null)
-            openConfigTab();
-        else
-            closeConfigTab();
-    }
-
-    private void openConfigTab() {
-        CoverConfigurator configurator = new CoverConfigurator(this.machine, this.side, this.coverBehavior) {
-
-            @Override
-            public Component getTitle() {
-                // Uses the widget's own title
-                return Component.empty();
-            }
-
-            @Override
-            public IGuiTexture getIcon() {
-                return GuiTextures.CLOSE_ICON;
-            }
-
-            @Override
-            public Widget createConfigurator() {
-                WidgetGroup group = new WidgetGroup(new Position(0, 0));
-
-                if (side == null || !(coverable.getCoverAtSide(side) instanceof IUICover iuiCover))
-                    return group;
-
-                Widget coverConfigurator = iuiCover.createUIWidget();
-                coverConfigurator.addSelfPosition(-1, -20);
-
-                group.addWidget(coverConfigurator);
-                group.setSize(new Size(
-                        Math.max(120, coverConfigurator.getSize().width),
-                        Math.max(80, coverConfigurator.getSize().height - 20)));
-
-                return group;
-            }
-        };
-
-        this.coverConfigurator = this.panel.createFloatingTab(configurator);
-        this.coverConfigurator.setGui(this.panel.getGui());
-        this.panel.addWidget(this.coverConfigurator);
-        this.panel.expandTab(this.coverConfigurator);
-
-        coverConfigurator.onClose(() -> {
-            if (coverConfigurator != null) {
-                this.panel.removeWidget(this.coverConfigurator);
-            }
-
-            this.coverConfigurator = null;
-        });
-    }
-
-    private void closeConfigTab() {
-        if (this.coverConfigurator != null) {
-            this.panel.collapseTab();
-        }
-    }
-
-    @Override
-    public ScreenSide getScreenSide() {
-        return ScreenSide.RIGHT;
-    }
-}
diff --git a/src/main/java/com/gregtechceu/gtceu/api/item/ComponentItem.java b/src/main/java/com/gregtechceu/gtceu/api/item/ComponentItem.java
index b45213e753e..682e2965d35 100644
--- a/src/main/java/com/gregtechceu/gtceu/api/item/ComponentItem.java
+++ b/src/main/java/com/gregtechceu/gtceu/api/item/ComponentItem.java
@@ -1,12 +1,12 @@
 package com.gregtechceu.gtceu.api.item;
 
+import com.gregtechceu.gtceu.GTCEu;
 import com.gregtechceu.gtceu.api.capability.GTCapabilityHelper;
 import com.gregtechceu.gtceu.api.capability.IElectricItem;
 import com.gregtechceu.gtceu.api.item.capability.ElectricItem;
 import com.gregtechceu.gtceu.api.item.component.*;
+import com.gregtechceu.gtceu.api.mui.IItemUIHolder;
 
-import com.lowdragmc.lowdraglib.client.renderer.IItemRendererProvider;
-import com.lowdragmc.lowdraglib.client.renderer.IRenderer;
 import com.lowdragmc.lowdraglib.gui.factory.HeldItemUIFactory;
 import com.lowdragmc.lowdraglib.gui.modular.ModularUI;
 
@@ -36,6 +36,10 @@
 import net.minecraft.world.level.Level;
 import net.minecraft.world.level.LevelReader;
 
+import brachy.modularui.factory.PlayerInventoryGuiData;
+import brachy.modularui.screen.ModularPanel;
+import brachy.modularui.screen.UISettings;
+import brachy.modularui.value.sync.PanelSyncManager;
 import com.google.common.collect.Multimap;
 import lombok.Getter;
 import org.jetbrains.annotations.Nullable;
@@ -49,7 +53,8 @@
 @ParametersAreNonnullByDefault
 @MethodsReturnNonnullByDefault
 public class ComponentItem extends Item
-                           implements HeldItemUIFactory.IHeldItemUIHolder, IItemRendererProvider, IComponentItem {
+                           implements HeldItemUIFactory.IHeldItemUIHolder, IComponentItem,
+                           IItemUIHolder {
 
     protected int burnTime = -1;
 
@@ -305,17 +310,6 @@ public ModularUI createUI(Player entityPlayer, HeldItemUIFactory.HeldItemHolder
         return null;
     }
 
-    @Nullable
-    @Override
-    public IRenderer getRenderer(ItemStack stack) {
-        for (IItemComponent component : components) {
-            if (component instanceof ICustomRenderer customRenderer) {
-                return customRenderer.getRenderer();
-            }
-        }
-        return null;
-    }
-
     @Override
     public void inventoryTick(ItemStack stack, Level level, Entity entity, int slotId, boolean isSelected) {
         for (IItemComponent component : components) {
@@ -443,4 +437,24 @@ public ItemStack getInfiniteChargedStack() {
         electricItem.setInfiniteCharge(true);
         return itemStack;
     }
+
+    @Override
+    public @Nullable ModularPanel<?> buildUI(PlayerInventoryGuiData<?> data, PanelSyncManager syncManager,
+                                             UISettings settings) {
+        for (IItemComponent component : getComponents()) {
+            if (component instanceof IItemUIHolder uiHolder) {
+                return uiHolder.buildUI(data, syncManager, settings);
+            }
+        }
+        GTCEu.LOGGER.error("Tried to get UI of {} item when it does not have one!", data.getUsedItemStack());
+        return null;
+    }
+
+    @Override
+    public boolean shouldOpenUI() {
+        for (IItemComponent component : getComponents()) {
+            if (component instanceof IItemUIHolder holder) return holder.shouldOpenUI();
+        }
+        return false;
+    }
 }
diff --git a/src/main/java/com/gregtechceu/gtceu/api/item/IGTTool.java b/src/main/java/com/gregtechceu/gtceu/api/item/IGTTool.java
index 57dff0347c9..731db0e7c44 100644
--- a/src/main/java/com/gregtechceu/gtceu/api/item/IGTTool.java
+++ b/src/main/java/com/gregtechceu/gtceu/api/item/IGTTool.java
@@ -19,15 +19,13 @@
 import com.gregtechceu.gtceu.api.item.tool.aoe.AoESymmetrical;
 import com.gregtechceu.gtceu.api.item.tool.behavior.IToolBehavior;
 import com.gregtechceu.gtceu.api.item.tool.behavior.IToolUIBehavior;
+import com.gregtechceu.gtceu.api.mui.GTGuiScreen;
 import com.gregtechceu.gtceu.api.sound.SoundEntry;
 import com.gregtechceu.gtceu.config.ConfigHolder;
 import com.gregtechceu.gtceu.data.recipe.VanillaRecipeHelper;
 import com.gregtechceu.gtceu.utils.FormattingUtil;
 import com.gregtechceu.gtceu.utils.GTUtil;
 
-import com.lowdragmc.lowdraglib.gui.factory.HeldItemUIFactory;
-import com.lowdragmc.lowdraglib.gui.modular.ModularUI;
-
 import net.minecraft.Util;
 import net.minecraft.client.color.item.ItemColor;
 import net.minecraft.core.BlockPos;
@@ -69,6 +67,12 @@
 import net.minecraftforge.common.extensions.IForgeItem;
 import net.minecraftforge.common.util.LazyOptional;
 
+import brachy.modularui.api.IUIHolder;
+import brachy.modularui.factory.PlayerInventoryGuiData;
+import brachy.modularui.screen.ModularPanel;
+import brachy.modularui.screen.ModularScreen;
+import brachy.modularui.screen.UISettings;
+import brachy.modularui.value.sync.PanelSyncManager;
 import com.google.common.collect.HashMultimap;
 import com.google.common.collect.Multimap;
 import it.unimi.dsi.fastutil.objects.Object2IntLinkedOpenHashMap;
@@ -83,7 +87,7 @@
 import static net.minecraft.world.item.Item.BASE_ATTACK_DAMAGE_UUID;
 import static net.minecraft.world.item.Item.BASE_ATTACK_SPEED_UUID;
 
-public interface IGTTool extends HeldItemUIFactory.IHeldItemUIHolder, ItemLike, IForgeItem {
+public interface IGTTool extends IUIHolder<PlayerInventoryGuiData<?>>, ItemLike, IForgeItem {
 
     GTToolType getToolType();
 
@@ -878,14 +882,21 @@ default void playSound(Player player) {
     }
 
     @Override
-    default ModularUI createUI(Player player, HeldItemUIFactory.HeldItemHolder holder) {
+    @OnlyIn(Dist.CLIENT)
+    default ModularScreen createScreen(PlayerInventoryGuiData<?> data, ModularPanel<?> mainPanel) {
+        return new GTGuiScreen(mainPanel);
+    }
+
+    @Override
+    default ModularPanel<?> buildUI(PlayerInventoryGuiData<?> data, PanelSyncManager syncManager, UISettings settings) {
         for (var behavior : getToolStats().getBehaviors()) {
-            if (!(behavior instanceof IToolUIBehavior uiBehavior) || !uiBehavior.openUI(player, holder.getHand())) {
+            if (!(behavior instanceof IToolUIBehavior uiBehavior) ||
+                    !uiBehavior.shouldOpenUI(data.getPlayer(), data.getPlayer().getUsedItemHand())) {
                 continue;
             }
-            return uiBehavior.createUI(player, holder);
+            return uiBehavior.buildUI(data, syncManager, settings);
         }
-        return new ModularUI(holder, player);
+        return null;
     }
 
     default Set<GTToolType> getToolClasses(ItemStack stack) {
diff --git a/src/main/java/com/gregtechceu/gtceu/api/item/MaterialBlockItem.java b/src/main/java/com/gregtechceu/gtceu/api/item/MaterialBlockItem.java
index 6c8addb7469..48f3e90e44c 100644
--- a/src/main/java/com/gregtechceu/gtceu/api/item/MaterialBlockItem.java
+++ b/src/main/java/com/gregtechceu/gtceu/api/item/MaterialBlockItem.java
@@ -7,10 +7,6 @@
 import com.gregtechceu.gtceu.api.data.chemical.material.properties.PropertyKey;
 import com.gregtechceu.gtceu.api.data.tag.TagPrefix;
 
-import com.lowdragmc.lowdraglib.client.renderer.IBlockRendererProvider;
-import com.lowdragmc.lowdraglib.client.renderer.IItemRendererProvider;
-import com.lowdragmc.lowdraglib.client.renderer.IRenderer;
-
 import net.minecraft.client.color.item.ItemColor;
 import net.minecraft.network.chat.Component;
 import net.minecraft.world.item.BlockItem;
@@ -23,7 +19,7 @@
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 
-public class MaterialBlockItem extends BlockItem implements IItemRendererProvider {
+public class MaterialBlockItem extends BlockItem {
 
     public final TagPrefix tagPrefix;
     public final Material material;
@@ -50,18 +46,8 @@ public static ItemColor tintColor(Material material) {
         return (itemStack, index) -> material.getLayerARGB(index);
     }
 
-    @Nullable
-    @Override
-    @OnlyIn(Dist.CLIENT)
-    public IRenderer getRenderer(ItemStack stack) {
-        if (getBlock() instanceof IBlockRendererProvider provider) {
-            return provider.getRenderer(getBlock().defaultBlockState());
-        }
-        return null;
-    }
-
     @Override
-    public String getDescriptionId() {
+    public @NotNull String getDescriptionId() {
         return getBlock().getDescriptionId();
     }
 
diff --git a/src/main/java/com/gregtechceu/gtceu/api/item/armor/ArmorComponentItem.java b/src/main/java/com/gregtechceu/gtceu/api/item/armor/ArmorComponentItem.java
index 5579e039564..17b18202137 100644
--- a/src/main/java/com/gregtechceu/gtceu/api/item/armor/ArmorComponentItem.java
+++ b/src/main/java/com/gregtechceu/gtceu/api/item/armor/ArmorComponentItem.java
@@ -24,6 +24,7 @@
 import com.google.common.base.Preconditions;
 import com.google.common.collect.*;
 import lombok.Getter;
+import lombok.experimental.Accessors;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.NotNullByDefault;
 import org.jetbrains.annotations.Nullable;
@@ -31,6 +32,7 @@
 import java.util.*;
 import java.util.function.Consumer;
 
+@Accessors(chain = true)
 @NotNullByDefault
 public class ArmorComponentItem extends ArmorItem implements IComponentItem {
 
@@ -162,11 +164,11 @@ public void fillItemCategory(CreativeModeTab category, NonNullList<ItemStack> it
     }
 
     @Override
-    public void appendHoverText(ItemStack stack, @Nullable Level level, List<Component> tooltipComponents,
+    public void appendHoverText(ItemStack stack, @Nullable Level level, List<Component> tooltips,
                                 TooltipFlag isAdvanced) {
         for (IItemComponent component : components) {
             if (component instanceof IAddInformation addInformation) {
-                addInformation.appendHoverText(stack, level, tooltipComponents, isAdvanced);
+                addInformation.appendHoverText(stack, level, tooltips, isAdvanced);
             }
         }
     }
diff --git a/src/main/java/com/gregtechceu/gtceu/api/item/armor/ArmorLogicSuite.java b/src/main/java/com/gregtechceu/gtceu/api/item/armor/ArmorLogicSuite.java
index 8fdf231f41d..794e90cfae0 100644
--- a/src/main/java/com/gregtechceu/gtceu/api/item/armor/ArmorLogicSuite.java
+++ b/src/main/java/com/gregtechceu/gtceu/api/item/armor/ArmorLogicSuite.java
@@ -87,7 +87,7 @@ public InteractionResultHolder<ItemStack> use(Item item, Level level, Player pla
             @Override
             public void appendHoverText(ItemStack stack, @Nullable Level level, List<Component> tooltipComponents,
                                         TooltipFlag isAdvanced) {
-                addInfo(stack, tooltipComponents);
+                // addInfo(stack, tooltipComponents);
             }
         });
     }
diff --git a/src/main/java/com/gregtechceu/gtceu/api/item/armor/IArmorLogic.java b/src/main/java/com/gregtechceu/gtceu/api/item/armor/IArmorLogic.java
index 3ae5f075c83..181b33d5d38 100644
--- a/src/main/java/com/gregtechceu/gtceu/api/item/armor/IArmorLogic.java
+++ b/src/main/java/com/gregtechceu/gtceu/api/item/armor/IArmorLogic.java
@@ -1,5 +1,9 @@
 package com.gregtechceu.gtceu.api.item.armor;
 
+import com.gregtechceu.gtceu.api.capability.GTCapabilityHelper;
+import com.gregtechceu.gtceu.api.item.module.AppliedItemModule;
+import com.gregtechceu.gtceu.api.item.module.IModularItem;
+
 import net.minecraft.Util;
 import net.minecraft.client.model.HumanoidModel;
 import net.minecraft.resources.ResourceLocation;
@@ -50,7 +54,13 @@ default boolean canBreakWithDamage(ItemStack stack) {
         return false;
     }
 
-    default boolean isPPE() {
+    default boolean isPPE(ItemStack stack) {
+        IModularItem modularItem = GTCapabilityHelper.getModularItem(stack);
+        if (modularItem != null) {
+            for (AppliedItemModule module : modularItem.getAppliedModules()) {
+                if (module.isPPE()) return true;
+            }
+        }
         return false;
     }
 
diff --git a/src/main/java/com/gregtechceu/gtceu/api/item/armor/ModularArmorItem.java b/src/main/java/com/gregtechceu/gtceu/api/item/armor/ModularArmorItem.java
new file mode 100644
index 00000000000..f63e6da54b1
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/api/item/armor/ModularArmorItem.java
@@ -0,0 +1,286 @@
+package com.gregtechceu.gtceu.api.item.armor;
+
+import com.gregtechceu.gtceu.api.item.IComponentItem;
+import com.gregtechceu.gtceu.api.item.component.*;
+import com.gregtechceu.gtceu.api.item.component.forge.IComponentCapability;
+
+import net.minecraft.MethodsReturnNonnullByDefault;
+import net.minecraft.client.model.HumanoidModel;
+import net.minecraft.core.NonNullList;
+import net.minecraft.network.chat.Component;
+import net.minecraft.world.InteractionHand;
+import net.minecraft.world.InteractionResult;
+import net.minecraft.world.InteractionResultHolder;
+import net.minecraft.world.entity.Entity;
+import net.minecraft.world.entity.EquipmentSlot;
+import net.minecraft.world.entity.LivingEntity;
+import net.minecraft.world.entity.player.Player;
+import net.minecraft.world.item.*;
+import net.minecraft.world.item.context.UseOnContext;
+import net.minecraft.world.level.Level;
+import net.minecraftforge.client.extensions.common.IClientItemExtensions;
+import net.minecraftforge.common.capabilities.Capability;
+import net.minecraftforge.common.util.LazyOptional;
+
+import lombok.Getter;
+import lombok.experimental.Accessors;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+import java.util.function.Consumer;
+
+import javax.annotation.ParametersAreNonnullByDefault;
+
+@ParametersAreNonnullByDefault
+@MethodsReturnNonnullByDefault
+@Accessors(chain = true)
+public class ModularArmorItem extends ArmorItem implements IComponentItem {
+
+    @Getter
+    protected List<IItemComponent> components = new ArrayList<>();
+
+    public ModularArmorItem(ArmorMaterial material, Type type, Properties properties) {
+        super(material, type, properties);
+    }
+
+    @Override
+    public void attachComponents(IItemComponent... components) {
+        this.components.addAll(Arrays.asList(components));
+        for (IItemComponent component : components) {
+            component.onAttached(this);
+        }
+    }
+
+    @Override
+    public int getMaxDamage(ItemStack stack) {
+        return super.getMaxDamage(stack);
+    }
+
+    @Override
+    public boolean isValidRepairItem(ItemStack stack, ItemStack repairCandidate) {
+        return false;
+    }
+
+    @Override
+    public boolean isEnchantable(ItemStack stack) {
+        return true;
+    }
+
+    @Override
+    public int getEnchantmentValue() {
+        return 50;
+    }
+
+    @Override
+    public void initializeClient(Consumer<IClientItemExtensions> consumer) {
+        consumer.accept(new IClientItemExtensions() {
+
+            @Override
+            public @NotNull HumanoidModel<?> getHumanoidArmorModel(LivingEntity livingEntity, ItemStack itemStack,
+                                                                   EquipmentSlot equipmentSlot,
+                                                                   HumanoidModel<?> original) {
+                // TODO modifiable armor model
+                // return armorLogic.getArmorModel(livingEntity, itemStack, equipmentSlot, original);
+                return original;
+            }
+        });
+    }
+
+    @Nullable
+    @Override
+    public String getArmorTexture(ItemStack stack, Entity entity, EquipmentSlot slot, String type) {
+        // TODO add custom texture logic (or not? do we need it?)
+        // return armorLogic.getArmorTexture(stack, entity, slot, type).toString();
+        return null;
+    }
+
+    ///////////////////////////////////////////
+    ///// ALL component item things ///////
+    ///////////////////////////////////////////
+
+    public void fillItemCategory(CreativeModeTab category, NonNullList<ItemStack> items) {
+        boolean found = false;
+        for (IItemComponent component : components) {
+            if (component instanceof ISubItemHandler subItemHandler) {
+                subItemHandler.fillItemCategory(this, category, items);
+                found = true;
+            }
+        }
+        if (found) return;
+        items.add(new ItemStack(this));
+    }
+
+    @Override
+    public void appendHoverText(ItemStack stack, @Nullable Level level, List<Component> tooltips,
+                                TooltipFlag isAdvanced) {
+        for (IItemComponent component : components) {
+            if (component instanceof IAddInformation addInformation) {
+                addInformation.appendHoverText(stack, level, tooltips, isAdvanced);
+            }
+        }
+    }
+
+    @Override
+    public boolean isBarVisible(ItemStack stack) {
+        for (IItemComponent component : components) {
+            if (component instanceof IDurabilityBar durabilityBar) {
+                return durabilityBar.isBarVisible(stack);
+            }
+        }
+        return super.isBarVisible(stack);
+    }
+
+    @Override
+    public int getBarWidth(ItemStack stack) {
+        for (IItemComponent component : components) {
+            if (component instanceof IDurabilityBar durabilityBar) {
+                return durabilityBar.getBarWidth(stack);
+            }
+        }
+        return super.getBarWidth(stack);
+    }
+
+    @Override
+    public int getBarColor(ItemStack stack) {
+        for (IItemComponent component : components) {
+            if (component instanceof IDurabilityBar durabilityBar) {
+                return durabilityBar.getBarColor(stack);
+            }
+        }
+        return super.getBarColor(stack);
+    }
+
+    @Override
+    public InteractionResult useOn(UseOnContext context) {
+        for (IItemComponent component : components) {
+            if (component instanceof IInteractionItem interactionItem) {
+                var result = interactionItem.useOn(context);
+                if (result != InteractionResult.PASS) {
+                    return result;
+                }
+            }
+        }
+        return super.useOn(context);
+    }
+
+    @Override
+    public InteractionResultHolder<ItemStack> use(Level level, Player player, InteractionHand usedHand) {
+        for (IItemComponent component : components) {
+            if (component instanceof IInteractionItem interactionItem) {
+                var result = interactionItem.use(this, level, player, usedHand);
+                if (result.getResult() != InteractionResult.PASS) {
+                    return result;
+                }
+            }
+        }
+        return super.use(level, player, usedHand);
+    }
+
+    @Override
+    public ItemStack finishUsingItem(ItemStack stack, Level level, LivingEntity livingEntity) {
+        for (IItemComponent component : components) {
+            if (component instanceof IInteractionItem interactionItem) {
+                stack = interactionItem.finishUsingItem(stack, level, livingEntity);
+            }
+        }
+        return super.finishUsingItem(stack, level, livingEntity);
+    }
+
+    @Override
+    public InteractionResult onItemUseFirst(ItemStack itemStack, UseOnContext context) {
+        for (IItemComponent component : components) {
+            if (component instanceof IInteractionItem interactionItem) {
+                var result = interactionItem.onItemUseFirst(itemStack, context);
+                if (result != InteractionResult.PASS) {
+                    return result;
+                }
+            }
+        }
+        return InteractionResult.PASS;
+    }
+
+    @Override
+    public InteractionResult interactLivingEntity(ItemStack stack, Player player, LivingEntity interactionTarget,
+                                                  InteractionHand usedHand) {
+        for (IItemComponent component : components) {
+            if (component instanceof IInteractionItem interactionItem) {
+                var result = interactionItem.interactLivingEntity(stack, player, interactionTarget, usedHand);
+                if (result != InteractionResult.PASS) {
+                    return result;
+                }
+            }
+        }
+        return InteractionResult.PASS;
+    }
+
+    @Override
+    public Component getName(ItemStack stack) {
+        for (IItemComponent component : components) {
+            if (component instanceof ICustomDescriptionId customDescriptionId) {
+                Component name = customDescriptionId.getItemName(stack);
+                if (name != null) {
+                    return name;
+                }
+            }
+        }
+        return super.getName(stack);
+    }
+
+    @Override
+    public String getDescriptionId(ItemStack stack) {
+        for (IItemComponent component : components) {
+            if (component instanceof ICustomDescriptionId customDescriptionId) {
+                String langId = customDescriptionId.getItemDescriptionId(stack);
+                if (langId != null) {
+                    return langId;
+                }
+            }
+        }
+        return super.getDescriptionId(stack);
+    }
+
+    @Override
+    public void inventoryTick(ItemStack stack, Level level, Entity entity, int slotId, boolean isSelected) {
+        for (IItemComponent component : components) {
+            if (component instanceof IItemLifeCycle lifeCycle) {
+                lifeCycle.inventoryTick(stack, level, entity, slotId, isSelected);
+            }
+        }
+    }
+
+    @Override
+    public ItemStack getCraftingRemainingItem(ItemStack itemStack) {
+        for (IItemComponent component : components) {
+            if (component instanceof IRecipeRemainder recipeRemainder) {
+                return recipeRemainder.getRecipeRemained(itemStack);
+            }
+        }
+        return super.getCraftingRemainingItem(itemStack);
+    }
+
+    @Override
+    public boolean hasCraftingRemainingItem(ItemStack stack) {
+        for (IItemComponent component : components) {
+            if (component instanceof IRecipeRemainder recipeRemainder) {
+                return recipeRemainder.getRecipeRemained(stack) != ItemStack.EMPTY;
+            }
+        }
+        return super.hasCraftingRemainingItem(stack);
+    }
+
+    // TODO: this was an @Override before, figure out what it did
+    public <T> LazyOptional<T> getCapability(@NotNull final ItemStack itemStack, @NotNull final Capability<T> cap) {
+        for (IItemComponent component : components) {
+            if (component instanceof IComponentCapability componentCapability) {
+                var value = componentCapability.getCapability(itemStack, cap);
+                if (value.isPresent()) {
+                    return value;
+                }
+            }
+        }
+        return LazyOptional.empty();
+    }
+}
diff --git a/src/main/java/com/gregtechceu/gtceu/api/item/capability/ModularItemStack.java b/src/main/java/com/gregtechceu/gtceu/api/item/capability/ModularItemStack.java
new file mode 100644
index 00000000000..040efbc9f78
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/api/item/capability/ModularItemStack.java
@@ -0,0 +1,119 @@
+package com.gregtechceu.gtceu.api.item.capability;
+
+import com.gregtechceu.gtceu.api.item.module.AppliedItemModule;
+import com.gregtechceu.gtceu.api.item.module.IModularItem;
+import com.gregtechceu.gtceu.api.item.module.ItemModule;
+import com.gregtechceu.gtceu.api.item.module.ItemModuleSlot;
+
+import net.minecraft.nbt.CompoundTag;
+import net.minecraft.nbt.Tag;
+import net.minecraft.world.item.ItemStack;
+
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+import org.jetbrains.annotations.Unmodifiable;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.function.Function;
+
+public class ModularItemStack implements IModularItem {
+
+    public static final String MODULE_SLOTS_KEY = "ModuleSlots";
+    public static final String MODULES_TAG = "Modules";
+
+    private final ItemStack stack;
+    private final Function<ItemStack, List<ItemModuleSlot>> defaultSlotGetter;
+
+    public ModularItemStack(ItemStack stack, Function<ItemStack, List<ItemModuleSlot>> defaultSlotGetter) {
+        this.stack = stack;
+        this.defaultSlotGetter = defaultSlotGetter;
+    }
+
+    @Override
+    public AppliedItemModule attach(ItemModule module, int slot, boolean simulate) {
+        CompoundTag modulesTag = stack.getOrCreateTagElement(MODULES_TAG);
+        ItemModuleSlot moduleSlot = getSlots().get(slot);
+        if (moduleSlot == null || !moduleSlot.acceptsModule(module) || !module.canApplyTo(stack)) return null;
+        if (!modulesTag.contains(String.valueOf(slot)) && !simulate)
+            modulesTag.put(String.valueOf(slot), new CompoundTag());
+        AppliedItemModule appliedModule = new AppliedItemModule(
+                simulate ? new CompoundTag() : modulesTag.getCompound(String.valueOf(slot)),
+                module,
+                slot);
+        appliedModule.setAppliedTo(stack);
+        if (!simulate) {
+            module.onAttach(appliedModule);
+        }
+        return appliedModule;
+    }
+
+    @Override
+    public @Nullable AppliedItemModule attach(ItemModule module, boolean simulate) {
+        for (int i = 0; i < getSlots().size(); i++) {
+            if (getModuleInSlot(i) == null) return attach(module, i, simulate);
+        }
+        return null;
+    }
+
+    @Override
+    public void clearModules() {
+        stack.removeTagKey(MODULES_TAG);
+    }
+
+    @Override
+    public @Nullable AppliedItemModule getModuleInSlot(int slot) {
+        CompoundTag modulesTag = stack.getOrCreateTagElement(MODULES_TAG);
+        if (!modulesTag.contains(String.valueOf(slot))) return null;
+        return new AppliedItemModule(modulesTag.getCompound(String.valueOf(slot)), stack, slot);
+    }
+
+    @Override
+    public @NotNull List<AppliedItemModule> getAppliedModules() {
+        CompoundTag modulesTag = stack.getOrCreateTagElement(MODULES_TAG);
+        List<AppliedItemModule> modules = new ArrayList<>();
+        for (String key : modulesTag.getAllKeys()) {
+            modules.add(new AppliedItemModule(modulesTag.getCompound(key), stack, Integer.parseInt(key)));
+        }
+        return modules;
+    }
+
+    @Override
+    public @Nullable AppliedItemModule getModule(ItemModule module) {
+        return getAppliedModules().stream().filter(appliedModule -> appliedModule.getModule() == module).findAny()
+                .orElse(null);
+    }
+
+    public List<ItemModuleSlot> getDefaultSlots() {
+        return this.defaultSlotGetter.apply(stack);
+    }
+
+    @Override
+    public void setSlots(List<ItemModuleSlot> slots) {
+        CompoundTag tag = new CompoundTag();
+        for (int i = 0; i < slots.size(); i++) {
+            ItemModuleSlot slot = slots.get(i);
+            if (slot != null) tag.put(String.valueOf(i), slot.serializeNBT());
+        }
+        stack.getOrCreateTag().put(MODULE_SLOTS_KEY, tag);
+    }
+
+    @Unmodifiable
+    @Override
+    public List<ItemModuleSlot> getSlots() {
+        if (!stack.getOrCreateTag().contains(MODULE_SLOTS_KEY, Tag.TAG_COMPOUND)) {
+            List<ItemModuleSlot> slots = getDefaultSlots();
+            setSlots(slots);
+            return slots;
+        } else {
+            List<ItemModuleSlot> slots = new ArrayList<>();
+            CompoundTag tag = stack.getOrCreateTagElement(MODULE_SLOTS_KEY);
+            for (String key : tag.getAllKeys()) {
+                int i = Integer.parseInt(key);
+                while (slots.size() <= i) slots.add(null);
+                slots.set(i, ItemModuleSlot.fromNBT(tag.getCompound(key)));
+            }
+            return slots;
+        }
+    }
+}
diff --git a/src/main/java/com/gregtechceu/gtceu/api/item/component/ICustomRenderer.java b/src/main/java/com/gregtechceu/gtceu/api/item/component/ICustomRenderer.java
deleted file mode 100644
index 9a295f6e91f..00000000000
--- a/src/main/java/com/gregtechceu/gtceu/api/item/component/ICustomRenderer.java
+++ /dev/null
@@ -1,11 +0,0 @@
-package com.gregtechceu.gtceu.api.item.component;
-
-import com.lowdragmc.lowdraglib.client.renderer.IRenderer;
-
-import org.jetbrains.annotations.NotNull;
-
-public interface ICustomRenderer extends IItemComponent {
-
-    @NotNull
-    IRenderer getRenderer();
-}
diff --git a/src/main/java/com/gregtechceu/gtceu/api/item/component/IMonitorModuleItem.java b/src/main/java/com/gregtechceu/gtceu/api/item/component/IMonitorModuleItem.java
index 91a12e74343..2d78e03b506 100644
--- a/src/main/java/com/gregtechceu/gtceu/api/item/component/IMonitorModuleItem.java
+++ b/src/main/java/com/gregtechceu/gtceu/api/item/component/IMonitorModuleItem.java
@@ -5,19 +5,21 @@
 import com.gregtechceu.gtceu.common.machine.multiblock.electric.CentralMonitorMachine;
 import com.gregtechceu.gtceu.common.machine.multiblock.electric.monitor.MonitorGroup;
 
-import com.lowdragmc.lowdraglib.gui.widget.Widget;
-
 import net.minecraft.world.item.ItemStack;
 
+import brachy.modularui.api.IPanelHandler;
+import brachy.modularui.value.sync.PanelSyncManager;
+
 public interface IMonitorModuleItem extends IItemComponent {
 
     default void tick(ItemStack stack, CentralMonitorMachine machine, MonitorGroup group) {}
 
     default void tickInPlaceholder(ItemStack stack, PlaceholderContext context) {}
 
-    IMonitorRenderer getRenderer(ItemStack stack);
+    IMonitorRenderer getRenderer(ItemStack stack, CentralMonitorMachine machine, MonitorGroup group);
 
-    Widget createUIWidget(ItemStack stack, CentralMonitorMachine machine, MonitorGroup group);
+    IPanelHandler createModularPanel(ItemStack stack, CentralMonitorMachine machine, MonitorGroup group,
+                                     PanelSyncManager syncManager);
 
     default String getType() {
         return "unknown";
diff --git a/src/main/java/com/gregtechceu/gtceu/api/item/component/ModularItemComponent.java b/src/main/java/com/gregtechceu/gtceu/api/item/component/ModularItemComponent.java
new file mode 100644
index 00000000000..602e6103dc9
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/api/item/component/ModularItemComponent.java
@@ -0,0 +1,150 @@
+package com.gregtechceu.gtceu.api.item.component;
+
+import com.gregtechceu.gtceu.api.capability.GTCapability;
+import com.gregtechceu.gtceu.api.capability.GTCapabilityHelper;
+import com.gregtechceu.gtceu.api.item.capability.ModularItemStack;
+import com.gregtechceu.gtceu.api.item.component.forge.IComponentCapability;
+import com.gregtechceu.gtceu.api.item.module.AppliedItemModule;
+import com.gregtechceu.gtceu.api.item.module.ICapabilityModule;
+import com.gregtechceu.gtceu.api.item.module.IModularItem;
+import com.gregtechceu.gtceu.api.item.module.ItemModuleSlot;
+import com.gregtechceu.gtceu.common.data.GTItemModules;
+
+import net.minecraft.ChatFormatting;
+import net.minecraft.network.chat.Component;
+import net.minecraft.world.InteractionHand;
+import net.minecraft.world.InteractionResult;
+import net.minecraft.world.InteractionResultHolder;
+import net.minecraft.world.entity.LivingEntity;
+import net.minecraft.world.entity.player.Player;
+import net.minecraft.world.item.Item;
+import net.minecraft.world.item.ItemStack;
+import net.minecraft.world.item.TooltipFlag;
+import net.minecraft.world.item.context.UseOnContext;
+import net.minecraft.world.level.Level;
+import net.minecraftforge.common.capabilities.Capability;
+import net.minecraftforge.common.util.LazyOptional;
+
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.function.Function;
+
+public class ModularItemComponent implements IItemComponent, IComponentCapability, IInteractionItem, IAddInformation {
+
+    private final Function<ItemStack, List<ItemModuleSlot>> defaultSlotGetter;
+
+    public ModularItemComponent(Function<ItemStack, List<ItemModuleSlot>> defaultSlotGetter) {
+        this.defaultSlotGetter = defaultSlotGetter;
+    }
+
+    public ModularItemComponent(int slots, int maxTier) {
+        List<ItemModuleSlot> defaultSlots = new ArrayList<>();
+        for (int i = 0; i < slots; i++) defaultSlots.add(GTItemModules.TIERED_SLOTS[maxTier]);
+        this.defaultSlotGetter = stack -> defaultSlots;
+    }
+
+    @Override
+    public @NotNull <T> LazyOptional<T> getCapability(ItemStack stack, @NotNull Capability<T> cap) {
+        if (cap == GTCapability.CAPABILITY_MODULAR_ITEM)
+            return GTCapability.CAPABILITY_MODULAR_ITEM.orEmpty(cap,
+                    LazyOptional.of(() -> new ModularItemStack(stack, defaultSlotGetter)));
+        else {
+            IModularItem modularItem = GTCapabilityHelper.getModularItem(stack);
+            if (modularItem != null) {
+                for (AppliedItemModule module : modularItem.getAppliedModules()) {
+                    if (module.getModule() instanceof ICapabilityModule capabilityModule) {
+                        LazyOptional<T> optional = capabilityModule.getCapability(module, cap);
+                        if (optional.isPresent()) return optional;
+                    }
+                }
+            }
+            return LazyOptional.empty();
+        }
+    }
+
+    @Override
+    public InteractionResultHolder<ItemStack> use(Item item, Level level, Player player, InteractionHand usedHand) {
+        IModularItem modularItem = GTCapabilityHelper.getModularItem(player.getItemInHand(usedHand));
+        if (modularItem != null) {
+            for (AppliedItemModule module : modularItem.getAppliedModules()) {
+                InteractionResultHolder<ItemStack> result = module.getModule().use(module, level, player, usedHand);
+                if (result.getResult() != InteractionResult.PASS) return result;
+            }
+        }
+        return IInteractionItem.super.use(item, level, player, usedHand);
+    }
+
+    @Override
+    public InteractionResult useOn(UseOnContext context) {
+        IModularItem modularItem = GTCapabilityHelper.getModularItem(context.getItemInHand());
+        if (modularItem != null) {
+            for (AppliedItemModule module : modularItem.getAppliedModules()) {
+                InteractionResult result = module.getModule().useOn(module, context);
+                if (result != InteractionResult.PASS) return result;
+            }
+        }
+        return IInteractionItem.super.useOn(context);
+    }
+
+    @Override
+    public InteractionResult onItemUseFirst(ItemStack itemStack, UseOnContext context) {
+        IModularItem modularItem = GTCapabilityHelper.getModularItem(itemStack);
+        if (modularItem != null) {
+            for (AppliedItemModule module : modularItem.getAppliedModules()) {
+                InteractionResult result = module.getModule().onItemUseFirst(module, context);
+                if (result != InteractionResult.PASS) return result;
+            }
+        }
+        return IInteractionItem.super.onItemUseFirst(itemStack, context);
+    }
+
+    @Override
+    public InteractionResult interactLivingEntity(ItemStack stack, Player player, LivingEntity interactionTarget,
+                                                  InteractionHand usedHand) {
+        IModularItem modularItem = GTCapabilityHelper.getModularItem(stack);
+        if (modularItem != null) {
+            for (AppliedItemModule module : modularItem.getAppliedModules()) {
+                InteractionResult result = module.getModule().interactLivingEntity(module, player, interactionTarget,
+                        usedHand);
+                if (result != InteractionResult.PASS) return result;
+            }
+        }
+        return IInteractionItem.super.interactLivingEntity(stack, player, interactionTarget, usedHand);
+    }
+
+    @Override
+    public void appendHoverText(ItemStack stack, @Nullable Level level, List<Component> tooltipComponents,
+                                TooltipFlag isAdvanced) {
+        IModularItem modularItem = GTCapabilityHelper.getModularItem(stack);
+        if (modularItem != null) {
+            List<ItemModuleSlot> slots = modularItem.getSlots();
+            if (!slots.isEmpty()) tooltipComponents.add(Component.translatable("metaarmor.tooltip.modifiers"));
+            for (int slotI = 0; slotI < slots.size(); slotI++) {
+                ItemModuleSlot slot = slots.get(slotI);
+                if (slot == null) continue;
+                AppliedItemModule module = modularItem.getModuleInSlot(slotI);
+                if (module != null) {
+                    int prevIndex = tooltipComponents.size();
+                    module.appendHoverText(level, isAdvanced, tooltipComponents);
+                    if (tooltipComponents.size() > prevIndex) {
+                        tooltipComponents.set(prevIndex, Component.translatable(
+                                "metaarmor.tooltip.modifier",
+                                slot.getDisplayName(),
+                                tooltipComponents.get(prevIndex)));
+                        for (int i = prevIndex + 1; i < tooltipComponents.size(); i++) {
+                            tooltipComponents.set(i, Component.literal("    ").append(tooltipComponents.get(i)));
+                        }
+                    }
+                } else {
+                    tooltipComponents.add(Component.translatable(
+                            "metaarmor.tooltip.modifier",
+                            slot.getDisplayName(),
+                            Component.translatable("metaarmor.tooltip.modifier.empty").withStyle(ChatFormatting.GRAY)));
+                }
+            }
+        }
+    }
+}
diff --git a/src/main/java/com/gregtechceu/gtceu/api/item/module/AppliedItemModule.java b/src/main/java/com/gregtechceu/gtceu/api/item/module/AppliedItemModule.java
new file mode 100644
index 00000000000..d314ef618f0
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/api/item/module/AppliedItemModule.java
@@ -0,0 +1,142 @@
+package com.gregtechceu.gtceu.api.item.module;
+
+import com.gregtechceu.gtceu.GTCEu;
+import com.gregtechceu.gtceu.api.item.capability.ModularItemStack;
+
+import net.minecraft.core.BlockPos;
+import net.minecraft.nbt.CompoundTag;
+import net.minecraft.network.chat.Component;
+import net.minecraft.world.damagesource.DamageSource;
+import net.minecraft.world.entity.LivingEntity;
+import net.minecraft.world.entity.player.Player;
+import net.minecraft.world.item.ItemStack;
+import net.minecraft.world.item.TooltipFlag;
+import net.minecraft.world.level.Level;
+
+import lombok.Getter;
+import lombok.Setter;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+
+import java.util.List;
+
+public final class AppliedItemModule {
+
+    private final CompoundTag moduleTag;
+    @Getter
+    private final int slot;
+
+    @Getter
+    private ItemModule module;
+
+    @Getter
+    private CompoundTag tag;
+
+    @Getter
+    private ItemStack moduleItem;
+
+    /**
+     * The stack that this module is applied to.
+     * If this module is not applied to anything, this field is {@code null}.
+     */
+    @Getter
+    @Setter
+    private ItemStack appliedTo;
+
+    /**
+     * Create an applied module and fill the provided tag with module data
+     */
+    public AppliedItemModule(CompoundTag moduleTag, ItemModule module, int slot) {
+        this.moduleTag = moduleTag;
+        this.moduleTag.put("module", module.serializeNBT());
+        this.moduleTag.put("tag", new CompoundTag());
+        this.module = module;
+        this.tag = this.moduleTag.getCompound("tag");
+        this.slot = slot;
+    }
+
+    /**
+     * Load an applied module from an existing module tag
+     */
+    public AppliedItemModule(CompoundTag moduleTag, @Nullable ItemStack appliedTo, int slot) {
+        this.moduleTag = moduleTag;
+        if (!this.moduleTag.contains("module")) {
+            GTCEu.LOGGER.warn("Created an AppliedItemModule from an invalid tag, module will be null!");
+        }
+        this.module = ItemModule.fromNBT(this.moduleTag.getCompound("module"));
+        if (!this.moduleTag.contains("tag")) this.moduleTag.put("tag", new CompoundTag());
+        this.tag = this.moduleTag.getCompound("tag");
+        this.slot = slot;
+        if (this.moduleTag.contains("item")) {
+            this.moduleItem = ItemStack.of(this.moduleTag.getCompound("item"));
+        }
+        this.appliedTo = appliedTo;
+    }
+
+    public void setModule(ItemModule module) {
+        this.moduleTag.put("module", module.serializeNBT());
+        this.module = module;
+    }
+
+    public void setModuleItem(ItemStack stack) {
+        this.moduleItem = stack;
+        this.moduleTag.put("item", stack.serializeNBT());
+    }
+
+    public void setTag(CompoundTag tag) {
+        this.moduleTag.put("tag", tag);
+        this.tag = tag;
+    }
+
+    public void detach() {
+        if (this.appliedTo == null || !this.module.canRemove(this)) return;
+        this.module.onRemove(this);
+        this.appliedTo.getOrCreateTagElement(ModularItemStack.MODULES_TAG).remove(String.valueOf(slot));
+        this.appliedTo = null;
+    }
+
+    public void inventoryTick(Player player) {
+        if (this.isEnabled()) this.module.onInventoryTick(player, this);
+        this.module.onTickRaw(this, player, player.level(), null);
+    }
+
+    public void armorTick(@NotNull LivingEntity entity) {
+        if (this.isEnabled()) this.module.onArmorTick(entity, this);
+    }
+
+    public void tick(@NotNull Level level, @Nullable BlockPos pos) {
+        this.module.onTickRaw(this, null, level, pos);
+    }
+
+    public void equip(@NotNull LivingEntity entity) {
+        this.module.onEquip(entity, this);
+    }
+
+    public void unequip(@NotNull LivingEntity entity) {
+        this.module.onUnequip(entity, this);
+    }
+
+    public float changeDamage(LivingEntity entity, float damage, DamageSource source) {
+        return this.isEnabled() ? this.module.changeDamage(entity, this, damage, source) : damage;
+    }
+
+    public void appendHoverText(Level level, TooltipFlag isAdvanced, List<Component> tooltips) {
+        this.module.appendHoverText(level, isAdvanced, tooltips, this);
+    }
+
+    public boolean isEnabled() {
+        return this.module.isEnabled(this);
+    }
+
+    public void setEnabled(boolean enabled) {
+        this.module.setEnabled(this, enabled);
+    }
+
+    public boolean isPPE() {
+        return this.module.isPPE(this) && this.isEnabled();
+    }
+
+    public boolean canRemove() {
+        return this.module.canRemove(this);
+    }
+}
diff --git a/src/main/java/com/gregtechceu/gtceu/api/item/module/ArmorLogicItemModule.java b/src/main/java/com/gregtechceu/gtceu/api/item/module/ArmorLogicItemModule.java
new file mode 100644
index 00000000000..090c6e5195a
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/api/item/module/ArmorLogicItemModule.java
@@ -0,0 +1,63 @@
+package com.gregtechceu.gtceu.api.item.module;
+
+import com.gregtechceu.gtceu.api.item.armor.IArmorLogic;
+import com.gregtechceu.gtceu.api.item.component.IItemHUDProvider;
+
+import net.minecraft.client.gui.GuiGraphics;
+import net.minecraft.resources.ResourceLocation;
+import net.minecraft.world.entity.LivingEntity;
+import net.minecraft.world.entity.player.Player;
+
+import org.jetbrains.annotations.Nullable;
+
+public abstract class ArmorLogicItemModule extends ItemModule implements IHUDProviderItemModule {
+
+    public ArmorLogicItemModule(ResourceLocation id) {
+        super(id);
+    }
+
+    protected abstract @Nullable IArmorLogic getArmorLogic(AppliedItemModule module);
+
+    @Override
+    public void onArmorTick(LivingEntity entity, AppliedItemModule module) {
+        super.onArmorTick(entity, module);
+        IArmorLogic armorLogic = getArmorLogic(module);
+        if (armorLogic == null) return;
+        if (entity instanceof Player player) armorLogic.onArmorTick(player.level(), player, module.getAppliedTo());
+    }
+
+    @Override
+    public void onEquip(LivingEntity entity, AppliedItemModule module) {
+        super.onEquip(entity, module);
+        IArmorLogic armorLogic = getArmorLogic(module);
+        if (armorLogic == null) return;
+        if (entity instanceof Player player) armorLogic.onEquip(player);
+    }
+
+    @Override
+    public void onUnequip(LivingEntity entity, AppliedItemModule module) {
+        super.onUnequip(entity, module);
+        IArmorLogic armorLogic = getArmorLogic(module);
+        if (armorLogic == null) return;
+        if (entity instanceof Player player) armorLogic.onUnequip(player);
+    }
+
+    @Override
+    public boolean isPPE(AppliedItemModule module) {
+        IArmorLogic armorLogic = getArmorLogic(module);
+        if (armorLogic == null) return super.isPPE(module);
+        return armorLogic.isPPE(module.getAppliedTo());
+    }
+
+    @Override
+    public boolean shouldDrawHUD(AppliedItemModule module) {
+        return getArmorLogic(module) instanceof IItemHUDProvider;
+    }
+
+    @Override
+    public void drawHUD(AppliedItemModule module, GuiGraphics graphics) {
+        if (getArmorLogic(module) instanceof IItemHUDProvider provider) {
+            IItemHUDProvider.tryDrawHud(provider, module.getAppliedTo(), graphics);
+        }
+    }
+}
diff --git a/src/main/java/com/gregtechceu/gtceu/api/item/module/ICapabilityModule.java b/src/main/java/com/gregtechceu/gtceu/api/item/module/ICapabilityModule.java
new file mode 100644
index 00000000000..321a45e895f
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/api/item/module/ICapabilityModule.java
@@ -0,0 +1,11 @@
+package com.gregtechceu.gtceu.api.item.module;
+
+import net.minecraftforge.common.capabilities.Capability;
+import net.minecraftforge.common.util.LazyOptional;
+
+import org.jetbrains.annotations.NotNull;
+
+public interface ICapabilityModule {
+
+    <T> @NotNull LazyOptional<T> getCapability(AppliedItemModule module, @NotNull Capability<T> cap);
+}
diff --git a/src/main/java/com/gregtechceu/gtceu/api/item/module/IConfigurableModule.java b/src/main/java/com/gregtechceu/gtceu/api/item/module/IConfigurableModule.java
new file mode 100644
index 00000000000..a2f63e43fee
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/api/item/module/IConfigurableModule.java
@@ -0,0 +1,11 @@
+package com.gregtechceu.gtceu.api.item.module;
+
+import com.lowdragmc.lowdraglib.gui.widget.Widget;
+
+import org.jetbrains.annotations.NotNull;
+
+public interface IConfigurableModule {
+
+    @NotNull
+    Widget createConfigUI(@NotNull AppliedItemModule module);
+}
diff --git a/src/main/java/com/gregtechceu/gtceu/api/item/module/IHUDProviderItemModule.java b/src/main/java/com/gregtechceu/gtceu/api/item/module/IHUDProviderItemModule.java
new file mode 100644
index 00000000000..6d9e2d84a10
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/api/item/module/IHUDProviderItemModule.java
@@ -0,0 +1,31 @@
+package com.gregtechceu.gtceu.api.item.module;
+
+import com.gregtechceu.gtceu.api.capability.GTCapabilityHelper;
+
+import net.minecraft.client.gui.GuiGraphics;
+import net.minecraft.world.item.ItemStack;
+import net.minecraftforge.api.distmarker.Dist;
+import net.minecraftforge.api.distmarker.OnlyIn;
+
+public interface IHUDProviderItemModule {
+
+    @OnlyIn(Dist.CLIENT)
+    default boolean shouldDrawHUD(AppliedItemModule module) {
+        return true;
+    }
+
+    @OnlyIn(Dist.CLIENT)
+    void drawHUD(AppliedItemModule module, GuiGraphics graphics);
+
+    @OnlyIn(Dist.CLIENT)
+    static void tryDrawHUD(ItemStack stack, GuiGraphics graphics) {
+        if (stack == null || stack.isEmpty()) return;
+        IModularItem modularItem = GTCapabilityHelper.getModularItem(stack);
+        if (modularItem == null) return;
+        for (AppliedItemModule module : modularItem.getAppliedModules()) {
+            if (module.getModule() instanceof IHUDProviderItemModule hudProvider) {
+                if (hudProvider.shouldDrawHUD(module)) hudProvider.drawHUD(module, graphics);
+            }
+        }
+    }
+}
diff --git a/src/main/java/com/gregtechceu/gtceu/api/item/module/IJumpBoostItemModule.java b/src/main/java/com/gregtechceu/gtceu/api/item/module/IJumpBoostItemModule.java
new file mode 100644
index 00000000000..52ff35a812a
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/api/item/module/IJumpBoostItemModule.java
@@ -0,0 +1,6 @@
+package com.gregtechceu.gtceu.api.item.module;
+
+public interface IJumpBoostItemModule {
+
+    float getJumpBoost(AppliedItemModule module);
+}
diff --git a/src/main/java/com/gregtechceu/gtceu/api/item/module/IModularItem.java b/src/main/java/com/gregtechceu/gtceu/api/item/module/IModularItem.java
new file mode 100644
index 00000000000..e907c107f6e
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/api/item/module/IModularItem.java
@@ -0,0 +1,31 @@
+package com.gregtechceu.gtceu.api.item.module;
+
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+
+import java.util.List;
+
+public interface IModularItem {
+
+    /**
+     * @return the default module slot configuration of this item
+     */
+    List<ItemModuleSlot> getSlots();
+
+    void clearModules();
+
+    @Nullable
+    AppliedItemModule getModuleInSlot(int slot);
+
+    @NotNull
+    List<AppliedItemModule> getAppliedModules();
+
+    @Nullable
+    AppliedItemModule getModule(ItemModule module);
+
+    void setSlots(List<ItemModuleSlot> slots);
+
+    AppliedItemModule attach(ItemModule module, int slot, boolean simulate);
+
+    AppliedItemModule attach(ItemModule module, boolean simulate);
+}
diff --git a/src/main/java/com/gregtechceu/gtceu/api/item/module/ITieredItemModule.java b/src/main/java/com/gregtechceu/gtceu/api/item/module/ITieredItemModule.java
new file mode 100644
index 00000000000..8cd8ef09722
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/api/item/module/ITieredItemModule.java
@@ -0,0 +1,6 @@
+package com.gregtechceu.gtceu.api.item.module;
+
+public interface ITieredItemModule {
+
+    int getTier();
+}
diff --git a/src/main/java/com/gregtechceu/gtceu/api/item/module/ItemModule.java b/src/main/java/com/gregtechceu/gtceu/api/item/module/ItemModule.java
new file mode 100644
index 00000000000..d2f58aeffb7
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/api/item/module/ItemModule.java
@@ -0,0 +1,296 @@
+package com.gregtechceu.gtceu.api.item.module;
+
+import com.gregtechceu.gtceu.GTCEu;
+import com.gregtechceu.gtceu.api.capability.GTCapabilityHelper;
+import com.gregtechceu.gtceu.api.capability.IElectricItem;
+import com.gregtechceu.gtceu.common.mui.GTGuiTextures;
+
+import net.minecraft.core.BlockPos;
+import net.minecraft.nbt.CompoundTag;
+import net.minecraft.network.chat.Component;
+import net.minecraft.resources.ResourceLocation;
+import net.minecraft.world.InteractionHand;
+import net.minecraft.world.InteractionResult;
+import net.minecraft.world.InteractionResultHolder;
+import net.minecraft.world.damagesource.DamageSource;
+import net.minecraft.world.entity.Entity;
+import net.minecraft.world.entity.LivingEntity;
+import net.minecraft.world.entity.player.Player;
+import net.minecraft.world.item.ItemStack;
+import net.minecraft.world.item.TooltipFlag;
+import net.minecraft.world.item.context.UseOnContext;
+import net.minecraft.world.level.Level;
+
+import brachy.modularui.api.drawable.IKey;
+import brachy.modularui.api.widget.IWidget;
+import brachy.modularui.drawable.GuiTextures;
+import brachy.modularui.value.sync.DoubleSyncValue;
+import brachy.modularui.value.sync.PanelSyncManager;
+import brachy.modularui.value.sync.SyncHandler;
+import brachy.modularui.value.sync.SyncHandlers;
+import brachy.modularui.widget.Widget;
+import brachy.modularui.widgets.ProgressWidget;
+import brachy.modularui.widgets.SliderWidget;
+import brachy.modularui.widgets.TextWidget;
+import brachy.modularui.widgets.ToggleButton;
+import brachy.modularui.widgets.layout.Flow;
+import brachy.modularui.widgets.textfield.TextFieldWidget;
+import lombok.Getter;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.function.*;
+
+public abstract class ItemModule {
+
+    private static final Map<ResourceLocation, ItemModule> MODULES = new HashMap<>();
+
+    @Getter
+    private final ResourceLocation id;
+
+    public static @Nullable ItemModule getModuleById(ResourceLocation id) {
+        return MODULES.get(id);
+    }
+
+    public ItemModule(ResourceLocation id) {
+        this.id = id;
+        if (MODULES.containsKey(id)) {
+            GTCEu.LOGGER.warn("Attempted to create 2 modules with the same id: {}", id);
+        } else MODULES.put(id, this);
+    }
+
+    public final CompoundTag serializeNBT() {
+        CompoundTag tag = new CompoundTag();
+        tag.putString("id", id.toString());
+        return tag;
+    }
+
+    public static ItemModule fromNBT(CompoundTag tag) {
+        return getModuleById(ResourceLocation.tryParse(tag.getString("id")));
+    }
+
+    public abstract Component getInfo();
+
+    public void onAttach(AppliedItemModule module) {}
+
+    public void onRemove(AppliedItemModule module) {}
+
+    public void onEquip(LivingEntity entity, AppliedItemModule module) {}
+
+    public void onArmorTick(LivingEntity entity, AppliedItemModule module) {
+        IElectricItem electricItem = GTCapabilityHelper.getElectricItem(module.getModuleItem());
+        long energy = energyUsagePerTick(entity, module);
+        if (electricItem != null) {
+            electricItem.discharge(energy, electricItem.getTier(), true, false, false);
+        }
+    }
+
+    public void onUnequip(LivingEntity entity, AppliedItemModule module) {}
+
+    /**
+     * Called each tick this item is in a player's inventory or equipment slots
+     */
+    public void onInventoryTick(Player player, AppliedItemModule module) {
+        if (module.getModuleItem() == null) return;
+        IElectricItem electricItem = GTCapabilityHelper.getElectricItem(module.getModuleItem());
+        long energy = energyUsagePerTick(player, module);
+        if (electricItem != null && useEnergyInInventory(player, module)) {
+            electricItem.discharge(energy, electricItem.getTier(), true, false, false);
+        }
+    }
+
+    /**
+     * @return name displayed in the modules UI
+     */
+    public Component getDisplayName(AppliedItemModule module) {
+        List<Component> list = new ArrayList<>();
+        appendHoverText(null, TooltipFlag.NORMAL, list, module);
+        return list.isEmpty() ? Component.empty() : list.get(0);
+    }
+
+    public void appendHoverText(Level level, TooltipFlag isAdvanced, List<Component> tooltips,
+                                AppliedItemModule module) {}
+
+    public boolean useEnergyInInventory(LivingEntity entity, AppliedItemModule module) {
+        return true;
+    }
+
+    public long energyUsagePerTick(LivingEntity entity, AppliedItemModule module) {
+        return 0;
+    }
+
+    public float changeDamage(LivingEntity entity, AppliedItemModule modifier, float damage, DamageSource source) {
+        return damage;
+    }
+
+    public boolean canRemove(AppliedItemModule module) {
+        return true;
+    }
+
+    public boolean isPPE(AppliedItemModule module) {
+        return false;
+    }
+
+    @SuppressWarnings("BooleanMethodIsAlwaysInverted")
+    public boolean canApplyTo(ItemStack stack) {
+        IModularItem modularItem = GTCapabilityHelper.getModularItem(stack);
+        return modularItem != null && modularItem.getModule(this) == null;
+    }
+
+    public boolean isEnabled(AppliedItemModule module) {
+        if (!module.getTag().contains("enabled")) {
+            setEnabled(module, true);
+        }
+        return module.getTag().getBoolean("enabled");
+    }
+
+    public void setEnabled(AppliedItemModule module, boolean enabled) {
+        module.getTag().putBoolean("enabled", enabled);
+    }
+
+    /**
+     * Called when the item this module is attached to is ticked,
+     * ignores {@link #isEnabled(AppliedItemModule)}.
+     *
+     * @param entity the entity in which the item is, {@code null} if the item is not in one
+     * @param pos    the position of the block in which the item is, {@code null} if the item is not in one
+     */
+    public void onTickRaw(AppliedItemModule module, @Nullable Entity entity, @NotNull Level level,
+                          @Nullable BlockPos pos) {}
+
+    public InteractionResultHolder<ItemStack> use(AppliedItemModule module, Level level, Player player,
+                                                  InteractionHand hand) {
+        return InteractionResultHolder.pass(player.getItemInHand(hand));
+    }
+
+    public InteractionResult useOn(AppliedItemModule module, UseOnContext context) {
+        return InteractionResult.PASS;
+    }
+
+    public InteractionResult onItemUseFirst(AppliedItemModule module, UseOnContext context) {
+        return InteractionResult.PASS;
+    }
+
+    public InteractionResult interactLivingEntity(AppliedItemModule module, Player player,
+                                                  LivingEntity interactionTarget, InteractionHand usedHand) {
+        return InteractionResult.PASS;
+    }
+
+    public Settings getSettings(AppliedItemModule module, PanelSyncManager psm, int id) {
+        psm.syncValue("module_enabled", id,
+                SyncHandlers.intNumber(() -> isEnabled(module) ? 0 : 1, x -> setEnabled(module, x == 0)));
+        Settings settings = new Settings(psm, id);
+        return settings
+                .bool(IKey.lang("gtceu.module.gui.enabled"), () -> isEnabled(module), b -> setEnabled(module, b));
+    }
+
+    public static final class Settings extends ArrayList<IWidget> {
+
+        private final PanelSyncManager psm;
+        private final int id;
+        private int current = 0;
+
+        private Settings(PanelSyncManager psm, int id) {
+            this.psm = psm;
+            this.id = id;
+        }
+
+        private String registerSyncValue(SyncHandler syncHandler) {
+            String key = "module_setting" + current;
+            current++;
+            psm.syncValue(key, id, syncHandler);
+            return key;
+        }
+
+        private Settings pop() {
+            remove(size() - 1);
+            return this;
+        }
+
+        private <W extends IWidget> W last() {
+            // noinspection unchecked
+            return (W) get(size() - 1);
+        }
+
+        private static Flow wrap(IKey label, IWidget widget) {
+            return Flow.row()
+                    .coverChildren()
+                    .childPadding(5)
+                    .child(new TextWidget<>(label))
+                    .child(widget);
+        }
+
+        public Settings custom(IKey label, SyncHandler syncHandler, Widget<?> widget) {
+            String key = registerSyncValue(syncHandler);
+            add(wrap(label, widget
+                    .syncHandler(key, id)));
+            return this;
+        }
+
+        public Settings bool(IKey label, BooleanSupplier getter, Consumer<Boolean> setter) {
+            return custom(label,
+                    SyncHandlers.intNumber(() -> getter.getAsBoolean() ? 0 : 1, x -> setter.accept(x == 0)),
+                    new ToggleButton()
+                            .invertSelected(true)
+                            .overlay(false, GuiTextures.CHECKMARK));
+        }
+
+        public Settings num(IKey label, IntSupplier getter, IntConsumer setter, int min, int max) {
+            return num(label, getter, setter, min, max, "%d");
+        }
+
+        public Settings num(IKey label, IntSupplier getter, IntConsumer setter, int min, int max, String sliderLabel) {
+            custom(label,
+                    SyncHandlers.intNumber(getter, setter),
+                    new SliderWidget()
+                            .bounds(min, max)
+                            .width(50)
+                            .stopper(1))
+                    .<Flow>last()
+                    .child(new TextWidget<>(
+                            IKey.dynamic(() -> Component.literal(sliderLabel.formatted(getter.getAsInt())))));
+            return this;
+        }
+
+        public Settings num(IKey label, DoubleSupplier getter, DoubleConsumer setter, double min, double max) {
+            return num(label, getter, setter, min, max, "%.2f"::formatted);
+        }
+
+        public Settings num(IKey label, DoubleSupplier getter, DoubleConsumer setter, double min, double max,
+                            DoubleFunction<String> sliderLabel) {
+            custom(label,
+                    SyncHandlers.doubleNumber(getter, setter),
+                    new SliderWidget()
+                            .bounds(min, max)
+                            .width(50)
+                            .stopper((max - min) / 10))
+                    .<Flow>last()
+                    .child(new TextWidget<>(
+                            IKey.dynamic(() -> Component.literal(sliderLabel.apply(getter.getAsDouble())))));
+            return this;
+        }
+
+        public Settings str(IKey label, Supplier<String> getter, Consumer<String> setter) {
+            return custom(label,
+                    SyncHandlers.string(getter, setter),
+                    new TextFieldWidget());
+        }
+
+        public Settings progress(IKey label, DoubleSupplier getter, DoubleFunction<String> rightLabel) {
+            DoubleSyncValue syncValue = SyncHandlers.doubleNumber(getter, null);
+            custom(label, syncValue, new ProgressWidget()
+                    .texture(GTGuiTextures.PROGRESS_BAR_BOILER_EMPTY_STEEL,
+                            GTGuiTextures.PROGRESS_BAR_BOILER_HEAT, 60)
+                    .direction(ProgressWidget.Direction.RIGHT)
+                    .width(50))
+                    .<Flow>last()
+                    .child(new TextWidget<>(
+                            IKey.dynamic(() -> Component.literal(rightLabel.apply(syncValue.getValue())))));
+            return this;
+        }
+    }
+}
diff --git a/src/main/java/com/gregtechceu/gtceu/api/item/module/ItemModuleSlot.java b/src/main/java/com/gregtechceu/gtceu/api/item/module/ItemModuleSlot.java
new file mode 100644
index 00000000000..6d731f384aa
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/api/item/module/ItemModuleSlot.java
@@ -0,0 +1,47 @@
+package com.gregtechceu.gtceu.api.item.module;
+
+import net.minecraft.nbt.CompoundTag;
+import net.minecraft.network.chat.Component;
+import net.minecraft.resources.ResourceLocation;
+
+import brachy.modularui.api.drawable.IDrawable;
+import lombok.Getter;
+import org.jetbrains.annotations.Nullable;
+
+import java.util.HashMap;
+import java.util.Map;
+
+public abstract class ItemModuleSlot {
+
+    private static final Map<ResourceLocation, ItemModuleSlot> SLOTS = new HashMap<>();
+
+    @Getter
+    private final ResourceLocation id;
+
+    public static @Nullable ItemModuleSlot getById(ResourceLocation id) {
+        return SLOTS.get(id);
+    }
+
+    protected ItemModuleSlot(ResourceLocation id) {
+        this.id = id;
+        SLOTS.put(id, this);
+    }
+
+    public CompoundTag serializeNBT() {
+        CompoundTag tag = new CompoundTag();
+        tag.putString("id", id.toString());
+        return tag;
+    }
+
+    public static ItemModuleSlot fromNBT(CompoundTag tag) {
+        return getById(ResourceLocation.tryParse(tag.getString("id")));
+    }
+
+    public abstract boolean acceptsModule(ItemModule module);
+
+    public abstract Component getDisplayName();
+
+    public IDrawable getSlotTexture() {
+        return null;
+    }
+}
diff --git a/src/main/java/com/gregtechceu/gtceu/api/item/module/TieredAttributeItemModule.java b/src/main/java/com/gregtechceu/gtceu/api/item/module/TieredAttributeItemModule.java
new file mode 100644
index 00000000000..db9faef2e56
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/api/item/module/TieredAttributeItemModule.java
@@ -0,0 +1,127 @@
+package com.gregtechceu.gtceu.api.item.module;
+
+import net.minecraft.nbt.CompoundTag;
+import net.minecraft.nbt.ListTag;
+import net.minecraft.nbt.Tag;
+import net.minecraft.resources.ResourceLocation;
+import net.minecraft.world.entity.EquipmentSlot;
+import net.minecraft.world.entity.LivingEntity;
+import net.minecraft.world.entity.ai.attributes.Attribute;
+import net.minecraft.world.entity.ai.attributes.AttributeModifier;
+
+import brachy.modularui.api.drawable.IKey;
+import brachy.modularui.value.sync.PanelSyncManager;
+
+import java.util.Iterator;
+import java.util.UUID;
+
+public abstract class TieredAttributeItemModule extends TieredItemModule {
+
+    private static final String MODIFIER_UUID_KEY = "modifier_id";
+    private static final String MODIFIER_AMOUNT_KEY = "modifier_amount";
+
+    public TieredAttributeItemModule(ResourceLocation id, int tier) {
+        super(id, tier);
+    }
+
+    private void attachAttribute(AppliedItemModule appliedItemModule) {
+        if (appliedItemModule.getTag().contains(MODIFIER_UUID_KEY)) return;
+        if (appliedItemModule.getAppliedTo() == null) return;
+        EquipmentSlot slot = LivingEntity.getEquipmentSlotForItem(appliedItemModule.getAppliedTo());
+        AttributeModifier attributeModifier = applySettingsToModifier(appliedItemModule,
+                getAttributeModifier(appliedItemModule));
+        appliedItemModule.getAppliedTo().addAttributeModifier(getAttribute(appliedItemModule), attributeModifier, slot);
+        appliedItemModule.getTag().putUUID(MODIFIER_UUID_KEY, attributeModifier.getId());
+    }
+
+    private void detachAttribute(AppliedItemModule appliedItemModule) {
+        UUID uuid = appliedItemModule.getTag().getUUID(MODIFIER_UUID_KEY);
+        ListTag listTag = appliedItemModule.getAppliedTo().getOrCreateTag().getList("AttributeModifiers",
+                Tag.TAG_COMPOUND);
+        Iterator<Tag> it = listTag.iterator();
+        while (it.hasNext()) {
+            Tag tag = it.next();
+            if (tag instanceof CompoundTag compoundTag) {
+                AttributeModifier attributeModifier = AttributeModifier.load(compoundTag);
+                if (attributeModifier != null && attributeModifier.getId().equals(uuid)) it.remove();
+            }
+        }
+        appliedItemModule.getTag().remove(MODIFIER_UUID_KEY);
+    }
+
+    protected double getNeutralModifier(AppliedItemModule module) {
+        return 0;
+    }
+
+    public double getMinModifier(AppliedItemModule module) {
+        AttributeModifier attributeModifier = getAttributeModifier(module);
+        double original = attributeModifier.getAmount();
+        double neutral = getNeutralModifier(module);
+        return Math.min(neutral, original);
+    }
+
+    public double getMaxModifier(AppliedItemModule module) {
+        AttributeModifier attributeModifier = getAttributeModifier(module);
+        double original = attributeModifier.getAmount();
+        double neutral = getNeutralModifier(module);
+        return Math.max(neutral, original);
+    }
+
+    protected AttributeModifier applySettingsToModifier(AppliedItemModule module, AttributeModifier modifier) {
+        double modifiedAmount = getModifier(module);
+        return new AttributeModifier(modifier.getId(), modifier.getName(), modifiedAmount, modifier.getOperation());
+    }
+
+    public double getModifier(AppliedItemModule module) {
+        if (module.getTag().contains(MODIFIER_AMOUNT_KEY))
+            return module.getTag().getDouble(MODIFIER_AMOUNT_KEY);
+        return getAttributeModifier(module).getAmount();
+    }
+
+    public void setModifier(AppliedItemModule module, double modifier) {
+        module.getTag().putDouble(MODIFIER_AMOUNT_KEY, modifier);
+        detachAttribute(module);
+        attachAttribute(module);
+    }
+
+    protected String getSliderString(AppliedItemModule module, double value) {
+        return switch (getAttributeModifier(module).getOperation()) {
+            case ADDITION -> "+%.2f".formatted(value);
+            case MULTIPLY_BASE, MULTIPLY_TOTAL -> "+%.2f%%".formatted(value * 100);
+        };
+    }
+
+    @Override
+    public Settings getSettings(AppliedItemModule module, PanelSyncManager psm, int id) {
+        return super.getSettings(module, psm, id)
+                .num(IKey.lang("gtceu.module.gui.power"),
+                        () -> getModifier(module),
+                        x -> setModifier(module, x),
+                        getMinModifier(module), getMaxModifier(module),
+                        x -> getSliderString(module, x));
+    }
+
+    @Override
+    public void onAttach(AppliedItemModule appliedItemModule) {
+        super.onAttach(appliedItemModule);
+        attachAttribute(appliedItemModule);
+    }
+
+    @Override
+    public void onRemove(AppliedItemModule appliedItemModule) {
+        super.onRemove(appliedItemModule);
+        detachAttribute(appliedItemModule);
+    }
+
+    @Override
+    public void setEnabled(AppliedItemModule module, boolean enabled) {
+        super.setEnabled(module, enabled);
+        if (this.isEnabled(module)) {
+            this.attachAttribute(module);
+        } else this.detachAttribute(module);
+    }
+
+    public abstract Attribute getAttribute(AppliedItemModule module);
+
+    public abstract AttributeModifier getAttributeModifier(AppliedItemModule module);
+}
diff --git a/src/main/java/com/gregtechceu/gtceu/api/item/module/TieredItemModule.java b/src/main/java/com/gregtechceu/gtceu/api/item/module/TieredItemModule.java
new file mode 100644
index 00000000000..fb347d35638
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/api/item/module/TieredItemModule.java
@@ -0,0 +1,49 @@
+package com.gregtechceu.gtceu.api.item.module;
+
+import com.gregtechceu.gtceu.api.GTValues;
+import com.gregtechceu.gtceu.api.capability.GTCapabilityHelper;
+
+import net.minecraft.resources.ResourceLocation;
+import net.minecraft.world.item.ItemStack;
+
+import lombok.Getter;
+
+import java.util.function.BiFunction;
+
+public abstract class TieredItemModule extends ItemModule implements ITieredItemModule {
+
+    @Getter
+    private final int tier;
+    @Getter
+    private TieredItemModule[] otherTierModules;
+
+    public TieredItemModule(ResourceLocation id, int tier) {
+        super(id);
+        this.tier = tier;
+    }
+
+    @Override
+    public boolean canApplyTo(ItemStack stack) {
+        if (otherTierModules == null) return super.canApplyTo(stack);
+        IModularItem modularItem = GTCapabilityHelper.getModularItem(stack);
+        if (modularItem == null) return false;
+        for (TieredItemModule module : otherTierModules) if (modularItem.getModule(module) != null) return false;
+        return super.canApplyTo(stack);
+    }
+
+    public static TieredItemModule[] create(ResourceLocation id, int minTier, int maxTier,
+                                            BiFunction<ResourceLocation, Integer, TieredItemModule> constructor) {
+        TieredItemModule[] result = new TieredItemModule[maxTier - minTier + 1];
+        for (int i = 0; i <= maxTier - minTier; i++) {
+            ResourceLocation resourceLocation = id.withSuffix("_" + (i + minTier));
+            result[i] = constructor.apply(resourceLocation, i + minTier);
+            result[i].otherTierModules = result;
+        }
+        return result;
+    }
+
+    public static TieredItemModule[] create(ResourceLocation id,
+                                            BiFunction<ResourceLocation, Integer, TieredItemModule> constructor) {
+        return create(id, GTValues.LV, GTValues.MAX, constructor);
+    }
+}
diff --git a/src/main/java/com/gregtechceu/gtceu/api/item/module/TieredItemModuleSlot.java b/src/main/java/com/gregtechceu/gtceu/api/item/module/TieredItemModuleSlot.java
new file mode 100644
index 00000000000..0edf46e6ce2
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/api/item/module/TieredItemModuleSlot.java
@@ -0,0 +1,53 @@
+package com.gregtechceu.gtceu.api.item.module;
+
+import com.gregtechceu.gtceu.api.GTValues;
+import com.gregtechceu.gtceu.common.mui.drawable.BorderDrawable;
+
+import net.minecraft.network.chat.Component;
+import net.minecraft.resources.ResourceLocation;
+
+import brachy.modularui.api.drawable.IDrawable;
+import lombok.Getter;
+
+import java.util.function.BiFunction;
+
+public class TieredItemModuleSlot extends ItemModuleSlot {
+
+    @Getter
+    private final int tier;
+
+    public TieredItemModuleSlot(ResourceLocation id, int tier) {
+        super(id);
+        this.tier = tier;
+    }
+
+    @Override
+    public boolean acceptsModule(ItemModule module) {
+        return !(module instanceof ITieredItemModule tieredModule) || tieredModule.getTier() <= getTier();
+    }
+
+    @Override
+    public Component getDisplayName() {
+        return Component.translatable("metaarmor.tooltip.modifier_slot.tiered", GTValues.VNF[getTier()]);
+    }
+
+    public static TieredItemModuleSlot[] create(ResourceLocation id, int minTier, int maxTier,
+                                                BiFunction<ResourceLocation, Integer, TieredItemModuleSlot> constructor) {
+        TieredItemModuleSlot[] result = new TieredItemModuleSlot[maxTier - minTier + 1];
+        for (int i = 0; i <= maxTier - minTier; i++) {
+            ResourceLocation resourceLocation = id.withSuffix("_" + (i + minTier));
+            result[i] = constructor.apply(resourceLocation, i + minTier);
+        }
+        return result;
+    }
+
+    public static TieredItemModuleSlot[] create(ResourceLocation id,
+                                                BiFunction<ResourceLocation, Integer, TieredItemModuleSlot> constructor) {
+        return create(id, GTValues.ULV, GTValues.MAX, constructor);
+    }
+
+    @Override
+    public IDrawable getSlotTexture() {
+        return new BorderDrawable(0xFF000000 | GTValues.VCM[getTier()], 1);
+    }
+}
diff --git a/src/main/java/com/gregtechceu/gtceu/api/item/module/UniversalItemModuleSlot.java b/src/main/java/com/gregtechceu/gtceu/api/item/module/UniversalItemModuleSlot.java
new file mode 100644
index 00000000000..c5903fa4e71
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/api/item/module/UniversalItemModuleSlot.java
@@ -0,0 +1,30 @@
+package com.gregtechceu.gtceu.api.item.module;
+
+import com.gregtechceu.gtceu.common.mui.drawable.BorderDrawable;
+
+import net.minecraft.network.chat.Component;
+import net.minecraft.resources.ResourceLocation;
+
+import brachy.modularui.api.drawable.IDrawable;
+
+public class UniversalItemModuleSlot extends ItemModuleSlot {
+
+    public UniversalItemModuleSlot(ResourceLocation id) {
+        super(id);
+    }
+
+    @Override
+    public boolean acceptsModule(ItemModule module) {
+        return true;
+    }
+
+    @Override
+    public Component getDisplayName() {
+        return Component.translatable("metaarmor.tooltip.modifier_slot.universal");
+    }
+
+    @Override
+    public IDrawable getSlotTexture() {
+        return new BorderDrawable(0xFFFFFFFF, 1);
+    }
+}
diff --git a/src/main/java/com/gregtechceu/gtceu/api/item/tool/IToolGridHighlight.java b/src/main/java/com/gregtechceu/gtceu/api/item/tool/IToolGridHighlight.java
index 9621d355051..d91f04b3940 100644
--- a/src/main/java/com/gregtechceu/gtceu/api/item/tool/IToolGridHighlight.java
+++ b/src/main/java/com/gregtechceu/gtceu/api/item/tool/IToolGridHighlight.java
@@ -1,13 +1,12 @@
 package com.gregtechceu.gtceu.api.item.tool;
 
-import com.lowdragmc.lowdraglib.gui.texture.ResourceTexture;
-
 import net.minecraft.core.BlockPos;
 import net.minecraft.core.Direction;
 import net.minecraft.world.entity.player.Player;
 import net.minecraft.world.item.ItemStack;
 import net.minecraft.world.level.block.state.BlockState;
 
+import brachy.modularui.drawable.UITexture;
 import org.jetbrains.annotations.Nullable;
 
 import java.util.Set;
@@ -16,7 +15,7 @@ public interface IToolGridHighlight {
 
     /**
      * Called to determine if the grid overlay should be rendered on this machine.
-     * 
+     *
      * @param player    Player looking at this machine
      * @param pos       Block pos
      * @param state     Block state
@@ -32,7 +31,7 @@ default boolean shouldRenderGrid(Player player, BlockPos pos, BlockState state,
     /**
      * Called when the machine grid overlay is being rendered to determine the icon to be rendered within the grid
      * segment on a specifc side.
-     * 
+     *
      * @param player    Player looking at this machine
      * @param pos       Block pos
      * @param state     Block state
@@ -40,8 +39,8 @@ default boolean shouldRenderGrid(Player player, BlockPos pos, BlockState state,
      * @param side      The machine side which this grid segment correspond to
      * @return The icon to be rendered, or null
      */
-    default @Nullable ResourceTexture sideTips(Player player, BlockPos pos, BlockState state, Set<GTToolType> toolTypes,
-                                               Direction side) {
+    default @Nullable UITexture sideTips(Player player, BlockPos pos, BlockState state, Set<GTToolType> toolTypes,
+                                         Direction side) {
         return null;
     }
 }
diff --git a/src/main/java/com/gregtechceu/gtceu/api/item/tool/behavior/IToolUIBehavior.java b/src/main/java/com/gregtechceu/gtceu/api/item/tool/behavior/IToolUIBehavior.java
index e00fd5f658e..c2df3dd28f7 100644
--- a/src/main/java/com/gregtechceu/gtceu/api/item/tool/behavior/IToolUIBehavior.java
+++ b/src/main/java/com/gregtechceu/gtceu/api/item/tool/behavior/IToolUIBehavior.java
@@ -1,31 +1,39 @@
 package com.gregtechceu.gtceu.api.item.tool.behavior;
 
-import com.lowdragmc.lowdraglib.gui.factory.HeldItemUIFactory;
-import com.lowdragmc.lowdraglib.gui.modular.ModularUI;
+import com.gregtechceu.gtceu.api.mui.GTGuiScreen;
 
-import net.minecraft.server.level.ServerPlayer;
 import net.minecraft.world.InteractionHand;
 import net.minecraft.world.InteractionResultHolder;
 import net.minecraft.world.entity.player.Player;
 import net.minecraft.world.item.ItemStack;
 import net.minecraft.world.level.Level;
+import net.minecraftforge.api.distmarker.Dist;
+import net.minecraftforge.api.distmarker.OnlyIn;
 
+import brachy.modularui.api.IUIHolder;
+import brachy.modularui.factory.PlayerInventoryGuiData;
+import brachy.modularui.factory.PlayerInventoryUIFactory;
+import brachy.modularui.screen.ModularPanel;
+import brachy.modularui.screen.ModularScreen;
 import org.jetbrains.annotations.NotNull;
 
-public interface IToolUIBehavior extends IToolBehavior {
+public interface IToolUIBehavior extends IToolBehavior, IUIHolder<PlayerInventoryGuiData<?>> {
 
     @Override
     default @NotNull InteractionResultHolder<ItemStack> onItemRightClick(@NotNull Level level, @NotNull Player player,
                                                                          @NotNull InteractionHand hand) {
-        var heldItem = player.getItemInHand(hand);
-        if (player instanceof ServerPlayer serverPlayer && openUI(serverPlayer, hand)) {
-            HeldItemUIFactory.INSTANCE.openUI(serverPlayer, hand);
-            return InteractionResultHolder.success(heldItem);
+        ItemStack heldItem = player.getItemInHand(hand);
+        if (level.isClientSide && shouldOpenUI(player, hand)) {
+            PlayerInventoryUIFactory.INSTANCE.openFromHandClient(hand);
         }
         return InteractionResultHolder.pass(heldItem);
     }
 
-    boolean openUI(@NotNull Player player, @NotNull InteractionHand hand);
+    @Override
+    @OnlyIn(Dist.CLIENT)
+    default ModularScreen createScreen(PlayerInventoryGuiData<?> data, ModularPanel<?> mainPanel) {
+        return new GTGuiScreen(mainPanel);
+    }
 
-    ModularUI createUI(Player player, HeldItemUIFactory.HeldItemHolder holder);
+    boolean shouldOpenUI(@NotNull Player player, @NotNull InteractionHand hand);
 }
diff --git a/src/main/java/com/gregtechceu/gtceu/api/machine/MachineCoverContainer.java b/src/main/java/com/gregtechceu/gtceu/api/machine/MachineCoverContainer.java
index 270aad6f1fb..2feb1641551 100644
--- a/src/main/java/com/gregtechceu/gtceu/api/machine/MachineCoverContainer.java
+++ b/src/main/java/com/gregtechceu/gtceu/api/machine/MachineCoverContainer.java
@@ -17,8 +17,6 @@
 import com.gregtechceu.gtceu.api.transfer.fluid.IFluidHandlerModifiable;
 import com.gregtechceu.gtceu.utils.GTUtil;
 
-import com.lowdragmc.lowdraglib.gui.texture.ResourceTexture;
-
 import net.minecraft.core.BlockPos;
 import net.minecraft.core.Direction;
 import net.minecraft.world.entity.player.Player;
@@ -28,6 +26,7 @@
 import net.minecraft.world.phys.shapes.VoxelShape;
 import net.minecraftforge.items.IItemHandlerModifiable;
 
+import brachy.modularui.drawable.UITexture;
 import lombok.Getter;
 import org.jetbrains.annotations.Nullable;
 
@@ -90,8 +89,8 @@ public boolean shouldRenderGridOverlay(Player player, BlockPos pos, BlockState s
     }
 
     @Override
-    public @Nullable ResourceTexture getGridOverlayIcon(Player player, BlockPos pos, BlockState state,
-                                                        Set<GTToolType> toolTypes, Direction side) {
+    public @Nullable UITexture getGridOverlayIcon(Player player, BlockPos pos, BlockState state,
+                                                  Set<GTToolType> toolTypes, Direction side) {
         var cover = getCoverAtSide(side);
         if (cover != null) {
             return cover.sideTips(player, pos, state, toolTypes, side);
diff --git a/src/main/java/com/gregtechceu/gtceu/api/machine/MachineDefinition.java b/src/main/java/com/gregtechceu/gtceu/api/machine/MachineDefinition.java
index 01b6204239c..ff57306e85e 100644
--- a/src/main/java/com/gregtechceu/gtceu/api/machine/MachineDefinition.java
+++ b/src/main/java/com/gregtechceu/gtceu/api/machine/MachineDefinition.java
@@ -3,15 +3,14 @@
 import com.gregtechceu.gtceu.api.block.MetaMachineBlock;
 import com.gregtechceu.gtceu.api.capability.recipe.RecipeCapability;
 import com.gregtechceu.gtceu.api.data.RotationState;
-import com.gregtechceu.gtceu.api.gui.editor.EditableMachineUI;
 import com.gregtechceu.gtceu.api.item.MetaMachineItem;
 import com.gregtechceu.gtceu.api.machine.feature.IRecipeLogicMachine;
+import com.gregtechceu.gtceu.api.mui.factory.PanelFactory;
 import com.gregtechceu.gtceu.api.recipe.GTRecipe;
 import com.gregtechceu.gtceu.api.recipe.GTRecipeType;
 import com.gregtechceu.gtceu.api.recipe.modifier.RecipeModifier;
 import com.gregtechceu.gtceu.client.model.machine.MachineRenderState;
-
-import com.lowdragmc.lowdraglib.utils.ShapeUtils;
+import com.gregtechceu.gtceu.utils.GTUtil;
 
 import net.minecraft.core.Direction;
 import net.minecraft.core.IdMapper;
@@ -26,6 +25,7 @@
 import net.minecraft.world.phys.shapes.Shapes;
 import net.minecraft.world.phys.shapes.VoxelShape;
 
+import brachy.modularui.theme.ThemeAPI;
 import it.unimi.dsi.fastutil.objects.Reference2IntMap;
 import it.unimi.dsi.fastutil.objects.Reference2IntOpenHashMap;
 import lombok.Getter;
@@ -119,10 +119,13 @@ public class MachineDefinition implements Supplier<MetaMachineBlock> {
     @Getter
     @Setter
     private boolean allowCoverOnFront;
+    @Getter
+    @Setter
     @Nullable
+    private PanelFactory UI;
     @Getter
     @Setter
-    private EditableMachineUI editableUI;
+    private String themeId = ThemeAPI.DEFAULT_ID;
     @Getter
     @Setter
     private Reference2IntMap<RecipeCapability<?>> recipeOutputLimits = new Reference2IntOpenHashMap<>();
@@ -164,7 +167,7 @@ public ItemStack asStack(int count) {
 
     public VoxelShape getShape(Direction direction) {
         if (shape.isEmpty() || shape == Shapes.block() || direction == Direction.NORTH) return shape;
-        return this.cache.computeIfAbsent(direction, dir -> ShapeUtils.rotate(shape, dir));
+        return this.cache.computeIfAbsent(direction, dir -> GTUtil.rotateVoxelShape(shape, dir));
     }
 
     @Override
diff --git a/src/main/java/com/gregtechceu/gtceu/api/machine/MetaMachine.java b/src/main/java/com/gregtechceu/gtceu/api/machine/MetaMachine.java
index 7a011bb3c71..f4b398b1222 100644
--- a/src/main/java/com/gregtechceu/gtceu/api/machine/MetaMachine.java
+++ b/src/main/java/com/gregtechceu/gtceu/api/machine/MetaMachine.java
@@ -13,8 +13,6 @@
 import com.gregtechceu.gtceu.api.capability.recipe.IO;
 import com.gregtechceu.gtceu.api.cover.CoverBehavior;
 import com.gregtechceu.gtceu.api.data.RotationState;
-import com.gregtechceu.gtceu.api.gui.GuiTextures;
-import com.gregtechceu.gtceu.api.gui.fancy.IFancyTooltip;
 import com.gregtechceu.gtceu.api.item.tool.GTToolType;
 import com.gregtechceu.gtceu.api.item.tool.IToolGridHighlight;
 import com.gregtechceu.gtceu.api.item.tool.ToolHelper;
@@ -45,11 +43,10 @@
 import com.gregtechceu.gtceu.common.machine.owner.MachineOwner;
 import com.gregtechceu.gtceu.common.machine.owner.PlayerOwner;
 import com.gregtechceu.gtceu.common.machine.trait.AutoOutputTrait;
+import com.gregtechceu.gtceu.common.mui.GTGuiTextures;
 import com.gregtechceu.gtceu.utils.ExtendedUseOnContext;
 import com.gregtechceu.gtceu.utils.data.TagCompatibilityFixer;
 
-import com.lowdragmc.lowdraglib.gui.texture.IGuiTexture;
-import com.lowdragmc.lowdraglib.gui.texture.ResourceTexture;
 import com.lowdragmc.lowdraglib.utils.DummyWorld;
 
 import net.minecraft.ChatFormatting;
@@ -58,7 +55,6 @@
 import net.minecraft.client.resources.model.BakedModel;
 import net.minecraft.core.BlockPos;
 import net.minecraft.core.Direction;
-import net.minecraft.locale.Language;
 import net.minecraft.nbt.CompoundTag;
 import net.minecraft.network.chat.Component;
 import net.minecraft.server.level.ServerPlayer;
@@ -89,6 +85,7 @@
 
 import appeng.api.networking.IInWorldGridNodeHost;
 import appeng.capabilities.Capabilities;
+import brachy.modularui.drawable.UITexture;
 import com.mojang.datafixers.util.Pair;
 import lombok.AccessLevel;
 import lombok.Getter;
@@ -102,7 +99,7 @@
  * The base BlockEntity for all GT machines.
  */
 public class MetaMachine extends ManagedSyncBlockEntity implements IGregtechBlockEntity, IToolGridHighlight,
-                         IFancyTooltip, IPaintable, IMachineFeature, ICopyable {
+                         IPaintable, IMachineFeature, ICopyable {
 
     @Getter
     protected final SyncDataHolder syncDataHolder = new SyncDataHolder(this);
@@ -202,7 +199,7 @@ public void onMachineDestroyed() {
 
     /**
      * Called to modify the drops returned when this block is destroyed
-     * 
+     *
      * @param drops A modifiable list of drops.
      */
     public void modifyDrops(List<ItemStack> drops) {}
@@ -382,7 +379,7 @@ public <T extends MachineTrait> Optional<T> getTraitOptional(MachineTraitType<T>
 
     /**
      * Called when a player clicks this machine with a GT tool
-     * 
+     *
      * @param context The context of this interaction.
      * @return A pair containing the type of the tool (if the interaction was successful), and the result of the
      *         interaction.
@@ -487,7 +484,7 @@ protected InteractionResult onScrewdriverClick(ExtendedUseOnContext context) {
 
     /**
      * Called when a machine is right clicked with an item.
-     * 
+     *
      * @param context The context which this interaction is being performed from.
      * @return The result of this interaction callback.
      */
@@ -512,7 +509,7 @@ public InteractionResult onUseWithItem(ExtendedUseOnContext context) {
     /**
      * Called when a machine is right clicked without an item, or if this machine was clicked with an item but no
      * item-specific interaction was performed.
-     * 
+     *
      * @param context The context which this interaction is being performed from.
      * @return The result of this interaction callback.
      */
@@ -621,21 +618,21 @@ public boolean shouldRenderGrid(Player player, BlockPos pos, BlockState state, I
     }
 
     @Override
-    public @Nullable ResourceTexture sideTips(Player player, BlockPos pos, BlockState state, Set<GTToolType> toolTypes,
-                                              Direction side) {
+    public @Nullable UITexture sideTips(Player player, BlockPos pos, BlockState state, Set<GTToolType> toolTypes,
+                                        Direction side) {
         if (toolTypes.contains(GTToolType.WRENCH)) {
             if (player.isShiftKeyDown()) {
                 if (isFacingValid(side) || (allowExtendedFacing() && hasFrontFacing() && side == getFrontFacing())) {
-                    return GuiTextures.TOOL_FRONT_FACING_ROTATION;
+                    return GTGuiTextures.TOOL_FRONT_FACING_ROTATION;
                 }
             }
         } else if (toolTypes.contains(GTToolType.SOFT_MALLET)) {
             if (this instanceof IControllable controllable) {
-                return controllable.isWorkingEnabled() ? GuiTextures.TOOL_START : GuiTextures.TOOL_PAUSE;
+                return controllable.isWorkingEnabled() ? GTGuiTextures.TOOL_START : GTGuiTextures.TOOL_PAUSE;
             }
         } else if (toolTypes.contains(GTToolType.HARD_HAMMER)) {
             if (this instanceof IMufflableMachine mufflableMachine) {
-                return mufflableMachine.isMuffled() ? GuiTextures.TOOL_SOUND : GuiTextures.TOOL_MUTE;
+                return mufflableMachine.isMuffled() ? GTGuiTextures.TOOL_SOUND : GTGuiTextures.TOOL_MUTE;
             }
         }
 
@@ -651,7 +648,7 @@ public boolean shouldRenderGrid(Player player, BlockPos pos, BlockState state, I
 
     /**
      * Adds extra information to the F3 debug overlay when looking at this machine.
-     * 
+     *
      * @param lines A string consumer which lines are added to.
      */
     public void addDebugOverlayText(Consumer<String> lines) {
@@ -667,7 +664,7 @@ public void addDebugOverlayText(Consumer<String> lines) {
 
     /**
      * The {@link MachineDefinition} of this machine.
-     * 
+     *
      * @return The {@link MachineDefinition}
      */
     public MachineDefinition getDefinition() {
@@ -689,7 +686,7 @@ public void addCollisionBoundingBox(List<VoxelShape> collisionList) {
 
     /**
      * Gets the direction which this machine is facing.
-     * 
+     *
      * @return The direction the machine is facing, or north if this machine does not have a front face.
      */
     public Direction getFrontFacing() {
@@ -699,7 +696,7 @@ public Direction getFrontFacing() {
 
     /**
      * Returns whether this machine has a front face.
-     * 
+     *
      * @return If this machine has a front face.
      */
     public final boolean hasFrontFacing() {
@@ -708,7 +705,7 @@ public final boolean hasFrontFacing() {
 
     /**
      * Returns whether this machine can be rotated to face a specific direction
-     * 
+     *
      * @param facing The direction to test
      * @return If it is possible to rotate this machine to face the given direction.
      */
@@ -726,7 +723,7 @@ public boolean isFacingValid(Direction facing) {
 
     /**
      * Returns the {@link RotationState} properties which this machine type supports.
-     * 
+     *
      * @return The {@link RotationState}
      */
     public RotationState getRotationState() {
@@ -735,7 +732,7 @@ public RotationState getRotationState() {
 
     /**
      * Rotates this machine to face a specific direction, if that direction is a valid facing direction.
-     * 
+     *
      * @param facing The new facing direction.
      */
     public void setFrontFacing(Direction facing) {
@@ -759,7 +756,7 @@ public void setFrontFacing(Direction facing) {
 
     /**
      * Gets the direction which is this machine's upwards face.
-     * 
+     *
      * @return The upwards facing direction, or north if this machine does not allow extended facing.
      */
     public Direction getUpwardsFacing() {
@@ -769,7 +766,7 @@ public Direction getUpwardsFacing() {
 
     /**
      * Changes this machine's upwards facing direction, if this machine supports extended facing directions.
-     * 
+     *
      * @param upwardsFacing The new upwards facing direction.
      */
     public void setUpwardsFacing(Direction upwardsFacing) {
@@ -793,7 +790,7 @@ public void setUpwardsFacing(Direction upwardsFacing) {
 
     /**
      * Returns whether this machine supports extended facing directions.
-     * 
+     *
      * @return If extended facing directions are supported.
      */
     public boolean allowExtendedFacing() {
@@ -802,7 +799,7 @@ public boolean allowExtendedFacing() {
 
     /**
      * Called when this machine is rotated
-     * 
+     *
      * @param oldFacing The previous facing direction
      * @param newFacing The new facing direction
      */
@@ -810,7 +807,7 @@ public void onRotated(Direction oldFacing, Direction newFacing) {}
 
     /**
      * Called by the block colour handler to get tint colour for a specific layer index
-     * 
+     *
      * @param index colour layer index
      * @return Integer colour, or -1 to not apply a colour tint.
      */
@@ -833,7 +830,7 @@ public ModelData getModelData() {
 
     /**
      * Called when a neighboring block is updated.
-     * 
+     *
      * @param neighborBlock The neighbor block type.
      * @param neighborPos   The neighbor position.
      * @param isMoving      If the neighbor block is moving (e.g. moved by a piston)
@@ -865,7 +862,7 @@ public BlockState getBlockAppearance(BlockState state, BlockAndTintGetter level,
     /**
      * Gets the current tick offset, which can be used to run code after a certain number of ticks.
      * For example, {@code getOffsetTimer() % 20 == 0} will be true every 20 ticks (1 second)
-     * 
+     *
      * @return The current tick offset.
      */
     public final long getOffsetTimer() {
@@ -877,11 +874,6 @@ public final long getOffsetTimer() {
         return server.getTickCount() + getOffset();
     }
 
-    @Override
-    public boolean isRemote() {
-        return IGregtechBlockEntity.super.isRemote();
-    }
-
     ////////////////////////////////
     // ***** Redstone Signals ****//
     ////////////////////////////////
@@ -973,35 +965,6 @@ public boolean canConnectRedstone(Direction side) {
         return MachineOwner.getPlayerOwner(ownerUUID);
     }
 
-    //////////////////////////////////////
-    // ******** GUI *********//
-    //////////////////////////////////////
-    @Override
-    public IGuiTexture getFancyTooltipIcon() {
-        return GuiTextures.INFO_ICON;
-    }
-
-    @Override
-    public final List<Component> getFancyTooltip() {
-        var tooltips = new ArrayList<Component>();
-        onAddFancyInformationTooltip(tooltips);
-        return tooltips;
-    }
-
-    @Override
-    public boolean showFancyTooltip() {
-        return !getFancyTooltip().isEmpty();
-    }
-
-    public void onAddFancyInformationTooltip(List<Component> tooltips) {
-        getDefinition().getTooltipBuilder().accept(getDefinition().asStack(), tooltips);
-        String mainKey = String.format("%s.machine.%s.tooltip", getDefinition().getId().getNamespace(),
-                getDefinition().getId().getPath());
-        if (Language.getInstance().has(mainKey)) {
-            tooltips.add(0, Component.translatable(mainKey));
-        }
-    }
-
     @Override
     public int getDefaultPaintingColor() {
         return getDefinition().getDefaultPaintingColor();
@@ -1029,7 +992,7 @@ public AABB getRenderBoundingBox() {
 
     /**
      * Gets the item filter for a specific side of this machine.
-     * 
+     *
      * @param side Side
      * @param io   The IO mode this filter should be applicable to.
      * @return A {@code Predicate<ItemStack>} representing this filter
@@ -1054,7 +1017,7 @@ public Predicate<ItemStack> getItemCapFilter(@Nullable Direction side, IO io) {
 
     /**
      * Gets the fluid filter for a specific side of this machine.
-     * 
+     *
      * @param side Side
      * @param io   The IO mode this filter should be applicable to.
      * @return A {@code Predicate<FluidStack>} representing this filter
@@ -1079,7 +1042,7 @@ public Predicate<FluidStack> getFluidCapFilter(@Nullable Direction side, IO io)
 
     /**
      * Gets the item handler capability for a specific side of this machine
-     * 
+     *
      * @param side               The side
      * @param useCoverCapability Whether to return an item handler provided by an attached cover, if present.
      * @return The {@link IItemHandlerModifiable} capability, or null.
@@ -1111,7 +1074,7 @@ public IItemHandlerModifiable getItemHandlerCap(@Nullable Direction side, boolea
 
     /**
      * Gets the fluid handler capability for a specific side of this machine
-     * 
+     *
      * @param side               The side
      * @param useCoverCapability Whether to return a fluid handler provided by an attached cover, if present.
      * @return The {@link IFluidHandlerModifiable} capability, or null.
diff --git a/src/main/java/com/gregtechceu/gtceu/api/machine/SimpleGeneratorMachine.java b/src/main/java/com/gregtechceu/gtceu/api/machine/SimpleGeneratorMachine.java
index 28afe1e2bfe..8183c0a87c1 100644
--- a/src/main/java/com/gregtechceu/gtceu/api/machine/SimpleGeneratorMachine.java
+++ b/src/main/java/com/gregtechceu/gtceu/api/machine/SimpleGeneratorMachine.java
@@ -3,40 +3,21 @@
 import com.gregtechceu.gtceu.api.GTValues;
 import com.gregtechceu.gtceu.api.blockentity.BlockEntityCreationInfo;
 import com.gregtechceu.gtceu.api.capability.recipe.*;
-import com.gregtechceu.gtceu.api.gui.editor.EditableMachineUI;
-import com.gregtechceu.gtceu.api.machine.feature.IFancyUIMachine;
 import com.gregtechceu.gtceu.api.recipe.GTRecipe;
-import com.gregtechceu.gtceu.api.recipe.GTRecipeType;
 import com.gregtechceu.gtceu.api.recipe.content.ContentModifier;
 import com.gregtechceu.gtceu.api.recipe.modifier.ModifierFunction;
 import com.gregtechceu.gtceu.api.recipe.modifier.ParallelLogic;
 import com.gregtechceu.gtceu.api.recipe.modifier.RecipeModifier;
-import com.gregtechceu.gtceu.api.recipe.ui.GTRecipeTypeUI;
 import com.gregtechceu.gtceu.common.data.GTMedicalConditions;
 import com.gregtechceu.gtceu.common.machine.trait.hazard.EnvironmentalHazardEmitterTrait;
 
-import com.lowdragmc.lowdraglib.gui.widget.WidgetGroup;
-import com.lowdragmc.lowdraglib.utils.Position;
-import com.lowdragmc.lowdraglib.utils.Size;
-
-import net.minecraft.Util;
-import net.minecraft.nbt.CompoundTag;
-import net.minecraft.resources.ResourceLocation;
-
-import com.google.common.collect.Tables;
 import it.unimi.dsi.fastutil.ints.Int2IntFunction;
 import lombok.Getter;
 
-import java.util.Collections;
-import java.util.EnumMap;
-import java.util.LinkedHashMap;
-import java.util.function.BiFunction;
-
 /**
  * All singleblock generators are implemented here.
  */
-public class SimpleGeneratorMachine extends WorkableTieredMachine
-                                    implements IFancyUIMachine {
+public class SimpleGeneratorMachine extends WorkableTieredMachine {
 
     @Getter
     private final EnvironmentalHazardEmitterTrait hazardEmitter;
@@ -124,40 +105,4 @@ public void afterWorking() {
     public long getDisplayRecipeVoltage() {
         return GTValues.V[this.tier];
     }
-
-    //////////////////////////////////////
-    // *********** GUI ***********//
-    //////////////////////////////////////
-
-    @SuppressWarnings("UnstableApiUsage")
-    public static BiFunction<ResourceLocation, GTRecipeType, EditableMachineUI> EDITABLE_UI_CREATOR = Util
-            .memoize((path, recipeType) -> new EditableMachineUI("generator", path, () -> {
-                WidgetGroup template = recipeType.getRecipeUI().createEditableUITemplate(false, false).createDefault();
-                WidgetGroup group = new WidgetGroup(0, 0, template.getSize().width + 4 + 8,
-                        template.getSize().height + 8);
-                Size size = group.getSize();
-                template.setSelfPosition(new Position(
-                        (size.width - 4 - template.getSize().width) / 2 + 4,
-                        (size.height - template.getSize().height) / 2));
-                group.addWidget(template);
-                return group;
-            }, (template, machine) -> {
-                if (machine instanceof SimpleGeneratorMachine generatorMachine) {
-                    var storages = Tables.newCustomTable(new EnumMap<>(IO.class),
-                            LinkedHashMap<RecipeCapability<?>, Object>::new);
-                    storages.put(IO.IN, ItemRecipeCapability.CAP, generatorMachine.importItems.storage);
-                    storages.put(IO.OUT, ItemRecipeCapability.CAP, generatorMachine.exportItems.storage);
-                    storages.put(IO.IN, FluidRecipeCapability.CAP, generatorMachine.importFluids);
-                    storages.put(IO.OUT, FluidRecipeCapability.CAP, generatorMachine.exportFluids);
-
-                    generatorMachine.getRecipeType().getRecipeUI().createEditableUITemplate(false, false).setupUI(
-                            template,
-                            new GTRecipeTypeUI.RecipeHolder(generatorMachine.recipeLogic::getProgressPercent,
-                                    storages,
-                                    new CompoundTag(),
-                                    Collections.emptyList(),
-                                    false, false));
-                    createEnergyBar().setupUI(template, generatorMachine);
-                }
-            }));
 }
diff --git a/src/main/java/com/gregtechceu/gtceu/api/machine/SimpleTieredMachine.java b/src/main/java/com/gregtechceu/gtceu/api/machine/SimpleTieredMachine.java
index 077803826a6..a6e94605482 100644
--- a/src/main/java/com/gregtechceu/gtceu/api/machine/SimpleTieredMachine.java
+++ b/src/main/java/com/gregtechceu/gtceu/api/machine/SimpleTieredMachine.java
@@ -4,42 +4,17 @@
 import com.gregtechceu.gtceu.api.blockentity.BlockEntityCreationInfo;
 import com.gregtechceu.gtceu.api.capability.GTCapabilityHelper;
 import com.gregtechceu.gtceu.api.capability.recipe.*;
-import com.gregtechceu.gtceu.api.gui.GuiTextures;
-import com.gregtechceu.gtceu.api.gui.editor.EditableMachineUI;
-import com.gregtechceu.gtceu.api.gui.editor.EditableUI;
-import com.gregtechceu.gtceu.api.gui.fancy.ConfiguratorPanel;
-import com.gregtechceu.gtceu.api.gui.fancy.IFancyConfigurator;
-import com.gregtechceu.gtceu.api.gui.fancy.IFancyConfiguratorButton;
-import com.gregtechceu.gtceu.api.gui.widget.GhostCircuitSlotWidget;
-import com.gregtechceu.gtceu.api.gui.widget.SlotWidget;
-import com.gregtechceu.gtceu.api.machine.fancyconfigurator.CircuitFancyConfigurator;
-import com.gregtechceu.gtceu.api.machine.feature.IFancyUIMachine;
+import com.gregtechceu.gtceu.api.machine.feature.IHasBatterySlot;
 import com.gregtechceu.gtceu.api.machine.feature.IHasCircuitSlot;
 import com.gregtechceu.gtceu.api.machine.trait.NotifiableItemStackHandler;
-import com.gregtechceu.gtceu.api.recipe.GTRecipeType;
-import com.gregtechceu.gtceu.api.recipe.ui.GTRecipeTypeUI;
 import com.gregtechceu.gtceu.api.sync_system.annotations.SaveField;
 import com.gregtechceu.gtceu.api.sync_system.annotations.SyncToClient;
 import com.gregtechceu.gtceu.api.transfer.item.CustomItemStackHandler;
 import com.gregtechceu.gtceu.common.item.behavior.IntCircuitBehaviour;
 import com.gregtechceu.gtceu.common.machine.trait.AutoOutputTrait;
 import com.gregtechceu.gtceu.config.ConfigHolder;
-import com.gregtechceu.gtceu.data.lang.LangHandler;
 import com.gregtechceu.gtceu.utils.ISubscription;
 
-import com.lowdragmc.lowdraglib.gui.texture.GuiTextureGroup;
-import com.lowdragmc.lowdraglib.gui.texture.IGuiTexture;
-import com.lowdragmc.lowdraglib.gui.texture.ResourceTexture;
-import com.lowdragmc.lowdraglib.gui.util.ClickData;
-import com.lowdragmc.lowdraglib.gui.widget.WidgetGroup;
-import com.lowdragmc.lowdraglib.utils.Position;
-
-import net.minecraft.Util;
-import net.minecraft.nbt.CompoundTag;
-import net.minecraft.network.chat.Component;
-import net.minecraft.resources.ResourceLocation;
-
-import com.google.common.collect.Tables;
 import it.unimi.dsi.fastutil.ints.Int2IntFunction;
 import lombok.Getter;
 import org.jetbrains.annotations.Nullable;
@@ -51,7 +26,7 @@
  * All simple single machines are implemented here.
  */
 public class SimpleTieredMachine extends WorkableTieredMachine
-                                 implements IFancyUIMachine, IHasCircuitSlot {
+                                 implements IHasCircuitSlot, IHasBatterySlot {
 
     @Getter
     @SaveField
@@ -134,151 +109,12 @@ public void onMachineDestroyed() {
         chargerInventory.dropInventoryInWorld(getLevel(), getBlockPos());
     }
 
-    /// //////////////////////////////////
+    /////////////////////////////////////
     // ****** RECIPE LOGIC *******//
-    /// //////////////////////////////////
+    /////////////////////////////////////
 
     @Override
     public long getDisplayRecipeVoltage() {
         return GTValues.V[this.tier];
     }
-
-    //////////////////////////////////////
-    // *********** GUI ***********//
-    //////////////////////////////////////
-
-    @Override
-    public void attachConfigurators(ConfiguratorPanel configuratorPanel) {
-        IFancyUIMachine.super.attachConfigurators(configuratorPanel);
-
-        if (autoOutput.supportsAutoOutputFluids()) {
-            configuratorPanel.attachConfigurators(createAutoOutputFluidConfigurator());
-        }
-        if (autoOutput.supportsAutoOutputItems()) {
-            configuratorPanel.attachConfigurators(createAutoOutputItemConfigurator());
-        }
-
-        if (isCircuitSlotEnabled()) {
-            configuratorPanel.attachConfigurators(new CircuitFancyConfigurator(circuitInventory.storage));
-        }
-    }
-
-    private IFancyConfigurator createAutoOutputFluidConfigurator() {
-        return createAutoOutputConfigurator(
-                GuiTextures.IO_CONFIG_FLUID_MODES_BUTTON,
-                "gtceu.gui.fluid_auto_output",
-                this.autoOutput::isAutoOutputFluids,
-                (cd, nextState) -> this.autoOutput.setAllowAutoOutputFluids(nextState));
-    }
-
-    private IFancyConfigurator createAutoOutputItemConfigurator() {
-        return createAutoOutputConfigurator(
-                GuiTextures.IO_CONFIG_ITEM_MODES_BUTTON,
-                "gtceu.gui.item_auto_output",
-                this.autoOutput::isAutoOutputItems,
-                (cd, nextState) -> this.autoOutput.setAllowAutoOutputItems(nextState));
-    }
-
-    private IFancyConfigurator createAutoOutputConfigurator(ResourceTexture modesButtonTexture,
-                                                            String tooltipBaseLangKey,
-                                                            BooleanSupplier stateSupplier,
-                                                            BiConsumer<ClickData, Boolean> onToggle) {
-        var toggle = new IFancyConfiguratorButton.Toggle(
-                new GuiTextureGroup(
-                        GuiTextures.TOGGLE_BUTTON_BACK.getSubTexture(0, 0, 1, 0.5),
-                        modesButtonTexture.getSubTexture(0, 1 / 3f, 1, 1 / 3f)),
-                new GuiTextureGroup(
-                        GuiTextures.TOGGLE_BUTTON_BACK.getSubTexture(0, 0.5, 1, 0.5),
-                        modesButtonTexture.getSubTexture(0, 2 / 3f, 1, 1 / 3f)),
-                stateSupplier,
-                onToggle);
-
-        toggle.setTooltipsSupplier(enabled -> {
-            var key = tooltipBaseLangKey + '.' + (enabled ? "enabled" : "disabled");
-            return List.of(Component.translatable(key));
-        });
-
-        return toggle;
-    }
-
-    @SuppressWarnings("UnstableApiUsage")
-    public static BiFunction<ResourceLocation, GTRecipeType, EditableMachineUI> EDITABLE_UI_CREATOR = Util
-            .memoize((path, recipeType) -> new EditableMachineUI("simple", path, () -> {
-                WidgetGroup template = recipeType.getRecipeUI().createEditableUITemplate(false, false).createDefault();
-                SlotWidget batterySlot = createBatterySlot().createDefault();
-                WidgetGroup group = new WidgetGroup(0, 0, template.getSize().width,
-                        Math.max(template.getSize().height, 78));
-                template.setSelfPosition(new Position(0, (group.getSize().height - template.getSize().height) / 2));
-                batterySlot.setSelfPosition(new Position(group.getSize().width / 2 - 9, group.getSize().height - 18));
-                group.addWidget(batterySlot);
-                group.addWidget(template);
-
-                // TODO fix this.
-                // if (ConfigHolder.INSTANCE.machines.ghostCircuit) {
-                // SlotWidget circuitSlot = createCircuitConfigurator().createDefault();
-                // circuitSlot.setSelfPosition(new Position(120, 62));
-                // group.addWidget(circuitSlot);
-                // }
-
-                return group;
-            }, (template, machine) -> {
-                if (machine instanceof SimpleTieredMachine tieredMachine) {
-                    var storages = Tables.newCustomTable(new EnumMap<>(IO.class),
-                            LinkedHashMap<RecipeCapability<?>, Object>::new);
-                    storages.put(IO.IN, ItemRecipeCapability.CAP, tieredMachine.importItems.storage);
-                    storages.put(IO.OUT, ItemRecipeCapability.CAP, tieredMachine.exportItems.storage);
-                    storages.put(IO.IN, FluidRecipeCapability.CAP, tieredMachine.importFluids);
-                    storages.put(IO.OUT, FluidRecipeCapability.CAP, tieredMachine.exportFluids);
-                    storages.put(IO.IN, CWURecipeCapability.CAP, tieredMachine.importComputation);
-                    storages.put(IO.OUT, CWURecipeCapability.CAP, tieredMachine.exportComputation);
-
-                    tieredMachine.getRecipeType().getRecipeUI().createEditableUITemplate(false, false).setupUI(template,
-                            new GTRecipeTypeUI.RecipeHolder(tieredMachine.recipeLogic::getProgressPercent,
-                                    storages,
-                                    new CompoundTag(),
-                                    Collections.emptyList(),
-                                    false, false));
-                    createBatterySlot().setupUI(template, tieredMachine);
-                    // createCircuitConfigurator().setupUI(template, tieredMachine);
-                }
-            }));
-
-    /**
-     * Create a battery slot widget.
-     */
-    protected static EditableUI<SlotWidget, SimpleTieredMachine> createBatterySlot() {
-        return new EditableUI<>("battery_slot", SlotWidget.class, () -> {
-            var slotWidget = new SlotWidget();
-            slotWidget.setBackground(GuiTextures.SLOT, GuiTextures.CHARGER_OVERLAY);
-            return slotWidget;
-        }, (slotWidget, machine) -> {
-            slotWidget.setHandlerSlot(machine.chargerInventory, 0);
-            slotWidget.setCanPutItems(true);
-            slotWidget.setCanTakeItems(true);
-            slotWidget.setHoverTooltips(LangHandler.getMultiLang("gtceu.gui.charger_slot.tooltip",
-                    GTValues.VNF[machine.getTier()], GTValues.VNF[machine.getTier()]).toArray(Component[]::new));
-        });
-    }
-
-    /**
-     * Create a ghost circuit slot widget.
-     */
-    protected static EditableUI<GhostCircuitSlotWidget, SimpleTieredMachine> createCircuitConfigurator() {
-        return new EditableUI<>("circuit_configurator", GhostCircuitSlotWidget.class, () -> {
-            var slotWidget = new GhostCircuitSlotWidget();
-            slotWidget.setBackground(GuiTextures.SLOT, GuiTextures.INT_CIRCUIT_OVERLAY);
-            return slotWidget;
-        }, (slotWidget, machine) -> {
-            slotWidget.setCircuitInventory(machine.circuitInventory);
-            slotWidget.setCanPutItems(false);
-            slotWidget.setCanTakeItems(false);
-            slotWidget.setHoverTooltips(
-                    LangHandler.getMultiLang("gtceu.gui.configurator_slot.tooltip").toArray(Component[]::new));
-        });
-    }
-
-    // Method provided to override
-    protected IGuiTexture getCircuitSlotOverlay() {
-        return GuiTextures.INT_CIRCUIT_OVERLAY;
-    }
 }
diff --git a/src/main/java/com/gregtechceu/gtceu/api/machine/TieredEnergyMachine.java b/src/main/java/com/gregtechceu/gtceu/api/machine/TieredEnergyMachine.java
index c6236776f7c..bdcdeb674fc 100644
--- a/src/main/java/com/gregtechceu/gtceu/api/machine/TieredEnergyMachine.java
+++ b/src/main/java/com/gregtechceu/gtceu/api/machine/TieredEnergyMachine.java
@@ -2,17 +2,11 @@
 
 import com.gregtechceu.gtceu.api.GTValues;
 import com.gregtechceu.gtceu.api.blockentity.BlockEntityCreationInfo;
-import com.gregtechceu.gtceu.api.gui.GuiTextures;
-import com.gregtechceu.gtceu.api.gui.editor.EditableUI;
 import com.gregtechceu.gtceu.api.machine.trait.NotifiableEnergyContainer;
 import com.gregtechceu.gtceu.api.sync_system.annotations.SaveField;
 import com.gregtechceu.gtceu.api.sync_system.annotations.SyncToClient;
 import com.gregtechceu.gtceu.common.machine.trait.EnvironmentalExplosionTrait;
 
-import com.lowdragmc.lowdraglib.gui.texture.IGuiTexture;
-import com.lowdragmc.lowdraglib.gui.texture.ProgressTexture;
-import com.lowdragmc.lowdraglib.gui.widget.ProgressWidget;
-
 import net.minecraft.util.Mth;
 
 import lombok.Getter;
@@ -92,18 +86,4 @@ protected long getMaxInputOutputAmperage() {
     protected boolean isEnergyEmitter() {
         return false;
     }
-
-    /**
-     * Create an energy bar widget.
-     */
-    protected static EditableUI<ProgressWidget, TieredEnergyMachine> createEnergyBar() {
-        return new EditableUI<>("energy_container", ProgressWidget.class, () -> {
-            var progressBar = new ProgressWidget(ProgressWidget.JEIProgress, 0, 0, 18, 60,
-                    new ProgressTexture(IGuiTexture.EMPTY, GuiTextures.ENERGY_BAR_BASE));
-            progressBar.setFillDirection(ProgressTexture.FillDirection.DOWN_TO_UP);
-            progressBar.setBackground(GuiTextures.ENERGY_BAR_BACKGROUND);
-            return progressBar;
-        }, (progressBar, machine) -> progressBar.setProgressSupplier(
-                () -> machine.energyContainer.getEnergyStored() * 1d / machine.energyContainer.getEnergyCapacity()));
-    }
 }
diff --git a/src/main/java/com/gregtechceu/gtceu/api/machine/WorkableTieredMachine.java b/src/main/java/com/gregtechceu/gtceu/api/machine/WorkableTieredMachine.java
index f5b2553f098..1ef33be41b7 100644
--- a/src/main/java/com/gregtechceu/gtceu/api/machine/WorkableTieredMachine.java
+++ b/src/main/java/com/gregtechceu/gtceu/api/machine/WorkableTieredMachine.java
@@ -95,7 +95,7 @@ public WorkableTieredMachine(BlockEntityCreationInfo info, int tier, Int2IntFunc
         this.recipeLogic = attachTrait(new RecipeLogic());
         this.importItems = attachTrait(
                 new NotifiableItemStackHandler(getRecipeType().getMaxInputs(ItemRecipeCapability.CAP),
-                        IO.IN));
+                        IO.IN, IO.BOTH));
         this.exportItems = attachTrait(
                 new NotifiableItemStackHandler(getRecipeType().getMaxOutputs(ItemRecipeCapability.CAP),
                         IO.OUT));
diff --git a/src/main/java/com/gregtechceu/gtceu/api/machine/fancyconfigurator/AutoStockingFancyConfigurator.java b/src/main/java/com/gregtechceu/gtceu/api/machine/fancyconfigurator/AutoStockingFancyConfigurator.java
deleted file mode 100644
index 94620e8736c..00000000000
--- a/src/main/java/com/gregtechceu/gtceu/api/machine/fancyconfigurator/AutoStockingFancyConfigurator.java
+++ /dev/null
@@ -1,53 +0,0 @@
-package com.gregtechceu.gtceu.api.machine.fancyconfigurator;
-
-import com.gregtechceu.gtceu.api.gui.fancy.IFancyConfigurator;
-import com.gregtechceu.gtceu.api.gui.widget.IntInputWidget;
-import com.gregtechceu.gtceu.common.data.GTItems;
-import com.gregtechceu.gtceu.config.ConfigHolder;
-import com.gregtechceu.gtceu.integration.ae2.machine.MEStockingBusPartMachine;
-import com.gregtechceu.gtceu.integration.ae2.machine.feature.multiblock.IMEStockingPart;
-
-import com.lowdragmc.lowdraglib.gui.texture.IGuiTexture;
-import com.lowdragmc.lowdraglib.gui.texture.ItemStackTexture;
-import com.lowdragmc.lowdraglib.gui.widget.LabelWidget;
-import com.lowdragmc.lowdraglib.gui.widget.Widget;
-import com.lowdragmc.lowdraglib.gui.widget.WidgetGroup;
-
-import net.minecraft.network.chat.Component;
-
-public class AutoStockingFancyConfigurator implements IFancyConfigurator {
-
-    private IMEStockingPart machine;
-
-    public AutoStockingFancyConfigurator(IMEStockingPart machine) {
-        this.machine = machine;
-    }
-
-    @Override
-    public Component getTitle() {
-        return Component.translatable("gtceu.gui.adv_stocking_config.title");
-    }
-
-    @Override
-    public IGuiTexture getIcon() {
-        return new ItemStackTexture(GTItems.TOOL_DATA_STICK.asStack());
-    }
-
-    @Override
-    public Widget createConfigurator() {
-        var group = new WidgetGroup(0, 0, 90, 70);
-
-        String suffix = machine instanceof MEStockingBusPartMachine ? "min_item_count" : "min_fluid_count";
-
-        group.addWidget(new LabelWidget(4, 2, "gtceu.gui.title.adv_stocking_config." + suffix));
-        group.addWidget(new IntInputWidget(4, 12, 81, 14, machine::getMinStackSize,
-                machine::setMinStackSize).setMin(1)
-                .appendHoverTooltips(Component.translatable("gtceu.gui.adv_stocking_config." + suffix)));
-        group.addWidget(new LabelWidget(4, 36, "gtceu.gui.title.adv_stocking_config.ticks_per_cycle"));
-        group.addWidget(new IntInputWidget(4, 46, 81, 14, machine::getTicksPerCycle,
-                machine::setTicksPerCycle).setMin(ConfigHolder.INSTANCE.compat.ae2.updateIntervals)
-                .setHoverTooltips(Component.translatable("gtceu.gui.adv_stocking_config.ticks_per_cycle")));
-
-        return group;
-    }
-}
diff --git a/src/main/java/com/gregtechceu/gtceu/api/machine/fancyconfigurator/ButtonConfigurator.java b/src/main/java/com/gregtechceu/gtceu/api/machine/fancyconfigurator/ButtonConfigurator.java
deleted file mode 100644
index 839da741dc9..00000000000
--- a/src/main/java/com/gregtechceu/gtceu/api/machine/fancyconfigurator/ButtonConfigurator.java
+++ /dev/null
@@ -1,39 +0,0 @@
-package com.gregtechceu.gtceu.api.machine.fancyconfigurator;
-
-import com.gregtechceu.gtceu.api.gui.fancy.IFancyConfiguratorButton;
-
-import com.lowdragmc.lowdraglib.gui.texture.IGuiTexture;
-import com.lowdragmc.lowdraglib.gui.util.ClickData;
-
-import net.minecraft.network.chat.Component;
-
-import lombok.Getter;
-import lombok.Setter;
-import lombok.experimental.Accessors;
-
-import java.util.Collections;
-import java.util.List;
-import java.util.function.Consumer;
-
-@Accessors(chain = true)
-public class ButtonConfigurator implements IFancyConfiguratorButton {
-
-    @Getter
-    protected IGuiTexture icon;
-
-    protected Consumer<ClickData> onClick;
-
-    @Getter
-    @Setter
-    protected List<Component> tooltips = Collections.emptyList();
-
-    public ButtonConfigurator(IGuiTexture texture, Consumer<ClickData> onClick) {
-        this.icon = texture;
-        this.onClick = onClick;
-    }
-
-    @Override
-    public void onClick(ClickData clickData) {
-        onClick.accept(clickData);
-    }
-}
diff --git a/src/main/java/com/gregtechceu/gtceu/api/machine/fancyconfigurator/CircuitFancyConfigurator.java b/src/main/java/com/gregtechceu/gtceu/api/machine/fancyconfigurator/CircuitFancyConfigurator.java
deleted file mode 100644
index dec55d9951c..00000000000
--- a/src/main/java/com/gregtechceu/gtceu/api/machine/fancyconfigurator/CircuitFancyConfigurator.java
+++ /dev/null
@@ -1,201 +0,0 @@
-package com.gregtechceu.gtceu.api.machine.fancyconfigurator;
-
-import com.gregtechceu.gtceu.api.gui.GuiTextures;
-import com.gregtechceu.gtceu.api.gui.fancy.IFancyConfigurator;
-import com.gregtechceu.gtceu.api.gui.fancy.IFancyCustomMiddleClickAction;
-import com.gregtechceu.gtceu.api.gui.fancy.IFancyCustomMouseWheelAction;
-import com.gregtechceu.gtceu.api.gui.widget.SlotWidget;
-import com.gregtechceu.gtceu.common.item.behavior.IntCircuitBehaviour;
-import com.gregtechceu.gtceu.config.ConfigHolder;
-import com.gregtechceu.gtceu.data.lang.LangHandler;
-
-import com.lowdragmc.lowdraglib.gui.texture.GuiTextureGroup;
-import com.lowdragmc.lowdraglib.gui.texture.IGuiTexture;
-import com.lowdragmc.lowdraglib.gui.texture.ItemStackTexture;
-import com.lowdragmc.lowdraglib.gui.widget.ButtonWidget;
-import com.lowdragmc.lowdraglib.gui.widget.LabelWidget;
-import com.lowdragmc.lowdraglib.gui.widget.Widget;
-import com.lowdragmc.lowdraglib.gui.widget.WidgetGroup;
-
-import net.minecraft.network.FriendlyByteBuf;
-import net.minecraft.network.chat.Component;
-import net.minecraft.network.chat.MutableComponent;
-import net.minecraft.world.item.ItemStack;
-import net.minecraft.world.item.Items;
-import net.minecraftforge.items.ItemStackHandler;
-
-import java.util.ArrayList;
-import java.util.Arrays;
-import java.util.List;
-import java.util.function.BiConsumer;
-import java.util.function.Consumer;
-
-public class CircuitFancyConfigurator implements IFancyConfigurator, IFancyCustomMouseWheelAction,
-                                      IFancyCustomMiddleClickAction {
-
-    private static final int SET_TO_ZERO = 2;
-    private static final int SET_TO_EMPTY = 3;
-    private static final int SET_TO_N = 4;
-
-    private static final int NO_CONFIG = -1;
-
-    final ItemStackHandler circuitSlot;
-
-    public CircuitFancyConfigurator(ItemStackHandler circuitSlot) {
-        this.circuitSlot = circuitSlot;
-    }
-
-    @Override
-    public Component getTitle() {
-        return Component.translatable("gtceu.gui.circuit.title");
-    }
-
-    @Override
-    public IGuiTexture getIcon() {
-        if (IntCircuitBehaviour.isIntegratedCircuit(circuitSlot.getStackInSlot(0))) {
-            return new ItemStackTexture(circuitSlot.getStackInSlot(0));
-        }
-        return new GuiTextureGroup(new ItemStackTexture(IntCircuitBehaviour.stack(0)),
-                new ItemStackTexture(Items.BARRIER));
-    }
-
-    @Override
-    public boolean mouseWheelMove(BiConsumer<Integer, Consumer<FriendlyByteBuf>> writeClientAction, double mouseX,
-                                  double mouseY, double wheelDelta) {
-        if (wheelDelta == 0) return false;
-        if (!ConfigHolder.INSTANCE.machines.ghostCircuit && circuitSlot.getStackInSlot(0).isEmpty()) return false;
-        int nextValue = getNextValue(wheelDelta > 0);
-        if (nextValue == NO_CONFIG) {
-            if (ConfigHolder.INSTANCE.machines.ghostCircuit) {
-                circuitSlot.setStackInSlot(0, ItemStack.EMPTY);
-                writeClientAction.accept(SET_TO_EMPTY, buf -> {});
-            }
-        } else {
-            circuitSlot.setStackInSlot(0, IntCircuitBehaviour.stack(nextValue));
-            writeClientAction.accept(SET_TO_N, buf -> buf.writeVarInt(nextValue));
-        }
-        return true;
-    }
-
-    @Override
-    public void handleClientAction(int id, FriendlyByteBuf buffer) {
-        switch (id) {
-            case SET_TO_ZERO -> {
-                if (ConfigHolder.INSTANCE.machines.ghostCircuit || !circuitSlot.getStackInSlot(0).isEmpty())
-                    circuitSlot.setStackInSlot(0, IntCircuitBehaviour.stack(0));
-            }
-            case SET_TO_EMPTY -> {
-                if (ConfigHolder.INSTANCE.machines.ghostCircuit || circuitSlot.getStackInSlot(0).isEmpty())
-                    circuitSlot.setStackInSlot(0, ItemStack.EMPTY);
-                else
-                    circuitSlot.setStackInSlot(0, IntCircuitBehaviour.stack(0));
-            }
-            case SET_TO_N -> {
-                if (ConfigHolder.INSTANCE.machines.ghostCircuit || !circuitSlot.getStackInSlot(0).isEmpty())
-                    circuitSlot.setStackInSlot(0, IntCircuitBehaviour.stack(buffer.readVarInt()));
-            }
-        }
-    }
-
-    @Override
-    public void onMiddleClick(BiConsumer<Integer, Consumer<FriendlyByteBuf>> writeClientAction) {
-        if (!ConfigHolder.INSTANCE.machines.ghostCircuit && !circuitSlot.getStackInSlot(0).isEmpty())
-            circuitSlot.setStackInSlot(0, IntCircuitBehaviour.stack(0));
-        else
-            circuitSlot.setStackInSlot(0, ItemStack.EMPTY);
-        writeClientAction.accept(SET_TO_EMPTY, buf -> {});
-    }
-
-    @Override
-    public Widget createConfigurator() {
-        var group = new WidgetGroup(0, 0, 174, 132);
-        group.addWidget(new LabelWidget(9, 8, "Programmed Circuit Configuration"));
-        group.addWidget(new SlotWidget(circuitSlot, 0, (group.getSize().width - 18) / 2, 20,
-                !ConfigHolder.INSTANCE.machines.ghostCircuit, !ConfigHolder.INSTANCE.machines.ghostCircuit)
-                .setBackground(new GuiTextureGroup(GuiTextures.SLOT, GuiTextures.INT_CIRCUIT_OVERLAY)));
-        if (ConfigHolder.INSTANCE.machines.ghostCircuit) {
-            group.addWidget(new ButtonWidget((group.getSize().width - 18) / 2, 20, 18, 18, IGuiTexture.EMPTY,
-                    clickData -> {
-                        if (!clickData.isRemote) {
-                            circuitSlot.setStackInSlot(0, ItemStack.EMPTY);
-                        }
-                    }));
-        }
-        int idx = 0;
-        for (int x = 0; x <= 2; x++) {
-            for (int y = 0; y <= 8; y++) {
-                int finalIdx = idx;
-                group.addWidget(new ButtonWidget(5 + (18 * y), 48 + (18 * x), 18, 18,
-                        new GuiTextureGroup(GuiTextures.SLOT,
-                                new ItemStackTexture(IntCircuitBehaviour.stack(finalIdx)).scale(16f / 18)),
-                        clickData -> {
-                            if (!clickData.isRemote) {
-                                ItemStack stack = circuitSlot.getStackInSlot(0).copy();
-                                if (IntCircuitBehaviour.isIntegratedCircuit(stack)) {
-                                    IntCircuitBehaviour.setCircuitConfiguration(stack, finalIdx);
-                                    circuitSlot.setStackInSlot(0, stack);
-                                } else if (ConfigHolder.INSTANCE.machines.ghostCircuit) {
-                                    circuitSlot.setStackInSlot(0, IntCircuitBehaviour.stack(finalIdx));
-                                }
-                            }
-                        }));
-                idx++;
-            }
-        }
-        for (int x = 0; x <= 5; x++) {
-            int finalIdx = x + 27;
-            group.addWidget(new ButtonWidget(5 + (18 * x), 102, 18, 18,
-                    new GuiTextureGroup(GuiTextures.SLOT,
-                            new ItemStackTexture(IntCircuitBehaviour.stack(finalIdx)).scale(16f / 18)),
-                    clickData -> {
-                        if (!clickData.isRemote) {
-                            ItemStack stack = circuitSlot.getStackInSlot(0).copy();
-                            if (IntCircuitBehaviour.isIntegratedCircuit(stack)) {
-                                IntCircuitBehaviour.setCircuitConfiguration(stack, finalIdx);
-                                circuitSlot.setStackInSlot(0, stack);
-                            } else if (ConfigHolder.INSTANCE.machines.ghostCircuit) {
-                                circuitSlot.setStackInSlot(0, IntCircuitBehaviour.stack(finalIdx));
-                            }
-                        }
-                    }));
-        }
-        return group;
-    }
-
-    @Override
-    public List<Component> getTooltips() {
-        var list = new ArrayList<>(IFancyConfigurator.super.getTooltips());
-        list.addAll(Arrays.stream(
-                LangHandler.getMultiLang("gtceu.gui.configurator_slot.tooltip").toArray(new MutableComponent[0]))
-                .toList());
-        return list;
-    }
-
-    private int getNextValue(boolean increment) {
-        int currentValue = IntCircuitBehaviour.getCircuitConfiguration(circuitSlot.getStackInSlot(0));
-        if (increment) {
-            // if at max, loop around to no circuit
-            if (currentValue == IntCircuitBehaviour.CIRCUIT_MAX) {
-                return 0;
-            }
-            // if at no circuit, skip 0 and return 1
-            if (this.circuitSlot.getStackInSlot(0).isEmpty()) {
-                return 1;
-            }
-            // normal case: increment by 1
-            return currentValue + 1;
-        } else {
-            // if at no circuit, loop around to max
-            if (this.circuitSlot.getStackInSlot(0).isEmpty() ||
-                    (currentValue == 0 && !ConfigHolder.INSTANCE.machines.ghostCircuit)) {
-                return IntCircuitBehaviour.CIRCUIT_MAX;
-            }
-            // if at 1, skip 0 and return no circuit
-            if (currentValue == 1 && ConfigHolder.INSTANCE.machines.ghostCircuit) {
-                return -1;
-            }
-            // normal case: decrement by 1
-            return currentValue - 1;
-        }
-    }
-}
diff --git a/src/main/java/com/gregtechceu/gtceu/api/machine/fancyconfigurator/CombinedDirectionalFancyConfigurator.java b/src/main/java/com/gregtechceu/gtceu/api/machine/fancyconfigurator/CombinedDirectionalFancyConfigurator.java
deleted file mode 100644
index c46b0c93dad..00000000000
--- a/src/main/java/com/gregtechceu/gtceu/api/machine/fancyconfigurator/CombinedDirectionalFancyConfigurator.java
+++ /dev/null
@@ -1,110 +0,0 @@
-package com.gregtechceu.gtceu.api.machine.fancyconfigurator;
-
-import com.gregtechceu.gtceu.api.gui.GuiTextures;
-import com.gregtechceu.gtceu.api.gui.WidgetUtils;
-import com.gregtechceu.gtceu.api.gui.fancy.FancyMachineUIWidget;
-import com.gregtechceu.gtceu.api.gui.fancy.IFancyUIProvider;
-import com.gregtechceu.gtceu.api.gui.widget.directional.CombinedDirectionalConfigurator;
-import com.gregtechceu.gtceu.api.gui.widget.directional.IDirectionalConfigHandler;
-import com.gregtechceu.gtceu.api.gui.widget.directional.handlers.AutoOutputFluidConfigHandler;
-import com.gregtechceu.gtceu.api.gui.widget.directional.handlers.AutoOutputItemConfigHandler;
-import com.gregtechceu.gtceu.api.gui.widget.directional.handlers.CoverableConfigHandler;
-import com.gregtechceu.gtceu.api.machine.MetaMachine;
-import com.gregtechceu.gtceu.common.machine.trait.AutoOutputTrait;
-
-import com.lowdragmc.lowdraglib.gui.texture.IGuiTexture;
-import com.lowdragmc.lowdraglib.gui.widget.Widget;
-import com.lowdragmc.lowdraglib.utils.Size;
-
-import net.minecraft.MethodsReturnNonnullByDefault;
-import net.minecraft.network.chat.Component;
-
-import org.jetbrains.annotations.Nullable;
-
-import java.util.ArrayList;
-import java.util.List;
-import java.util.Objects;
-import java.util.function.Function;
-import java.util.function.Supplier;
-
-import javax.annotation.ParametersAreNonnullByDefault;
-
-@MethodsReturnNonnullByDefault
-@ParametersAreNonnullByDefault
-public class CombinedDirectionalFancyConfigurator implements IFancyUIProvider {
-
-    private final List<Supplier<IDirectionalConfigHandler>> configs;
-    private final MetaMachine machine;
-
-    public CombinedDirectionalFancyConfigurator(List<Supplier<IDirectionalConfigHandler>> configs,
-                                                MetaMachine machine) {
-        this.configs = configs;
-        this.machine = machine;
-    }
-
-    @Override
-    public Widget createMainPage(FancyMachineUIWidget widget) {
-        Size parentSize = widget.getSize();
-        return new CombinedDirectionalConfigurator(
-                widget, configs.stream().map(Supplier::get).toArray(IDirectionalConfigHandler[]::new), machine,
-                parentSize.width - 8,
-                parentSize.height - WidgetUtils.getInventoryHeight(true));
-    }
-
-    @Override
-    public IGuiTexture getTabIcon() {
-        return GuiTextures.TOOL_COVER_SETTINGS;
-    }
-
-    @Override
-    public Component getTitle() {
-        return Component.translatable("gtceu.gui.directional_setting.title");
-    }
-
-    @Override
-    public List<Component> getTabTooltips() {
-        List<Component> tooltip = new ArrayList<>();
-        tooltip.add(Component.translatable("gtceu.gui.directional_setting.tab_tooltip"));
-        return tooltip;
-    }
-
-    // ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-
-    private static final List<Function<MetaMachine, Supplier<IDirectionalConfigHandler>>> CONFIG_HANDLERS = new ArrayList<>();
-
-    static {
-        // Left side:
-        CONFIG_HANDLERS.add(
-                machine -> {
-                    var trait = machine.getTraitHolder().getTrait(AutoOutputTrait.TYPE);
-                    return trait != null && trait.supportsAutoOutputItems() ?
-                            () -> new AutoOutputItemConfigHandler(trait) : null;
-                });
-        CONFIG_HANDLERS.add(
-                machine -> {
-                    var trait = machine.getTraitHolder().getTrait(AutoOutputTrait.TYPE);
-                    return trait != null && trait.supportsAutoOutputFluids() ?
-                            () -> new AutoOutputFluidConfigHandler(trait) : null;
-                });
-
-        // Right side:
-        CONFIG_HANDLERS.add(machine -> () -> new CoverableConfigHandler(machine.getCoverContainer()));
-    }
-
-    /**
-     * To be used by addons for registering their own directional configurations
-     */
-    public static void registerConfigHandler(Function<MetaMachine, Supplier<IDirectionalConfigHandler>> factory) {
-        CONFIG_HANDLERS.add(factory);
-    }
-
-    @Nullable
-    public static CombinedDirectionalFancyConfigurator of(MetaMachine container, MetaMachine machine) {
-        var configs = CONFIG_HANDLERS.stream()
-                .map(handler -> handler.apply(container))
-                .filter(Objects::nonNull)
-                .toList();
-
-        return configs.isEmpty() ? null : new CombinedDirectionalFancyConfigurator(configs, machine);
-    }
-}
diff --git a/src/main/java/com/gregtechceu/gtceu/api/machine/fancyconfigurator/FancyInvConfigurator.java b/src/main/java/com/gregtechceu/gtceu/api/machine/fancyconfigurator/FancyInvConfigurator.java
deleted file mode 100644
index 9d3efb6993b..00000000000
--- a/src/main/java/com/gregtechceu/gtceu/api/machine/fancyconfigurator/FancyInvConfigurator.java
+++ /dev/null
@@ -1,68 +0,0 @@
-package com.gregtechceu.gtceu.api.machine.fancyconfigurator;
-
-import com.gregtechceu.gtceu.api.gui.GuiTextures;
-import com.gregtechceu.gtceu.api.gui.fancy.IFancyConfigurator;
-import com.gregtechceu.gtceu.api.gui.widget.SlotWidget;
-import com.gregtechceu.gtceu.api.transfer.item.CustomItemStackHandler;
-
-import com.lowdragmc.lowdraglib.gui.texture.IGuiTexture;
-import com.lowdragmc.lowdraglib.gui.widget.Widget;
-import com.lowdragmc.lowdraglib.gui.widget.WidgetGroup;
-import com.lowdragmc.lowdraglib.jei.IngredientIO;
-
-import net.minecraft.network.chat.Component;
-
-import lombok.Getter;
-import lombok.Setter;
-import lombok.experimental.Accessors;
-
-import java.util.Collections;
-import java.util.List;
-
-@Accessors(chain = true)
-public class FancyInvConfigurator implements IFancyConfigurator {
-
-    private final CustomItemStackHandler inventory;
-
-    @Getter
-    private final Component title;
-
-    @Getter
-    @Setter
-    private List<Component> tooltips = Collections.emptyList();
-
-    public FancyInvConfigurator(CustomItemStackHandler inventory, Component title) {
-        this.inventory = inventory;
-        this.title = title;
-    }
-
-    @Override
-    public IGuiTexture getIcon() {
-        return GuiTextures.BUTTON_ITEM_OUTPUT;
-    }
-
-    @Override
-    public Widget createConfigurator() {
-        int rowSize = (int) Math.sqrt(inventory.getSlots());
-        int colSize = rowSize;
-        if (inventory.getSlots() == 8) {
-            rowSize = 4;
-            colSize = 2;
-        }
-        var group = new WidgetGroup(0, 0, 18 * rowSize + 16, 18 * colSize + 16);
-        var container = new WidgetGroup(4, 4, 18 * rowSize + 8, 18 * colSize + 8);
-        int index = 0;
-        for (int y = 0; y < colSize; y++) {
-            for (int x = 0; x < rowSize; x++) {
-                container.addWidget(new SlotWidget(inventory, index++, 4 + x * 18, 4 + y * 18, true, true)
-                        .setBackgroundTexture(GuiTextures.SLOT)
-                        .setIngredientIO(IngredientIO.INPUT));
-            }
-        }
-
-        container.setBackground(GuiTextures.BACKGROUND_INVERSE);
-        group.addWidget(container);
-
-        return group;
-    }
-}
diff --git a/src/main/java/com/gregtechceu/gtceu/api/machine/fancyconfigurator/FancySelectorConfigurator.java b/src/main/java/com/gregtechceu/gtceu/api/machine/fancyconfigurator/FancySelectorConfigurator.java
deleted file mode 100644
index 5b89d526cdc..00000000000
--- a/src/main/java/com/gregtechceu/gtceu/api/machine/fancyconfigurator/FancySelectorConfigurator.java
+++ /dev/null
@@ -1,54 +0,0 @@
-package com.gregtechceu.gtceu.api.machine.fancyconfigurator;
-
-import com.gregtechceu.gtceu.api.gui.fancy.IFancyConfiguratorButton;
-import com.gregtechceu.gtceu.api.gui.widget.EnumSelectorWidget;
-
-import com.lowdragmc.lowdraglib.gui.texture.IGuiTexture;
-import com.lowdragmc.lowdraglib.gui.util.ClickData;
-
-import net.minecraft.network.chat.Component;
-
-import lombok.Setter;
-import lombok.experimental.Accessors;
-
-import java.util.Collections;
-import java.util.List;
-import java.util.function.Consumer;
-import java.util.function.Function;
-
-public class FancySelectorConfigurator<T extends Enum<T> & EnumSelectorWidget.SelectableEnum>
-                                      implements IFancyConfiguratorButton {
-
-    private final EnumSelectorWidget<T> widget;
-
-    @Setter
-    @Accessors(chain = true)
-    private Function<T, List<Component>> tooltip = t -> Collections.singletonList(Component.empty());
-
-    public FancySelectorConfigurator(T[] values, T initialValue, Consumer<T> onChanged) {
-        this.widget = new EnumSelectorWidget<>(0, 0, 20, 20, values, initialValue, onChanged);
-    }
-
-    @Override
-    public IGuiTexture getIcon() {
-        return widget.getTexture(widget.selected);
-    }
-
-    @Override
-    public List<Component> getTooltips() {
-        return this.tooltip.apply(widget.getCurrentValue());
-    }
-
-    @Override
-    public void onClick(ClickData clickData) {
-        ++widget.selected;
-        if (widget.selected >= widget.values.size()) {
-            widget.selected = 0;
-        }
-
-        widget.buttonWidget.setIndex(widget.selected);
-        if (widget.onChanged != null) {
-            widget.onChanged.accept(widget.getCurrentValue());
-        }
-    }
-}
diff --git a/src/main/java/com/gregtechceu/gtceu/api/machine/fancyconfigurator/FancyTankConfigurator.java b/src/main/java/com/gregtechceu/gtceu/api/machine/fancyconfigurator/FancyTankConfigurator.java
deleted file mode 100644
index ffde47feb4c..00000000000
--- a/src/main/java/com/gregtechceu/gtceu/api/machine/fancyconfigurator/FancyTankConfigurator.java
+++ /dev/null
@@ -1,68 +0,0 @@
-package com.gregtechceu.gtceu.api.machine.fancyconfigurator;
-
-import com.gregtechceu.gtceu.api.gui.GuiTextures;
-import com.gregtechceu.gtceu.api.gui.fancy.IFancyConfigurator;
-import com.gregtechceu.gtceu.api.gui.widget.TankWidget;
-import com.gregtechceu.gtceu.api.transfer.fluid.CustomFluidTank;
-
-import com.lowdragmc.lowdraglib.gui.texture.IGuiTexture;
-import com.lowdragmc.lowdraglib.gui.widget.Widget;
-import com.lowdragmc.lowdraglib.gui.widget.WidgetGroup;
-
-import net.minecraft.network.chat.Component;
-
-import lombok.Getter;
-import lombok.Setter;
-import lombok.experimental.Accessors;
-
-import java.util.Collections;
-import java.util.List;
-
-@Accessors(chain = true)
-public class FancyTankConfigurator implements IFancyConfigurator {
-
-    private final CustomFluidTank[] tanks;
-
-    @Getter
-    private final Component title;
-
-    @Getter
-    @Setter
-    private List<Component> tooltips = Collections.emptyList();
-
-    public FancyTankConfigurator(CustomFluidTank[] tanks, Component title) {
-        this.tanks = tanks;
-        this.title = title;
-    }
-
-    @Override
-    public IGuiTexture getIcon() {
-        return GuiTextures.BUTTON_FLUID_OUTPUT;
-    }
-
-    @Override
-    public Widget createConfigurator() {
-        int rowSize = (int) Math.sqrt(tanks.length);
-        int colSize = rowSize;
-        if (tanks.length == 8) {
-            rowSize = 4;
-            colSize = 2;
-        }
-
-        var group = new WidgetGroup(0, 0, 18 * rowSize + 16, 18 * colSize + 16);
-        var container = new WidgetGroup(4, 4, 18 * rowSize + 8, 18 * colSize + 8);
-
-        int index = 0;
-        for (int y = 0; y < colSize; y++) {
-            for (int x = 0; x < rowSize; x++) {
-                container.addWidget(new TankWidget(tanks[index++], 4 + x * 18, 4 + y * 18, true, true)
-                        .setBackground(GuiTextures.FLUID_SLOT));
-            }
-        }
-
-        container.setBackground(GuiTextures.BACKGROUND_INVERSE);
-        group.addWidget(container);
-
-        return group;
-    }
-}
diff --git a/src/main/java/com/gregtechceu/gtceu/api/machine/fancyconfigurator/MachineModeFancyConfigurator.java b/src/main/java/com/gregtechceu/gtceu/api/machine/fancyconfigurator/MachineModeFancyConfigurator.java
deleted file mode 100644
index ae205e44c95..00000000000
--- a/src/main/java/com/gregtechceu/gtceu/api/machine/fancyconfigurator/MachineModeFancyConfigurator.java
+++ /dev/null
@@ -1,102 +0,0 @@
-package com.gregtechceu.gtceu.api.machine.fancyconfigurator;
-
-import com.gregtechceu.gtceu.api.gui.GuiTextures;
-import com.gregtechceu.gtceu.api.gui.fancy.FancyMachineUIWidget;
-import com.gregtechceu.gtceu.api.gui.fancy.IFancyUIProvider;
-import com.gregtechceu.gtceu.api.machine.feature.IRecipeLogicMachine;
-import com.gregtechceu.gtceu.common.data.GTItems;
-
-import com.lowdragmc.lowdraglib.gui.editor.ColorPattern;
-import com.lowdragmc.lowdraglib.gui.texture.*;
-import com.lowdragmc.lowdraglib.gui.widget.ButtonWidget;
-import com.lowdragmc.lowdraglib.gui.widget.ImageWidget;
-import com.lowdragmc.lowdraglib.gui.widget.Widget;
-import com.lowdragmc.lowdraglib.gui.widget.WidgetGroup;
-
-import net.minecraft.network.FriendlyByteBuf;
-import net.minecraft.network.chat.Component;
-
-import java.util.ArrayList;
-import java.util.List;
-
-public class MachineModeFancyConfigurator implements IFancyUIProvider {
-
-    protected IRecipeLogicMachine machine;
-
-    public MachineModeFancyConfigurator(IRecipeLogicMachine machine) {
-        this.machine = machine;
-    }
-
-    @Override
-    public Component getTitle() {
-        return Component.translatable("gtceu.gui.machinemode.title");
-    }
-
-    @Override
-    public IGuiTexture getTabIcon() {
-        return new ItemStackTexture(GTItems.ROBOT_ARM_LV.get());
-    }
-
-    @Override
-    public Widget createMainPage(FancyMachineUIWidget widget) {
-        var group = new MachineModeConfigurator(0, 0, 140, 20 * machine.getRecipeTypes().length + 4);
-        group.setBackground(GuiTextures.BACKGROUND_INVERSE);
-        for (int i = 0; i < machine.getRecipeTypes().length; i++) {
-            int finalI = i;
-            group.addWidget(new ButtonWidget(2, 2 + i * 20, 136, 20, IGuiTexture.EMPTY,
-                    cd -> setActiveRecipeTypeAndUpdateTickSubs(finalI)));
-            group.addWidget(new ImageWidget(2, 2 + i * 20, 136, 20,
-                    () -> new GuiTextureGroup(
-                            ResourceBorderTexture.BUTTON_COMMON.copy()
-                                    .setColor(machine.getActiveRecipeType() == finalI ? ColorPattern.CYAN.color : -1),
-                            new TextTexture(machine.getRecipeTypes()[finalI].registryName.toLanguageKey()).setWidth(136)
-                                    .setType(TextTexture.TextType.ROLL))));
-
-        }
-        return group;
-    }
-
-    @Override
-    public List<Component> getTabTooltips() {
-        List<Component> tooltip = new ArrayList<>();
-        tooltip.add(Component.translatable("gtceu.gui.machinemode.tab_tooltip"));
-        return tooltip;
-    }
-
-    private void setActiveRecipeTypeAndUpdateTickSubs(int activeRecipeType) {
-        boolean needUpdateTickSubs = !machine.keepSubscribing() && activeRecipeType != machine.getActiveRecipeType();
-        machine.setActiveRecipeType(activeRecipeType);
-        if (needUpdateTickSubs) {
-            machine.getRecipeLogic().updateTickSubscription();
-        }
-    }
-
-    public class MachineModeConfigurator extends WidgetGroup {
-
-        public MachineModeConfigurator(int x, int y, int width, int height) {
-            super(x, y, width, height);
-        }
-
-        @Override
-        public void writeInitialData(FriendlyByteBuf buffer) {
-            buffer.writeVarInt(machine.getActiveRecipeType());
-        }
-
-        @Override
-        public void readInitialData(FriendlyByteBuf buffer) {
-            machine.setActiveRecipeType(buffer.readVarInt());
-        }
-
-        @Override
-        public void detectAndSendChanges() {
-            this.writeUpdateInfo(0, buf -> buf.writeVarInt(machine.getActiveRecipeType()));
-        }
-
-        @Override
-        public void readUpdateInfo(int id, FriendlyByteBuf buffer) {
-            if (id == 0) {
-                machine.setActiveRecipeType(buffer.readVarInt());
-            }
-        }
-    }
-}
diff --git a/src/main/java/com/gregtechceu/gtceu/api/machine/feature/IFancyUIMachine.java b/src/main/java/com/gregtechceu/gtceu/api/machine/feature/IFancyUIMachine.java
deleted file mode 100644
index d7dc3b46867..00000000000
--- a/src/main/java/com/gregtechceu/gtceu/api/machine/feature/IFancyUIMachine.java
+++ /dev/null
@@ -1,152 +0,0 @@
-package com.gregtechceu.gtceu.api.machine.feature;
-
-import com.gregtechceu.gtceu.api.capability.IControllable;
-import com.gregtechceu.gtceu.api.gui.GuiTextures;
-import com.gregtechceu.gtceu.api.gui.fancy.*;
-import com.gregtechceu.gtceu.api.machine.MetaMachine;
-import com.gregtechceu.gtceu.api.machine.fancyconfigurator.CombinedDirectionalFancyConfigurator;
-import com.gregtechceu.gtceu.api.machine.fancyconfigurator.MachineModeFancyConfigurator;
-
-import com.lowdragmc.lowdraglib.gui.modular.ModularUI;
-import com.lowdragmc.lowdraglib.gui.texture.IGuiTexture;
-import com.lowdragmc.lowdraglib.gui.texture.ItemStackTexture;
-import com.lowdragmc.lowdraglib.gui.widget.ImageWidget;
-import com.lowdragmc.lowdraglib.gui.widget.SceneWidget;
-import com.lowdragmc.lowdraglib.gui.widget.Widget;
-import com.lowdragmc.lowdraglib.gui.widget.WidgetGroup;
-import com.lowdragmc.lowdraglib.utils.BlockInfo;
-import com.lowdragmc.lowdraglib.utils.TrackedDummyWorld;
-
-import net.minecraft.client.gui.GuiGraphics;
-import net.minecraft.core.BlockPos;
-import net.minecraft.core.Direction;
-import net.minecraft.network.chat.Component;
-import net.minecraft.world.entity.player.Player;
-import net.minecraftforge.api.distmarker.Dist;
-import net.minecraftforge.api.distmarker.OnlyIn;
-
-import org.jetbrains.annotations.NotNull;
-
-import java.util.ArrayList;
-import java.util.List;
-
-public interface IFancyUIMachine extends IUIMachine, IFancyUIProvider {
-
-    @Override
-    default ModularUI createUI(Player entityPlayer) {
-        return new ModularUI(176, 166, this, entityPlayer).widget(new FancyMachineUIWidget(this, 176, 166));
-    }
-
-    /**
-     * We should not override this method in general, and use {@link IFancyUIMachine#createUIWidget()} instead,
-     */
-    @Override
-    default Widget createMainPage(FancyMachineUIWidget widget) {
-        var editableUI = self().getDefinition().getEditableUI();
-        if (editableUI != null) {
-            var template = editableUI.createCustomUI();
-            if (template == null) {
-                template = editableUI.createDefault();
-            }
-            editableUI.setupUI(template, self());
-            return template;
-        }
-        return createUIWidget();
-    }
-
-    /**
-     * Create the core widget of this machine.
-     */
-    default Widget createUIWidget() {
-        var group = new WidgetGroup(0, 0, 100, 100);
-        if (isRemote()) {
-            group.addWidget(new ImageWidget((100 - 48) / 2, 60, 48, 16, GuiTextures.SCENE));
-            TrackedDummyWorld world = new TrackedDummyWorld();
-            world.addBlock(BlockPos.ZERO, BlockInfo.fromBlockState(self().getBlockState()));
-            SceneWidget sceneWidget = new SceneWidget(0, 0, 100, 100, world) {
-
-                @Override
-                @OnlyIn(Dist.CLIENT)
-                public void drawInBackground(@NotNull GuiGraphics graphics, int mouseX, int mouseY,
-                                             float partialTicks) {
-                    // AUTO ROTATION
-                    if (renderer != null) {
-                        this.rotationPitch = (partialTicks + getGui().getTickCount()) * 2;
-                        renderer.setCameraLookAt(this.center, 0.1f, Math.toRadians(this.rotationPitch),
-                                Math.toRadians(this.rotationYaw));
-                    }
-                    super.drawInBackground(graphics, mouseX, mouseY, partialTicks);
-                }
-            };
-            sceneWidget.useOrtho(true)
-                    .setOrthoRange(0.5f)
-                    .setScalable(false)
-                    .setDraggable(false)
-                    .setRenderFacing(false)
-                    .setRenderSelect(false);
-            sceneWidget.getRenderer().setFov(30);
-            group.addWidget(sceneWidget);
-            sceneWidget.setRenderedCore(List.of(BlockPos.ZERO), null);
-        }
-        return group;
-    }
-
-    @Override
-    default IGuiTexture getTabIcon() {
-        return new ItemStackTexture(self().getDefinition().getItem());
-    }
-
-    @Override
-    default void attachSideTabs(TabsWidget sideTabs) {
-        sideTabs.setMainTab(this);
-
-        if (this instanceof IRecipeLogicMachine rLMachine && rLMachine.getRecipeTypes().length > 1) {
-            sideTabs.attachSubTab(new MachineModeFancyConfigurator(rLMachine));
-        }
-        var directionalConfigurator = CombinedDirectionalFancyConfigurator.of(self(), self());
-        if (directionalConfigurator != null)
-            sideTabs.attachSubTab(directionalConfigurator);
-    }
-
-    @Override
-    default void attachConfigurators(ConfiguratorPanel configuratorPanel) {
-        if (this instanceof IControllable controllable) {
-            configuratorPanel.attachConfigurators(new IFancyConfiguratorButton.Toggle(
-                    GuiTextures.BUTTON_POWER.getSubTexture(0, 0, 1, 0.5),
-                    GuiTextures.BUTTON_POWER.getSubTexture(0, 0.5, 1, 0.5),
-                    controllable::isWorkingEnabled, (clickData, pressed) -> controllable.setWorkingEnabled(pressed))
-                    .setTooltipsSupplier(pressed -> List.of(
-                            Component.translatable(
-                                    pressed ? "behaviour.soft_hammer.enabled" : "behaviour.soft_hammer.disabled"))));
-        }
-        if (this instanceof MetaMachine machine) {
-            for (var direction : Direction.values()) {
-                if (machine.getCoverContainer().hasCover(direction)) {
-                    var configurator = machine.getCoverContainer().getCoverAtSide(direction).getConfigurator();
-                    if (configurator != null)
-                        configuratorPanel.attachConfigurators(configurator);
-                }
-            }
-        }
-    }
-
-    @Override
-    default void attachTooltips(TooltipsPanel tooltipsPanel) {
-        tooltipsPanel.attachTooltips(self());
-        self().getTraitHolder().getAllTraits().stream().filter(IFancyTooltip.class::isInstance)
-                .map(IFancyTooltip.class::cast)
-                .forEach(tooltipsPanel::attachTooltips);
-    }
-
-    @Override
-    default List<Component> getTabTooltips() {
-        var list = new ArrayList<Component>();
-        list.add(Component.translatable(self().getDefinition().getDescriptionId()));
-        return list;
-    }
-
-    @Override
-    default Component getTitle() {
-        return Component.translatable(self().getDefinition().getDescriptionId());
-    }
-}
diff --git a/src/main/java/com/gregtechceu/gtceu/api/machine/feature/IHasBatterySlot.java b/src/main/java/com/gregtechceu/gtceu/api/machine/feature/IHasBatterySlot.java
new file mode 100644
index 00000000000..9ff7e106831
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/api/machine/feature/IHasBatterySlot.java
@@ -0,0 +1,8 @@
+package com.gregtechceu.gtceu.api.machine.feature;
+
+import com.gregtechceu.gtceu.api.transfer.item.CustomItemStackHandler;
+
+public interface IHasBatterySlot extends IMachineFeature {
+
+    CustomItemStackHandler getChargerInventory();
+}
diff --git a/src/main/java/com/gregtechceu/gtceu/api/machine/feature/IMuiMachine.java b/src/main/java/com/gregtechceu/gtceu/api/machine/feature/IMuiMachine.java
new file mode 100644
index 00000000000..89bbf9ec13a
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/api/machine/feature/IMuiMachine.java
@@ -0,0 +1,59 @@
+package com.gregtechceu.gtceu.api.machine.feature;
+
+import com.gregtechceu.gtceu.api.machine.mui.MachineUIPanelBuilder;
+import com.gregtechceu.gtceu.api.mui.GTGuiScreen;
+import com.gregtechceu.gtceu.api.mui.factory.MachineUIFactory;
+
+import net.minecraft.server.level.ServerPlayer;
+import net.minecraft.world.InteractionHand;
+import net.minecraft.world.InteractionResult;
+import net.minecraft.world.entity.player.Player;
+import net.minecraft.world.phys.BlockHitResult;
+import net.minecraftforge.api.distmarker.Dist;
+import net.minecraftforge.api.distmarker.OnlyIn;
+
+import brachy.modularui.api.IUIHolder;
+import brachy.modularui.factory.PosGuiData;
+import brachy.modularui.screen.ModularPanel;
+import brachy.modularui.screen.ModularScreen;
+import brachy.modularui.screen.UISettings;
+import brachy.modularui.value.sync.PanelSyncManager;
+import brachy.modularui.widget.ParentWidget;
+
+public interface IMuiMachine extends IUIHolder<PosGuiData>, IMachineFeature {
+
+    @Override
+    default ModularPanel<?> buildUI(PosGuiData data, PanelSyncManager syncManager, UISettings settings) {
+        var panelBuilder = getPanelBuilder(data, syncManager, settings);
+        panelBuilder.mainContents(parent -> buildMainUI(parent, data, syncManager, settings));
+        return panelBuilder.build(syncManager, settings);
+    }
+
+    default MachineUIPanelBuilder getPanelBuilder(PosGuiData data, PanelSyncManager syncManager, UISettings settings) {
+        return MachineUIPanelBuilder.defaultPanelBuilder(self());
+    }
+
+    default void buildMainUI(ParentWidget<?> mainWidget, PosGuiData guiData, PanelSyncManager syncManager,
+                             UISettings settings) {}
+
+    default boolean shouldOpenUI(Player player, InteractionHand hand, BlockHitResult hit) {
+        return true;
+    }
+
+    @Override
+    @OnlyIn(Dist.CLIENT)
+    default ModularScreen createScreen(PosGuiData data, ModularPanel<?> mainPanel) {
+        return new GTGuiScreen(mainPanel);
+    }
+
+    default InteractionResult tryToOpenUI(Player player, InteractionHand hand, BlockHitResult hit) {
+        if (this.shouldOpenUI(player, hand, hit)) {
+            if (player instanceof ServerPlayer serverPlayer) {
+                MachineUIFactory.INSTANCE.open(serverPlayer, this);
+            }
+            return InteractionResult.sidedSuccess(player.level().isClientSide);
+        } else {
+            return InteractionResult.PASS;
+        }
+    }
+}
diff --git a/src/main/java/com/gregtechceu/gtceu/api/machine/feature/IUIMachine.java b/src/main/java/com/gregtechceu/gtceu/api/machine/feature/IUIMachine.java
deleted file mode 100644
index 074723db931..00000000000
--- a/src/main/java/com/gregtechceu/gtceu/api/machine/feature/IUIMachine.java
+++ /dev/null
@@ -1,45 +0,0 @@
-package com.gregtechceu.gtceu.api.machine.feature;
-
-import com.gregtechceu.gtceu.api.gui.factory.MachineUIFactory;
-
-import com.lowdragmc.lowdraglib.gui.modular.IUIHolder;
-
-import net.minecraft.server.level.ServerPlayer;
-import net.minecraft.world.InteractionHand;
-import net.minecraft.world.InteractionResult;
-import net.minecraft.world.entity.player.Player;
-import net.minecraft.world.phys.BlockHitResult;
-
-/**
- * A machine that has gui. can be opened via right click.
- */
-public interface IUIMachine extends IUIHolder, IMachineFeature {
-
-    default boolean shouldOpenUI(Player player, InteractionHand hand, BlockHitResult hit) {
-        return true;
-    }
-
-    default InteractionResult tryToOpenUI(Player player, InteractionHand hand, BlockHitResult hit) {
-        if (this.shouldOpenUI(player, hand, hit)) {
-            if (player instanceof ServerPlayer serverPlayer) {
-                MachineUIFactory.INSTANCE.openUI(self(), serverPlayer);
-            }
-        } else {
-            return InteractionResult.PASS;
-        }
-        return InteractionResult.sidedSuccess(player.level().isClientSide);
-    }
-
-    @Override
-    default boolean isInvalid() {
-        return self().isRemoved();
-    }
-
-    @Override
-    default boolean isRemote() {
-        return self().isRemote();
-    }
-
-    @Override
-    default void markAsDirty() {};
-}
diff --git a/src/main/java/com/gregtechceu/gtceu/api/machine/feature/IVoidable.java b/src/main/java/com/gregtechceu/gtceu/api/machine/feature/IVoidable.java
index 72e6f1941ef..2b77a95e04a 100644
--- a/src/main/java/com/gregtechceu/gtceu/api/machine/feature/IVoidable.java
+++ b/src/main/java/com/gregtechceu/gtceu/api/machine/feature/IVoidable.java
@@ -3,21 +3,13 @@
 import com.gregtechceu.gtceu.api.capability.recipe.FluidRecipeCapability;
 import com.gregtechceu.gtceu.api.capability.recipe.ItemRecipeCapability;
 import com.gregtechceu.gtceu.api.capability.recipe.RecipeCapability;
-import com.gregtechceu.gtceu.api.gui.GuiTextures;
-import com.gregtechceu.gtceu.api.gui.fancy.ConfiguratorPanel;
-import com.gregtechceu.gtceu.api.gui.widget.EnumSelectorWidget;
-import com.gregtechceu.gtceu.api.machine.fancyconfigurator.FancySelectorConfigurator;
 
-import com.lowdragmc.lowdraglib.gui.texture.IGuiTexture;
-
-import net.minecraft.network.chat.Component;
 import net.minecraft.util.StringRepresentable;
 
 import it.unimi.dsi.fastutil.objects.Reference2IntMap;
 import lombok.Getter;
 import org.jetbrains.annotations.NotNull;
 
-import java.util.List;
 import java.util.function.Predicate;
 
 public interface IVoidable extends IMachineFeature {
@@ -37,15 +29,7 @@ default VoidingMode getVoidingMode() {
         return VoidingMode.VOID_NONE;
     }
 
-    static void attachConfigurators(ConfiguratorPanel configuratorPanel, IVoidable controller) {
-        configuratorPanel
-                .attachConfigurators(new FancySelectorConfigurator<>(VoidingMode.VALUES, controller.getVoidingMode(),
-                        controller::setVoidingMode)
-                        .setTooltip(m -> List.of(Component.translatable("gtceu.gui.multiblock.voiding_mode"),
-                                Component.translatable(m.localeName))));
-    }
-
-    enum VoidingMode implements StringRepresentable, EnumSelectorWidget.SelectableEnum {
+    enum VoidingMode implements StringRepresentable {
 
         VOID_NONE("gtceu.gui.no_voiding", cap -> false),
         VOID_ITEMS("gtceu.gui.item_voiding", cap -> cap == ItemRecipeCapability.CAP),
@@ -55,30 +39,22 @@ enum VoidingMode implements StringRepresentable, EnumSelectorWidget.SelectableEn
 
         public static final VoidingMode[] VALUES = values();
 
-        private final String localeName;
         @Getter
-        private final IGuiTexture icon;
+        private final String tooltip;
         private final Predicate<RecipeCapability<?>> canVoid;
 
         VoidingMode(String name, Predicate<RecipeCapability<?>> canVoid) {
-            this.localeName = name;
+            this.tooltip = name;
             this.canVoid = canVoid;
-            this.icon = GuiTextures.BUTTON_VOID_MULTIBLOCK.getSubTexture(0, ordinal() * 0.25, 1, 0.25);
         }
 
         public boolean canVoid(RecipeCapability<?> capability) {
             return canVoid.test(capability);
         }
 
-        @NotNull
-        @Override
-        public String getSerializedName() {
-            return localeName;
-        }
-
         @Override
-        public @NotNull String getTooltip() {
-            return localeName;
+        public @NotNull String getSerializedName() {
+            return tooltip;
         }
     }
 }
diff --git a/src/main/java/com/gregtechceu/gtceu/api/machine/feature/multiblock/IDisplayUIMachine.java b/src/main/java/com/gregtechceu/gtceu/api/machine/feature/multiblock/IDisplayUIMachine.java
deleted file mode 100644
index d6bfdb6b5fa..00000000000
--- a/src/main/java/com/gregtechceu/gtceu/api/machine/feature/multiblock/IDisplayUIMachine.java
+++ /dev/null
@@ -1,52 +0,0 @@
-package com.gregtechceu.gtceu.api.machine.feature.multiblock;
-
-import com.gregtechceu.gtceu.api.gui.GuiTextures;
-import com.gregtechceu.gtceu.api.gui.UITemplate;
-import com.gregtechceu.gtceu.api.machine.feature.IUIMachine;
-import com.gregtechceu.gtceu.api.machine.multiblock.MultiblockControllerMachine;
-
-import com.lowdragmc.lowdraglib.gui.modular.ModularUI;
-import com.lowdragmc.lowdraglib.gui.texture.IGuiTexture;
-import com.lowdragmc.lowdraglib.gui.util.ClickData;
-import com.lowdragmc.lowdraglib.gui.widget.ComponentPanelWidget;
-import com.lowdragmc.lowdraglib.gui.widget.DraggableScrollableWidgetGroup;
-import com.lowdragmc.lowdraglib.gui.widget.LabelWidget;
-
-import net.minecraft.network.chat.Component;
-import net.minecraft.world.entity.player.Player;
-
-import java.util.List;
-
-public interface IDisplayUIMachine extends IUIMachine {
-
-    default void addDisplayText(List<Component> textList) {
-        for (var part : self().getParts()) {
-            part.addMultiText(textList);
-        }
-    }
-
-    default void handleDisplayClick(String componentData, ClickData clickData) {}
-
-    default IGuiTexture getScreenTexture() {
-        return GuiTextures.DISPLAY;
-    }
-
-    @Override
-    default ModularUI createUI(Player entityPlayer) {
-        var screen = new DraggableScrollableWidgetGroup(7, 4, 162, 121).setBackground(getScreenTexture());
-        screen.addWidget(new LabelWidget(4, 5, self().getBlockState().getBlock().getDescriptionId()));
-        screen.addWidget(new ComponentPanelWidget(4, 17, this::addDisplayText)
-                .textSupplier(this.self().getLevel().isClientSide ? null : this::addDisplayText)
-                .setMaxWidthLimit(150)
-                .clickHandler(this::handleDisplayClick));
-        return new ModularUI(176, 216, this, entityPlayer)
-                .background(GuiTextures.BACKGROUND)
-                .widget(screen)
-                .widget(UITemplate.bindPlayerInventory(entityPlayer.getInventory(), GuiTextures.SLOT, 7, 134, true));
-    }
-
-    @Override
-    default MultiblockControllerMachine self() {
-        return (MultiblockControllerMachine) this;
-    }
-}
diff --git a/src/main/java/com/gregtechceu/gtceu/api/machine/feature/multiblock/IDistinctPart.java b/src/main/java/com/gregtechceu/gtceu/api/machine/feature/multiblock/IDistinctPart.java
index 1c1947d7ed3..06e4d1d7566 100644
--- a/src/main/java/com/gregtechceu/gtceu/api/machine/feature/multiblock/IDistinctPart.java
+++ b/src/main/java/com/gregtechceu/gtceu/api/machine/feature/multiblock/IDistinctPart.java
@@ -1,36 +1,8 @@
 package com.gregtechceu.gtceu.api.machine.feature.multiblock;
 
-import com.gregtechceu.gtceu.api.gui.GuiTextures;
-import com.gregtechceu.gtceu.api.gui.fancy.ConfiguratorPanel;
-import com.gregtechceu.gtceu.api.gui.fancy.IFancyConfiguratorButton;
-
-import net.minecraft.ChatFormatting;
-import net.minecraft.network.chat.Component;
-import net.minecraft.network.chat.Style;
-
-import java.util.List;
-
 public interface IDistinctPart extends IMultiPart {
 
     boolean isDistinct();
 
     void setDistinct(boolean isDistinct);
-
-    @Override
-    default void attachConfigurators(ConfiguratorPanel configuratorPanel) {
-        superAttachConfigurators(configuratorPanel);
-        configuratorPanel.attachConfigurators(new IFancyConfiguratorButton.Toggle(
-                GuiTextures.BUTTON_DISTINCT_BUSES.getSubTexture(0, 0.5, 1, 0.5),
-                GuiTextures.BUTTON_DISTINCT_BUSES.getSubTexture(0, 0, 1, 0.5),
-                this::isDistinct, (clickData, pressed) -> setDistinct(pressed))
-                .setTooltipsSupplier(pressed -> List.of(
-                        Component.translatable("gtceu.multiblock.universal.distinct")
-                                .setStyle(Style.EMPTY.withColor(ChatFormatting.YELLOW))
-                                .append(Component.translatable(pressed ? "gtceu.multiblock.universal.distinct.yes" :
-                                        "gtceu.multiblock.universal.distinct.no")))));
-    }
-
-    default void superAttachConfigurators(ConfiguratorPanel configuratorPanel) {
-        IMultiPart.super.attachConfigurators(configuratorPanel);
-    }
 }
diff --git a/src/main/java/com/gregtechceu/gtceu/api/machine/feature/multiblock/IMaintenanceMachine.java b/src/main/java/com/gregtechceu/gtceu/api/machine/feature/multiblock/IMaintenanceMachine.java
index 3216cc9850e..81fb6fbd40b 100644
--- a/src/main/java/com/gregtechceu/gtceu/api/machine/feature/multiblock/IMaintenanceMachine.java
+++ b/src/main/java/com/gregtechceu/gtceu/api/machine/feature/multiblock/IMaintenanceMachine.java
@@ -1,21 +1,12 @@
 package com.gregtechceu.gtceu.api.machine.feature.multiblock;
 
 import com.gregtechceu.gtceu.api.GTValues;
-import com.gregtechceu.gtceu.api.gui.GuiTextures;
-import com.gregtechceu.gtceu.api.gui.fancy.IFancyTooltip;
-import com.gregtechceu.gtceu.api.gui.fancy.TooltipsPanel;
-import com.gregtechceu.gtceu.api.machine.multiblock.MultiblockControllerMachine;
 import com.gregtechceu.gtceu.api.machine.property.GTMachineModelProperties;
 import com.gregtechceu.gtceu.api.recipe.GTRecipe;
 import com.gregtechceu.gtceu.config.ConfigHolder;
 
-import net.minecraft.ChatFormatting;
-import net.minecraft.network.chat.Component;
-import net.minecraft.network.chat.Style;
 import net.minecraft.world.level.block.state.properties.BooleanProperty;
 
-import java.util.ArrayList;
-
 public interface IMaintenanceMachine extends IMultiPart {
 
     BooleanProperty MAINTENANCE_TAPED_PROPERTY = GTMachineModelProperties.IS_TAPED;
@@ -153,39 +144,43 @@ default GTRecipe modifyRecipe(GTRecipe recipe) {
     // ******* FANCY GUI ********//
     //////////////////////////////////////
 
-    @Override
-    default void attachFancyTooltipsToController(MultiblockControllerMachine controller, TooltipsPanel tooltipsPanel) {
-        attachTooltips(tooltipsPanel);
-    }
-
-    @Override
-    default void attachTooltips(TooltipsPanel tooltipsPanel) {
-        if (ConfigHolder.INSTANCE.machines.enableMaintenance) {
-            tooltipsPanel.attachTooltips(new IFancyTooltip.Basic(() -> GuiTextures.MAINTENANCE_ICON, () -> {
-                var tooltips = new ArrayList<Component>();
-                tooltips.add(Component.translatable("gtceu.multiblock.universal.has_problems_header")
-                        .setStyle(Style.EMPTY.withColor(ChatFormatting.RED)));
-
-                if ((getMaintenanceProblems() & 1) == 0)
-                    tooltips.add(Component.translatable("gtceu.multiblock.universal.problem.wrench"));
-
-                if (((getMaintenanceProblems() >> 1) & 1) == 0)
-                    tooltips.add(Component.translatable("gtceu.multiblock.universal.problem.screwdriver"));
-
-                if (((getMaintenanceProblems() >> 2) & 1) == 0)
-                    tooltips.add(Component.translatable("gtceu.multiblock.universal.problem.soft_mallet"));
-
-                if (((getMaintenanceProblems() >> 3) & 1) == 0)
-                    tooltips.add(Component.translatable("gtceu.multiblock.universal.problem.hard_hammer"));
-
-                if (((getMaintenanceProblems() >> 4) & 1) == 0)
-                    tooltips.add(Component.translatable("gtceu.multiblock.universal.problem.wire_cutter"));
-
-                if (((getMaintenanceProblems() >> 5) & 1) == 0)
-                    tooltips.add(Component.translatable("gtceu.multiblock.universal.problem.crowbar"));
+    /*
+     * @Override
+     * default void attachFancyTooltipsToController(IMultiController controller, TooltipsPanel tooltipsPanel) {
+     * attachTooltips(tooltipsPanel);
+     * }
+     */
 
-                return tooltips;
-            }, this::hasMaintenanceProblems, () -> null));
-        }
-    }
+    /*
+     * @Override
+     * default void attachTooltips(TooltipsPanel tooltipsPanel) {
+     * if (ConfigHolder.INSTANCE.machines.enableMaintenance) {
+     * tooltipsPanel.attachTooltips(new IFancyTooltip.Basic(() -> GuiTextures.MAINTENANCE_ICON, () -> {
+     * var tooltips = new ArrayList<Component>();
+     * tooltips.add(Component.translatable("gtceu.multiblock.universal.has_problems_header")
+     * .setStyle(Style.EMPTY.withColor(ChatFormatting.RED)));
+     *
+     * if ((getMaintenanceProblems() & 1) == 0)
+     * tooltips.add(Component.translatable("gtceu.multiblock.universal.problem.wrench"));
+     *
+     * if (((getMaintenanceProblems() >> 1) & 1) == 0)
+     * tooltips.add(Component.translatable("gtceu.multiblock.universal.problem.screwdriver"));
+     *
+     * if (((getMaintenanceProblems() >> 2) & 1) == 0)
+     * tooltips.add(Component.translatable("gtceu.multiblock.universal.problem.soft_mallet"));
+     *
+     * if (((getMaintenanceProblems() >> 3) & 1) == 0)
+     * tooltips.add(Component.translatable("gtceu.multiblock.universal.problem.hard_hammer"));
+     *
+     * if (((getMaintenanceProblems() >> 4) & 1) == 0)
+     * tooltips.add(Component.translatable("gtceu.multiblock.universal.problem.wire_cutter"));
+     *
+     * if (((getMaintenanceProblems() >> 5) & 1) == 0)
+     * tooltips.add(Component.translatable("gtceu.multiblock.universal.problem.crowbar"));
+     *
+     * return tooltips;
+     * }, this::hasMaintenanceProblems, () -> null));
+     * }
+     * }
+     */
 }
diff --git a/src/main/java/com/gregtechceu/gtceu/api/machine/feature/multiblock/IMultiPart.java b/src/main/java/com/gregtechceu/gtceu/api/machine/feature/multiblock/IMultiPart.java
index ec75796b409..1fa24b84022 100644
--- a/src/main/java/com/gregtechceu/gtceu/api/machine/feature/multiblock/IMultiPart.java
+++ b/src/main/java/com/gregtechceu/gtceu/api/machine/feature/multiblock/IMultiPart.java
@@ -1,9 +1,8 @@
 package com.gregtechceu.gtceu.api.machine.feature.multiblock;
 
-import com.gregtechceu.gtceu.api.gui.fancy.TooltipsPanel;
 import com.gregtechceu.gtceu.api.machine.MetaMachine;
-import com.gregtechceu.gtceu.api.machine.feature.IFancyUIMachine;
 import com.gregtechceu.gtceu.api.machine.feature.IMachineFeature;
+import com.gregtechceu.gtceu.api.machine.feature.IMuiMachine;
 import com.gregtechceu.gtceu.api.machine.multiblock.MultiblockControllerMachine;
 import com.gregtechceu.gtceu.api.machine.multiblock.WorkableMultiblockMachine;
 import com.gregtechceu.gtceu.api.machine.trait.RecipeHandlerList;
@@ -12,7 +11,6 @@
 
 import net.minecraft.core.BlockPos;
 import net.minecraft.core.Direction;
-import net.minecraft.network.chat.Component;
 import net.minecraft.world.level.BlockAndTintGetter;
 import net.minecraft.world.level.block.state.BlockState;
 
@@ -22,7 +20,7 @@
 import java.util.List;
 import java.util.SortedSet;
 
-public interface IMultiPart extends IMachineFeature, IFancyUIMachine {
+public interface IMultiPart extends IMachineFeature, IMuiMachine {
 
     /**
      * @return If this multi part can be shared between multiple multiblocks.
@@ -33,7 +31,7 @@ default boolean canShared() {
 
     /**
      * If this multi part belongs to a controller at the given position
-     * 
+     *
      * @param controllerPos Controller position
      * @return If this multi part belongs to a controller at the given position
      */
@@ -54,14 +52,14 @@ default boolean canShared() {
 
     /**
      * Called when this part is removed from a multiblock.
-     * 
+     *
      * @param controller The controller which this part has been removed from.
      */
     void removedFromController(MultiblockControllerMachine controller);
 
     /**
      * Called when this part is added to a multiblock.
-     * 
+     *
      * @param controller The controller which this part has been added to
      */
     void addedToController(MultiblockControllerMachine controller);
@@ -80,7 +78,7 @@ default boolean replacePartModelWhenFormed() {
 
     /**
      * Called to get block appearance when this multi part is in a formed multiblock.
-     * 
+     *
      * @see MetaMachine#getBlockAppearance(BlockState, BlockAndTintGetter, BlockPos, Direction, BlockState, BlockPos)
      */
     @Nullable
@@ -137,16 +135,4 @@ default boolean beforeWorking(IWorkableMultiController controller) {
     default GTRecipe modifyRecipe(GTRecipe recipe) {
         return recipe;
     }
-
-    /**
-     * Add text to the multiblock's screen.
-     * 
-     * @param textList the text list to add to.
-     */
-    default void addMultiText(List<Component> textList) {}
-
-    /**
-     * Attach part's tooltips to the controller.
-     */
-    default void attachFancyTooltipsToController(MultiblockControllerMachine controller, TooltipsPanel tooltipsPanel) {}
 }
diff --git a/src/main/java/com/gregtechceu/gtceu/api/machine/feature/multiblock/IRotorHolderMachine.java b/src/main/java/com/gregtechceu/gtceu/api/machine/feature/multiblock/IRotorHolderMachine.java
new file mode 100644
index 00000000000..8b137891791
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/api/machine/feature/multiblock/IRotorHolderMachine.java
@@ -0,0 +1 @@
+
diff --git a/src/main/java/com/gregtechceu/gtceu/api/machine/mui/MachineUIPanel.java b/src/main/java/com/gregtechceu/gtceu/api/machine/mui/MachineUIPanel.java
new file mode 100644
index 00000000000..beb944f924a
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/api/machine/mui/MachineUIPanel.java
@@ -0,0 +1,88 @@
+package com.gregtechceu.gtceu.api.machine.mui;
+
+import com.gregtechceu.gtceu.api.machine.MetaMachine;
+import com.gregtechceu.gtceu.common.mui.GTGuiTextures;
+import com.gregtechceu.gtceu.common.mui.GTMuiWidgets;
+
+import brachy.modularui.api.drawable.IDrawable;
+import brachy.modularui.drawable.UITexture;
+import brachy.modularui.screen.ModularPanel;
+import brachy.modularui.screen.UISettings;
+import brachy.modularui.theme.ThemeAPI;
+import brachy.modularui.utils.Alignment;
+import brachy.modularui.widget.ParentWidget;
+import brachy.modularui.widgets.SlotGroupWidget;
+import brachy.modularui.widgets.layout.Flow;
+import lombok.Getter;
+
+public class MachineUIPanel extends ModularPanel<MachineUIPanel> {
+
+    public static final int DEFAULT_CONTENT_WIDTH = 169;
+    public static final int DEFAULT_CONTENT_HEIGHT = 77;
+
+    @Getter
+    protected final Flow leftConfiguratorPanel, rightConfiguratorPanel;
+    @Getter
+    protected final ParentWidget<?> mainContents;
+
+    public MachineUIPanel(MetaMachine machine, UISettings settings, boolean attachPlayerInventory,
+                          boolean addTitleBar, boolean drawGTLogo, UITexture gtLogoTexture) {
+        super(machine.getDefinition().getId().getPath());
+
+        UITexture themeBackground = (UITexture) ThemeAPI.INSTANCE.getTheme(settings.getTheme()).getPanelTheme()
+                .theme().getBackground();
+        if (themeBackground == null) themeBackground = GTGuiTextures.BACKGROUND;
+        leftConfiguratorPanel = Flow.col()
+                .coverChildren()
+                .rightRel(1.0f)
+                .reverseLayout(true)
+                .padding(4, 2, 4, 4)
+                .bottom(16)
+                .crossAxisAlignment(Alignment.CrossAxis.CENTER)
+                .childPadding(2)
+                .excludeAreaInRecipeViewer()
+                .background(themeBackground.getSubArea(0f, 0f, 0.75f, 1.0f))
+                .setEnabledIf(f -> !f.getChildren().isEmpty())
+                .decoration();
+
+        rightConfiguratorPanel = Flow.col()
+                .coverChildren()
+                .leftRel(1.0f)
+                .reverseLayout(true)
+                .padding(2, 4, 4, 4)
+                .bottom(16)
+                .crossAxisAlignment(Alignment.CrossAxis.CENTER)
+                .childPadding(2)
+                .excludeAreaInRecipeViewer()
+                .background(themeBackground.getSubArea(0.25f, 0f, 1.0f, 1.0f))
+                .setEnabledIf(f -> !f.getChildren().isEmpty())
+                .decoration();
+
+        Flow panelContents = Flow.col().coverChildren();
+        panelContents.margin(4);
+        mainContents = new ParentWidget<>().coverChildren(DEFAULT_CONTENT_WIDTH, DEFAULT_CONTENT_HEIGHT);
+
+        panelContents.child(mainContents);
+
+        if (attachPlayerInventory) {
+            var inventory = SlotGroupWidget.playerInventory((index, slot) -> slot)
+                    .marginTop(1)
+                    .marginBottom(3);
+            panelContents.child(inventory);
+        }
+
+        if (addTitleBar) {
+            child(GTMuiWidgets.createTitleBar(machine.getDefinition(), 172).decoration());
+        }
+
+        if (drawGTLogo) {
+            child(new IDrawable.DrawableWidget(gtLogoTexture)
+                    .right(7).bottom(7 + (attachPlayerInventory ? 78 : 0)).decoration());
+        }
+
+        child(leftConfiguratorPanel);
+        child(rightConfiguratorPanel);
+        child(panelContents);
+        coverChildren();
+    }
+}
diff --git a/src/main/java/com/gregtechceu/gtceu/api/machine/mui/MachineUIPanelBuilder.java b/src/main/java/com/gregtechceu/gtceu/api/machine/mui/MachineUIPanelBuilder.java
new file mode 100644
index 00000000000..281b261be04
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/api/machine/mui/MachineUIPanelBuilder.java
@@ -0,0 +1,113 @@
+package com.gregtechceu.gtceu.api.machine.mui;
+
+import com.gregtechceu.gtceu.api.capability.IControllable;
+import com.gregtechceu.gtceu.api.machine.MetaMachine;
+import com.gregtechceu.gtceu.api.machine.feature.IHasBatterySlot;
+import com.gregtechceu.gtceu.api.machine.feature.IHasCircuitSlot;
+import com.gregtechceu.gtceu.api.machine.feature.IVoidable;
+import com.gregtechceu.gtceu.api.machine.feature.multiblock.IDistinctPart;
+import com.gregtechceu.gtceu.api.machine.trait.feature.IAttachConfiguratorsTrait;
+import com.gregtechceu.gtceu.common.mui.GTGuiTextures;
+import com.gregtechceu.gtceu.common.mui.GTMuiWidgets;
+
+import brachy.modularui.drawable.UITexture;
+import brachy.modularui.screen.UISettings;
+import brachy.modularui.value.sync.PanelSyncManager;
+import brachy.modularui.widget.ParentWidget;
+import brachy.modularui.widgets.layout.Flow;
+import lombok.Setter;
+import lombok.experimental.Accessors;
+
+import java.util.function.Consumer;
+
+@Accessors(fluent = true)
+@Setter
+public class MachineUIPanelBuilder {
+
+    /**
+     * Should the GregTech logo be drawn in the bottom right corner of the panel.
+     */
+    private boolean drawGTLogo = false;
+    private UITexture gtLogoTexture = GTGuiTextures.GREGTECH_LOGO;
+    /**
+     * Should the player inventory be attached to the bottom of the panel.
+     */
+    private boolean attachInventory = true;
+    /**
+     * Should a fancy title bar be created for this panel.
+     */
+    private boolean addTitleBar = true;
+    /**
+     * If machine traits should be allowed to attach configurators to the sides of the panel.
+     */
+    private boolean addTraitConfigurators = true;
+    /**
+     * If the default configurators (circuit slot, battery slot, power button) should be added to this machine, provided
+     * the machine supports them.
+     */
+    private boolean addDefaultConfigurators = true;
+    private final MetaMachine machine;
+
+    private Consumer<Flow> leftConfigurators = (f) -> {};
+    private Consumer<Flow> rightConfigurators = (f) -> {};
+    private Consumer<ParentWidget<?>> mainContents = (p) -> {};
+
+    protected MachineUIPanelBuilder(MetaMachine machine) {
+        this.machine = machine;
+    }
+
+    public MachineUIPanel build(PanelSyncManager syncManager, UISettings settings) {
+        var panel = new MachineUIPanel(machine, settings, attachInventory, addTitleBar, drawGTLogo, gtLogoTexture);
+
+        var attachLeft = panel.getLeftConfiguratorPanel();
+        var attachRight = panel.getRightConfiguratorPanel();
+        var attachMain = panel.getMainContents();
+
+        if (addDefaultConfigurators) {
+            if (machine instanceof IHasCircuitSlot circuitSlot && circuitSlot.isCircuitSlotEnabled()) {
+                attachLeft.child(GTMuiWidgets.createCircuitSlotPanel(circuitSlot, panel, syncManager));
+            }
+
+            if (machine instanceof IControllable controllable) {
+                attachRight.child(GTMuiWidgets.createPowerButton(controllable));
+            }
+            if (machine instanceof IHasBatterySlot batterySlot) {
+                attachRight.child(GTMuiWidgets.createBatterySlot(batterySlot, syncManager));
+            }
+            if (machine instanceof IVoidable voidable) {
+                attachRight.child(GTMuiWidgets.createVoidingButton(voidable));
+            }
+            if (machine instanceof IDistinctPart distinctPart) {
+                attachRight.child(GTMuiWidgets.createDistinctnessButton(distinctPart));
+            }
+        }
+
+        leftConfigurators.accept(attachLeft);
+        rightConfigurators.accept(attachRight);
+        mainContents.accept(attachMain);
+
+        if (addTraitConfigurators) {
+            for (var trait : machine.getTraitHolder().getAllTraits()) {
+                if (trait instanceof IAttachConfiguratorsTrait attachConfiguratorsTrait) {
+                    attachConfiguratorsTrait.attachLeftConfigurators(attachLeft, panel, syncManager);
+                    attachConfiguratorsTrait.attachRightConfigurators(attachRight, panel, syncManager);
+                }
+            }
+        }
+
+        return panel;
+    }
+
+    public static MachineUIPanelBuilder defaultSimpleSingleblockPanelBuilder(MetaMachine machine) {
+        return new MachineUIPanelBuilder(machine).drawGTLogo(true);
+    }
+
+    public static MachineUIPanelBuilder defaultPanelBuilder(MetaMachine machine) {
+        return new MachineUIPanelBuilder(machine);
+    }
+
+    public static MachineUIPanelBuilder defaultSteamMachineBuilder(MetaMachine machine) {
+        return new MachineUIPanelBuilder(machine).drawGTLogo(true).addDefaultConfigurators(false)
+                .addTraitConfigurators(false);
+    }
+}
diff --git a/src/main/java/com/gregtechceu/gtceu/api/machine/multiblock/CoilWorkableElectricMultiblockMachine.java b/src/main/java/com/gregtechceu/gtceu/api/machine/multiblock/CoilWorkableElectricMultiblockMachine.java
index a4ea83d5a11..3d851717c1b 100644
--- a/src/main/java/com/gregtechceu/gtceu/api/machine/multiblock/CoilWorkableElectricMultiblockMachine.java
+++ b/src/main/java/com/gregtechceu/gtceu/api/machine/multiblock/CoilWorkableElectricMultiblockMachine.java
@@ -2,10 +2,18 @@
 
 import com.gregtechceu.gtceu.api.block.ICoilType;
 import com.gregtechceu.gtceu.api.blockentity.BlockEntityCreationInfo;
+import com.gregtechceu.gtceu.api.sync_system.annotations.SyncToClient;
 import com.gregtechceu.gtceu.common.block.CoilBlock;
 
 import net.minecraft.MethodsReturnNonnullByDefault;
 
+import brachy.modularui.api.drawable.IDrawable;
+import brachy.modularui.drawable.*;
+import brachy.modularui.factory.PosGuiData;
+import brachy.modularui.screen.UISettings;
+import brachy.modularui.value.sync.PanelSyncManager;
+import brachy.modularui.widget.ParentWidget;
+import brachy.modularui.widgets.layout.Flow;
 import lombok.Getter;
 
 import javax.annotation.ParametersAreNonnullByDefault;
@@ -16,6 +24,9 @@ public class CoilWorkableElectricMultiblockMachine extends WorkableElectricMulti
 
     @Getter
     private ICoilType coilType = CoilBlock.CoilType.CUPRONICKEL;
+    @SyncToClient
+    @Getter
+    private int coilTier = 1;
 
     public CoilWorkableElectricMultiblockMachine(BlockEntityCreationInfo info) {
         super(info);
@@ -30,10 +41,24 @@ public void onStructureFormed() {
         var type = getMultiblockState().getMatchContext().get("CoilType");
         if (type instanceof ICoilType coil) {
             this.coilType = coil;
+            this.coilTier = coil.getTier();
+            getSyncDataHolder().markClientSyncFieldDirty("coilTier");
         }
     }
 
-    public int getCoilTier() {
-        return coilType.getTier();
+    @Override
+    public void buildMainUI(ParentWidget<?> mainWidget, PosGuiData guiData, PanelSyncManager syncManager,
+                            UISettings settings) {
+        IDrawable coilTexture = new UITexture.Builder()
+                .location(CoilBlock.CoilType.values()[coilTier].getTexture())
+                .imageSize(16, 16)
+                .colorType(ColorType.DEFAULT)
+                .tiled().build();
+
+        mainWidget
+                .child(Flow.row().height(MULTI_UI_TEXT_PANEL_HEIGHT).coverChildrenWidth()
+                        .child(new IDrawable.DrawableWidget(coilTexture).size(4, MULTI_UI_TEXT_PANEL_HEIGHT))
+                        .child(getMainTextPanel(syncManager))
+                        .child(new IDrawable.DrawableWidget(coilTexture).size(4, MULTI_UI_TEXT_PANEL_HEIGHT)));
     }
 }
diff --git a/src/main/java/com/gregtechceu/gtceu/api/machine/multiblock/MultiblockControllerMachine.java b/src/main/java/com/gregtechceu/gtceu/api/machine/multiblock/MultiblockControllerMachine.java
index 8e1ad857077..1d109f7d7ff 100644
--- a/src/main/java/com/gregtechceu/gtceu/api/machine/multiblock/MultiblockControllerMachine.java
+++ b/src/main/java/com/gregtechceu/gtceu/api/machine/multiblock/MultiblockControllerMachine.java
@@ -28,6 +28,8 @@
 import net.minecraft.world.InteractionResult;
 import net.minecraft.world.level.block.state.BlockState;
 
+import brachy.modularui.api.widget.IWidget;
+import brachy.modularui.value.sync.PanelSyncManager;
 import lombok.Getter;
 import org.jetbrains.annotations.Nullable;
 
@@ -160,7 +162,7 @@ public void onPartUnload() {
 
     //////////////////////////////////////
     // ***** Getters ******//
-    /// ///////////////////////////////////
+    //////////////////////////////////////
 
     /**
      * The {@link MultiblockMachineDefinition} of this multiblock.
@@ -413,4 +415,15 @@ public boolean checkPatternWithTryLock() {
             return false;
         }
     }
+
+    /**
+     * Can be overridden to just add widgets to the black box in the middle instead of overriding the whole UI.
+     * Don't forget to invoke {@code super.getWidgetsForDisplay} to add the default lines (progress, voltage, etc.).
+     *
+     * @param syncManager the sync manager
+     * @return list of widgets to be displayed inside the black box in the middle of a standard multiblock UI
+     */
+    public List<IWidget> getWidgetsForDisplay(PanelSyncManager syncManager) {
+        return new ArrayList<>();
+    }
 }
diff --git a/src/main/java/com/gregtechceu/gtceu/api/machine/multiblock/WorkableElectricMultiblockMachine.java b/src/main/java/com/gregtechceu/gtceu/api/machine/multiblock/WorkableElectricMultiblockMachine.java
index a96213a0e87..69a335f03ae 100644
--- a/src/main/java/com/gregtechceu/gtceu/api/machine/multiblock/WorkableElectricMultiblockMachine.java
+++ b/src/main/java/com/gregtechceu/gtceu/api/machine/multiblock/WorkableElectricMultiblockMachine.java
@@ -6,43 +6,40 @@
 import com.gregtechceu.gtceu.api.capability.recipe.EURecipeCapability;
 import com.gregtechceu.gtceu.api.capability.recipe.IO;
 import com.gregtechceu.gtceu.api.capability.recipe.IRecipeHandler;
-import com.gregtechceu.gtceu.api.gui.GuiTextures;
-import com.gregtechceu.gtceu.api.gui.fancy.*;
-import com.gregtechceu.gtceu.api.machine.feature.IFancyUIMachine;
+import com.gregtechceu.gtceu.api.machine.feature.IMuiMachine;
 import com.gregtechceu.gtceu.api.machine.feature.IOverclockMachine;
 import com.gregtechceu.gtceu.api.machine.feature.ITieredMachine;
 import com.gregtechceu.gtceu.api.machine.feature.IVoidable;
-import com.gregtechceu.gtceu.api.machine.feature.multiblock.IDisplayUIMachine;
-import com.gregtechceu.gtceu.api.machine.feature.multiblock.IMultiPart;
 import com.gregtechceu.gtceu.api.machine.trait.RecipeLogic;
 import com.gregtechceu.gtceu.api.misc.EnergyContainerList;
-import com.gregtechceu.gtceu.api.recipe.modifier.RecipeModifierList;
 import com.gregtechceu.gtceu.api.sync_system.annotations.SaveField;
-import com.gregtechceu.gtceu.common.data.GTRecipeModifiers;
-import com.gregtechceu.gtceu.common.machine.multiblock.part.ParallelHatchPartMachine;
+import com.gregtechceu.gtceu.common.mui.GTMultiblockTextUtil;
 import com.gregtechceu.gtceu.utils.GTUtil;
 
-import com.lowdragmc.lowdraglib.gui.modular.ModularUI;
-import com.lowdragmc.lowdraglib.gui.widget.*;
-
 import net.minecraft.MethodsReturnNonnullByDefault;
-import net.minecraft.network.chat.Component;
-import net.minecraft.world.entity.player.Player;
 
+import brachy.modularui.api.widget.IWidget;
+import brachy.modularui.drawable.GuiTextures;
+import brachy.modularui.drawable.Icon;
+import brachy.modularui.factory.PosGuiData;
+import brachy.modularui.screen.UISettings;
+import brachy.modularui.utils.Alignment;
+import brachy.modularui.value.sync.PanelSyncManager;
+import brachy.modularui.widget.ParentWidget;
+import brachy.modularui.widget.Widget;
+import brachy.modularui.widgets.ListWidget;
 import lombok.Getter;
+import org.jetbrains.annotations.Nullable;
 
 import java.util.ArrayList;
-import java.util.Arrays;
 import java.util.List;
-import java.util.Objects;
 
-import javax.annotation.Nullable;
 import javax.annotation.ParametersAreNonnullByDefault;
 
 @ParametersAreNonnullByDefault
 @MethodsReturnNonnullByDefault
-public class WorkableElectricMultiblockMachine extends WorkableMultiblockMachine implements IFancyUIMachine,
-                                               IDisplayUIMachine, ITieredMachine, IOverclockMachine {
+public class WorkableElectricMultiblockMachine extends WorkableMultiblockMachine
+                                               implements IMuiMachine, ITieredMachine, IOverclockMachine, IVoidable {
 
     // runtime
     protected @Nullable EnergyContainerList energyContainer;
@@ -98,91 +95,37 @@ public void setBatchEnabled(boolean batch) {
     // ********** GUI ***********//
     //////////////////////////////////////
 
-    @Override
-    public void addDisplayText(List<Component> textList) {
-        int numParallels;
-        int subtickParallels;
-        int batchParallels;
-        int totalRuns;
-        boolean exact = false;
-        if (recipeLogic.isActive() && recipeLogic.getLastRecipe() != null) {
-            numParallels = recipeLogic.getLastRecipe().parallels;
-            subtickParallels = recipeLogic.getLastRecipe().subtickParallels;
-            batchParallels = recipeLogic.getLastRecipe().batchParallels;
-            totalRuns = recipeLogic.getLastRecipe().getTotalRuns();
-            exact = true;
-        } else {
-            numParallels = getParallelHatch()
-                    .map(ParallelHatchPartMachine::getCurrentParallel)
-                    .orElse(0);
-            subtickParallels = 0;
-            batchParallels = 0;
-            totalRuns = 0;
-        }
+    public static final int MULTI_UI_TEXT_PANEL_WIDTH = 172;
+    public static final int MULTI_UI_TEXT_PANEL_HEIGHT = 136;
 
-        MultiblockDisplayText.builder(textList, isFormed())
-                .setWorkingStatus(recipeLogic.isWorkingEnabled(), recipeLogic.isActive())
-                .addEnergyUsageLine(energyContainer)
-                .addEnergyTierLine(tier)
-                .addMachineModeLine(getRecipeType(), getRecipeTypes().length > 1)
-                .addTotalRunsLine(totalRuns)
-                .addParallelsLine(numParallels, exact)
-                .addSubtickParallelsLine(subtickParallels)
-                .addBatchModeLine(isBatchEnabled(), batchParallels)
-                .addWorkingStatusLine()
-                .addProgressLine(recipeLogic)
-                .addRecipeFailReasonLine(recipeLogic)
-                .addOutputLines(recipeLogic.getLastRecipe());
-        getDefinition().getAdditionalDisplay().accept(this, textList);
-        IDisplayUIMachine.super.addDisplayText(textList);
-    }
+    public Widget<?> getMainTextPanel(PanelSyncManager syncManager) {
+        var parentWidget = new ParentWidget<>();
+        var listWidget = new ListWidget<>()
+                .width(MULTI_UI_TEXT_PANEL_WIDTH - 6)
+                .height(MULTI_UI_TEXT_PANEL_HEIGHT - 6)
+                .childSeparator(Icon.EMPTY_2PX)
+                .crossAxisAlignment(Alignment.CrossAxis.START)
+                .posRel(Alignment.CenterLeft);
+        parentWidget.size(MULTI_UI_TEXT_PANEL_WIDTH, MULTI_UI_TEXT_PANEL_HEIGHT).background(GuiTextures.DISPLAY);
 
-    @Override
-    public Widget createUIWidget() {
-        var group = new WidgetGroup(0, 0, 182 + 8, 117 + 8);
-        group.addWidget(new DraggableScrollableWidgetGroup(4, 4, 182, 117).setBackground(getScreenTexture())
-                .addWidget(new LabelWidget(4, 5, self().getBlockState().getBlock().getDescriptionId()))
-                .addWidget(new ComponentPanelWidget(4, 17, this::addDisplayText)
-                        .textSupplier(this.getLevel().isClientSide ? null : this::addDisplayText)
-                        .setMaxWidthLimit(200)
-                        .clickHandler(this::handleDisplayClick)));
-        group.setBackground(GuiTextures.BACKGROUND_INVERSE);
-        return group;
+        listWidget.children(getWidgetsForDisplay(syncManager));
+        parentWidget.child(listWidget.left(3).top(3));
+        return parentWidget;
     }
 
     @Override
-    public ModularUI createUI(Player entityPlayer) {
-        return new ModularUI(198, 208, this, entityPlayer).widget(new FancyMachineUIWidget(this, 198, 208));
+    public void buildMainUI(ParentWidget<?> mainWidget, PosGuiData guiData, PanelSyncManager syncManager,
+                            UISettings settings) {
+        mainWidget.child(getMainTextPanel(syncManager).margin(4, 2));
     }
 
     @Override
-    public List<IFancyUIProvider> getSubTabs() {
-        return getParts().stream().filter(Objects::nonNull).map(IFancyUIProvider.class::cast).toList();
-    }
-
-    @Override
-    public void attachConfigurators(ConfiguratorPanel configuratorPanel) {
-        IVoidable.attachConfigurators(configuratorPanel, this);
-        if (getDefinition().getRecipeModifier() instanceof RecipeModifierList list && Arrays.stream(list.getModifiers())
-                .anyMatch(modifier -> modifier == GTRecipeModifiers.BATCH_MODE)) {
-            configuratorPanel.attachConfigurators(new IFancyConfiguratorButton.Toggle(
-                    GuiTextures.BUTTON_BATCH.getSubTexture(0, 0, 1, 0.5),
-                    GuiTextures.BUTTON_BATCH.getSubTexture(0, 0.5, 1, 0.5),
-                    this::isBatchEnabled,
-                    (cd, p) -> setBatchEnabled(p))
-                    .setTooltipsSupplier(
-                            p -> List.of(
-                                    Component.translatable("gtceu.machine.batch_" + (p ? "enabled" : "disabled")))));
-        }
-
-        IFancyUIMachine.super.attachConfigurators(configuratorPanel);
-    }
-
-    @Override
-    public void attachTooltips(TooltipsPanel tooltipsPanel) {
-        for (IMultiPart part : getParts()) {
-            part.attachFancyTooltipsToController(this, tooltipsPanel);
-        }
+    public List<IWidget> getWidgetsForDisplay(PanelSyncManager syncManager) {
+        List<IWidget> widgets = new ArrayList<>();
+        widgets.add(GTMultiblockTextUtil.addEnergyTierLine(this, syncManager));
+        widgets.add(GTMultiblockTextUtil.addEnergyUsageLine(this, syncManager));
+        widgets.addAll(super.getWidgetsForDisplay(syncManager));
+        return widgets;
     }
 
     //////////////////////////////////////
diff --git a/src/main/java/com/gregtechceu/gtceu/api/machine/multiblock/WorkableMultiblockMachine.java b/src/main/java/com/gregtechceu/gtceu/api/machine/multiblock/WorkableMultiblockMachine.java
index 1026e857dba..12ebb955a68 100644
--- a/src/main/java/com/gregtechceu/gtceu/api/machine/multiblock/WorkableMultiblockMachine.java
+++ b/src/main/java/com/gregtechceu/gtceu/api/machine/multiblock/WorkableMultiblockMachine.java
@@ -16,11 +16,14 @@
 import com.gregtechceu.gtceu.api.sync_system.annotations.SyncToClient;
 import com.gregtechceu.gtceu.client.model.machine.MachineRenderState;
 import com.gregtechceu.gtceu.common.machine.trait.CleanroomReceiverTrait;
+import com.gregtechceu.gtceu.common.mui.GTMultiblockTextUtil;
 import com.gregtechceu.gtceu.utils.ISubscription;
 
 import net.minecraft.core.BlockPos;
 import net.minecraft.world.level.block.Block;
 
+import brachy.modularui.api.widget.IWidget;
+import brachy.modularui.value.sync.PanelSyncManager;
 import it.unimi.dsi.fastutil.longs.Long2ObjectMap;
 import it.unimi.dsi.fastutil.longs.Long2ObjectMaps;
 import it.unimi.dsi.fastutil.longs.LongSet;
@@ -311,4 +314,17 @@ public void setVoidingMode(VoidingMode mode) {
         voidingMode = mode;
         getRecipeLogic().updateTickSubscription();
     }
+
+    @Override
+    public List<IWidget> getWidgetsForDisplay(PanelSyncManager syncManager) {
+        List<IWidget> widgets = super.getWidgetsForDisplay(syncManager);
+        widgets.add(GTMultiblockTextUtil.addProgressLine(this, syncManager));
+        widgets.add(GTMultiblockTextUtil.addWorkingStatusLine(this, syncManager));
+        widgets.add(GTMultiblockTextUtil.addParallelLine(this, syncManager));
+        widgets.add(GTMultiblockTextUtil.addBatchModeLine(this, syncManager));
+        widgets.add(GTMultiblockTextUtil.addSubtickParallelsLine(this, syncManager));
+        widgets.add(GTMultiblockTextUtil.addTotalRunsLine(this, syncManager));
+        widgets.add(GTMultiblockTextUtil.addOutputLines(this, syncManager));
+        return widgets;
+    }
 }
diff --git a/src/main/java/com/gregtechceu/gtceu/api/machine/multiblock/part/TieredIOPartMachine.java b/src/main/java/com/gregtechceu/gtceu/api/machine/multiblock/part/TieredIOPartMachine.java
index 4656665301e..921d4323823 100644
--- a/src/main/java/com/gregtechceu/gtceu/api/machine/multiblock/part/TieredIOPartMachine.java
+++ b/src/main/java/com/gregtechceu/gtceu/api/machine/multiblock/part/TieredIOPartMachine.java
@@ -10,7 +10,6 @@
 import net.minecraft.MethodsReturnNonnullByDefault;
 
 import lombok.Getter;
-import org.jetbrains.annotations.Nullable;
 
 import javax.annotation.ParametersAreNonnullByDefault;
 
@@ -45,14 +44,17 @@ public void setWorkingEnabled(boolean workingEnabled) {
     // ***** Initialization ******//
     //////////////////////////////////////
 
-    @Nullable
-    @Override
-    public PageGroupingData getPageGroupingData() {
-        return switch (this.io) {
-            case IN -> new PageGroupingData("gtceu.multiblock.page_switcher.io.import", 1);
-            case OUT -> new PageGroupingData("gtceu.multiblock.page_switcher.io.export", 2);
-            case BOTH -> new PageGroupingData("gtceu.multiblock.page_switcher.io.both", 3);
-            case NONE -> null;
-        };
-    }
+    /*
+     * @Nullable
+     *
+     * @Override
+     * public PageGroupingData getPageGroupingData() {
+     * return switch (this.io) {
+     * case IN -> new PageGroupingData("gtceu.multiblock.page_switcher.io.import", 1);
+     * case OUT -> new PageGroupingData("gtceu.multiblock.page_switcher.io.export", 2);
+     * case BOTH -> new PageGroupingData("gtceu.multiblock.page_switcher.io.both", 3);
+     * case NONE -> null;
+     * };
+     * }
+     */
 }
diff --git a/src/main/java/com/gregtechceu/gtceu/api/machine/steam/SimpleSteamMachine.java b/src/main/java/com/gregtechceu/gtceu/api/machine/steam/SimpleSteamMachine.java
index e28634e50e4..199ba8cb40e 100644
--- a/src/main/java/com/gregtechceu/gtceu/api/machine/steam/SimpleSteamMachine.java
+++ b/src/main/java/com/gregtechceu/gtceu/api/machine/steam/SimpleSteamMachine.java
@@ -4,12 +4,7 @@
 import com.gregtechceu.gtceu.api.blockentity.BlockEntityCreationInfo;
 import com.gregtechceu.gtceu.api.capability.recipe.IO;
 import com.gregtechceu.gtceu.api.capability.recipe.ItemRecipeCapability;
-import com.gregtechceu.gtceu.api.capability.recipe.RecipeCapability;
-import com.gregtechceu.gtceu.api.gui.GuiTextures;
-import com.gregtechceu.gtceu.api.gui.UITemplate;
-import com.gregtechceu.gtceu.api.gui.widget.PredicatedImageWidget;
 import com.gregtechceu.gtceu.api.machine.MetaMachine;
-import com.gregtechceu.gtceu.api.machine.feature.IUIMachine;
 import com.gregtechceu.gtceu.api.machine.property.GTMachineModelProperties;
 import com.gregtechceu.gtceu.api.machine.trait.NotifiableItemStackHandler;
 import com.gregtechceu.gtceu.api.machine.trait.RecipeHandlerList;
@@ -23,15 +18,8 @@
 import com.gregtechceu.gtceu.common.machine.trait.ExhaustVentMachineTrait;
 import com.gregtechceu.gtceu.common.recipe.condition.VentCondition;
 
-import com.lowdragmc.lowdraglib.gui.modular.ModularUI;
-import com.lowdragmc.lowdraglib.gui.widget.LabelWidget;
-import com.lowdragmc.lowdraglib.utils.Position;
-
 import net.minecraft.core.Direction;
-import net.minecraft.nbt.CompoundTag;
-import net.minecraft.world.entity.player.Player;
 
-import com.google.common.collect.Tables;
 import lombok.Getter;
 
 import java.util.*;
@@ -39,7 +27,7 @@
 /**
  * A singleblock steam machine with recipe logic and item IO.
  */
-public class SimpleSteamMachine extends SteamWorkableMachine implements IUIMachine {
+public class SimpleSteamMachine extends SteamWorkableMachine {
 
     @SaveField
     public final NotifiableItemStackHandler importItems;
@@ -167,35 +155,4 @@ public void afterWorking() {
         exhaustVentTrait.setNeedsVenting(true);
         exhaustVentTrait.checkVenting();
     }
-
-    //////////////////////////////////////
-    // *********** GUI ***********//
-    //////////////////////////////////////
-
-    @Override
-    public ModularUI createUI(Player entityPlayer) {
-        var storages = Tables.newCustomTable(new EnumMap<>(IO.class), LinkedHashMap<RecipeCapability<?>, Object>::new);
-        storages.put(IO.IN, ItemRecipeCapability.CAP, importItems.storage);
-        storages.put(IO.OUT, ItemRecipeCapability.CAP, exportItems.storage);
-
-        var group = getRecipeType().getRecipeUI().createUITemplate(recipeLogic::getProgressPercent,
-                storages,
-                new CompoundTag(),
-                Collections.emptyList(),
-                true,
-                isHighPressure);
-        Position pos = new Position((Math.max(group.getSize().width + 4 + 8, 176) - 4 - group.getSize().width) / 2 + 4,
-                32);
-        group.setSelfPosition(pos);
-        return new ModularUI(176, 166, this, entityPlayer)
-                .background(GuiTextures.BACKGROUND_STEAM.get(isHighPressure))
-                .widget(group)
-                .widget(new LabelWidget(5, 5, getBlockState().getBlock().getDescriptionId()))
-                .widget(new PredicatedImageWidget(pos.x + group.getSize().width / 2 - 9,
-                        pos.y + group.getSize().height / 2 - 9, 18, 18,
-                        GuiTextures.INDICATOR_NO_STEAM.get(isHighPressure))
-                        .setPredicate(recipeLogic::isWaiting))
-                .widget(UITemplate.bindPlayerInventory(entityPlayer.getInventory(),
-                        GuiTextures.SLOT_STEAM.get(isHighPressure), 7, 84, true));
-    }
 }
diff --git a/src/main/java/com/gregtechceu/gtceu/api/machine/steam/SteamBoilerMachine.java b/src/main/java/com/gregtechceu/gtceu/api/machine/steam/SteamBoilerMachine.java
index 08462261a9f..53b62a5a32b 100644
--- a/src/main/java/com/gregtechceu/gtceu/api/machine/steam/SteamBoilerMachine.java
+++ b/src/main/java/com/gregtechceu/gtceu/api/machine/steam/SteamBoilerMachine.java
@@ -3,13 +3,10 @@
 import com.gregtechceu.gtceu.api.GTValues;
 import com.gregtechceu.gtceu.api.blockentity.BlockEntityCreationInfo;
 import com.gregtechceu.gtceu.api.capability.recipe.IO;
-import com.gregtechceu.gtceu.api.gui.GuiTextures;
-import com.gregtechceu.gtceu.api.gui.UITemplate;
-import com.gregtechceu.gtceu.api.gui.widget.TankWidget;
 import com.gregtechceu.gtceu.api.machine.MetaMachine;
 import com.gregtechceu.gtceu.api.machine.TickableSubscription;
-import com.gregtechceu.gtceu.api.machine.feature.IDataInfoProvider;
-import com.gregtechceu.gtceu.api.machine.feature.IUIMachine;
+import com.gregtechceu.gtceu.api.machine.feature.*;
+import com.gregtechceu.gtceu.api.machine.mui.MachineUIPanelBuilder;
 import com.gregtechceu.gtceu.api.machine.trait.NotifiableFluidTank;
 import com.gregtechceu.gtceu.api.machine.trait.RecipeLogic;
 import com.gregtechceu.gtceu.api.recipe.GTRecipe;
@@ -19,16 +16,10 @@
 import com.gregtechceu.gtceu.api.sync_system.annotations.SyncToClient;
 import com.gregtechceu.gtceu.common.data.GTMaterials;
 import com.gregtechceu.gtceu.common.item.behavior.PortableScannerBehavior;
+import com.gregtechceu.gtceu.common.mui.GTGuiTextures;
 import com.gregtechceu.gtceu.config.ConfigHolder;
 import com.gregtechceu.gtceu.utils.*;
 
-import com.lowdragmc.lowdraglib.gui.modular.ModularUI;
-import com.lowdragmc.lowdraglib.gui.texture.ProgressTexture;
-import com.lowdragmc.lowdraglib.gui.widget.ImageWidget;
-import com.lowdragmc.lowdraglib.gui.widget.LabelWidget;
-import com.lowdragmc.lowdraglib.gui.widget.ProgressWidget;
-
-import net.minecraft.client.resources.language.I18n;
 import net.minecraft.core.BlockPos;
 import net.minecraft.core.Direction;
 import net.minecraft.core.particles.ParticleTypes;
@@ -39,12 +30,22 @@
 import net.minecraft.sounds.SoundSource;
 import net.minecraft.util.RandomSource;
 import net.minecraft.world.InteractionResult;
-import net.minecraft.world.entity.player.Player;
 import net.minecraft.world.level.block.Block;
 import net.minecraftforge.fluids.FluidType;
 import net.minecraftforge.fluids.FluidUtil;
 import net.minecraftforge.fluids.capability.IFluidHandler.FluidAction;
 
+import brachy.modularui.api.drawable.IKey;
+import brachy.modularui.drawable.UITexture;
+import brachy.modularui.factory.PosGuiData;
+import brachy.modularui.screen.UISettings;
+import brachy.modularui.value.sync.DoubleSyncValue;
+import brachy.modularui.value.sync.FluidSlotSyncHandler;
+import brachy.modularui.value.sync.PanelSyncManager;
+import brachy.modularui.widget.ParentWidget;
+import brachy.modularui.widgets.ProgressWidget;
+import brachy.modularui.widgets.layout.Flow;
+import brachy.modularui.widgets.slot.FluidSlot;
 import lombok.Getter;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
@@ -54,7 +55,7 @@
 import java.util.List;
 
 public abstract class SteamBoilerMachine extends SteamWorkableMachine
-                                         implements IUIMachine, IDataInfoProvider {
+                                         implements IMuiMachine, IDataInfoProvider {
 
     @SaveField
     public final NotifiableFluidTank waterTank;
@@ -169,7 +170,9 @@ protected void updateCurrentTemperature() {
                 currentTemperature -= getCoolDownRate();
                 timeBeforeCoolingDown = getCooldownInterval();
             }
-        } else--timeBeforeCoolingDown;
+        } else {
+            --timeBeforeCoolingDown;
+        }
 
         if (getOffsetTimer() % 10 == 0) {
             if (currentTemperature >= 100) {
@@ -183,7 +186,9 @@ protected void updateCurrentTemperature() {
                 }
                 if (this.hasNoWater && hasDrainedWater) {
                     GTUtil.doExplosion(getLevel(), getBlockPos(), 2.0f);
-                } else this.hasNoWater = !hasDrainedWater;
+                } else {
+                    this.hasNoWater = !hasDrainedWater;
+                }
                 if (filledSteam == 0 && hasDrainedWater && getLevel() instanceof ServerLevel serverLevel) {
                     final float x = getBlockPos().getX() + 0.5F;
                     final float y = getBlockPos().getY() + 0.5F;
@@ -206,9 +211,12 @@ protected void updateCurrentTemperature() {
                     // bypass capability check for special case behavior
                     steamTank.drainInternal(FluidType.BUCKET_VOLUME * 4, FluidAction.EXECUTE);
                 }
-            } else this.hasNoWater = false;
+            } else {
+                this.hasNoWater = false;
+            }
         }
         updateSteamSubscription();
+        syncDataHolder.markClientSyncFieldDirty("currentTemperature");
     }
 
     protected int getCooldownInterval() {
@@ -296,27 +304,42 @@ public InteractionResult onUseWithItem(ExtendedUseOnContext context) {
     //////////////////////////////////////
 
     @Override
-    public ModularUI createUI(Player entityPlayer) {
-        return new ModularUI(176, 166, this, entityPlayer)
-                .background(GuiTextures.BACKGROUND_STEAM.get(isHighPressure))
-                .widget(new LabelWidget(6, 6, getBlockState().getBlock().getDescriptionId()))
-                .widget(new ProgressWidget(this::getTemperaturePercent, 96, 26, 10, 54)
-                        .setProgressTexture(GuiTextures.PROGRESS_BAR_BOILER_EMPTY.get(isHighPressure),
-                                GuiTextures.PROGRESS_BAR_BOILER_HEAT)
-                        .setFillDirection(ProgressTexture.FillDirection.DOWN_TO_UP)
-                        .setDynamicHoverTips(pct -> I18n.get("gtceu.multiblock.large_boiler.temperature",
-                                currentTemperature + 274, getMaxTemperature() + 274)))
-                .widget(new TankWidget(waterTank.getStorages()[0], 83, 26, 10, 54, false, true)
-                        .setShowAmount(false)
-                        .setFillDirection(ProgressTexture.FillDirection.DOWN_TO_UP)
-                        .setBackground(GuiTextures.PROGRESS_BAR_BOILER_EMPTY.get(isHighPressure)))
-                .widget(new TankWidget(steamTank.getStorages()[0], 70, 26, 10, 54, true, false)
-                        .setShowAmount(false)
-                        .setFillDirection(ProgressTexture.FillDirection.DOWN_TO_UP)
-                        .setBackground(GuiTextures.PROGRESS_BAR_BOILER_EMPTY.get(isHighPressure)))
-                .widget(new ImageWidget(43, 44, 18, 18, GuiTextures.CANISTER_OVERLAY_STEAM.get(isHighPressure)))
-                .widget(UITemplate.bindPlayerInventory(entityPlayer.getInventory(),
-                        GuiTextures.SLOT_STEAM.get(isHighPressure), 7, 84, true));
+    public MachineUIPanelBuilder getPanelBuilder(PosGuiData data, PanelSyncManager syncManager, UISettings settings) {
+        return MachineUIPanelBuilder.defaultSteamMachineBuilder(this);
+    }
+
+    @Override
+    public void buildMainUI(ParentWidget<?> mainWidget, PosGuiData guiData, PanelSyncManager syncManager,
+                            UISettings settings) {
+        UITexture progressTexture = isHighPressure() ? GTGuiTextures.PROGRESS_BAR_BOILER_EMPTY_STEEL :
+                GTGuiTextures.PROGRESS_BAR_BOILER_EMPTY_BRONZE;
+
+        DoubleSyncValue tempPercentage = syncManager.getOrCreateSyncHandler("tempPercentage", DoubleSyncValue.class,
+                () -> new DoubleSyncValue(this::getTemperaturePercent));
+
+        mainWidget.child(Flow.row()
+                .top(12)
+                .left(50)
+                .coverChildren()
+                .childPadding(10)
+                .child(new FluidSlot()
+                        .syncHandler(new FluidSlotSyncHandler(waterTank.getStorages()[0]))
+                        .size(14, 54)
+                        .alwaysShowFull(true))
+                .child(new FluidSlot()
+                        .syncHandler(new FluidSlotSyncHandler(steamTank.getStorages()[0])
+                                .canFillSlot(false).canDrainSlot(true))
+                        .alwaysShowFull(true)
+                        .size(14, 54))
+                .child(new ProgressWidget()
+                        .texture(progressTexture,
+                                GTGuiTextures.PROGRESS_BAR_BOILER_HEAT, 54)
+                        .size(14, 54)
+                        .value(tempPercentage)
+                        .direction(ProgressWidget.Direction.UP)
+                        .tooltipAutoUpdate(true)
+                        .tooltipBuilder((r) -> r.addLine(IKey
+                                .lang(Component.translatable("gtceu.fluid.temperature", getCurrentTemperature()))))));
     }
 
     //////////////////////////////////////
diff --git a/src/main/java/com/gregtechceu/gtceu/api/machine/steam/SteamEnergyRecipeHandler.java b/src/main/java/com/gregtechceu/gtceu/api/machine/steam/SteamEnergyRecipeHandler.java
index ab2e69cb39a..5b99437bc4b 100644
--- a/src/main/java/com/gregtechceu/gtceu/api/machine/steam/SteamEnergyRecipeHandler.java
+++ b/src/main/java/com/gregtechceu/gtceu/api/machine/steam/SteamEnergyRecipeHandler.java
@@ -13,6 +13,7 @@
 
 import net.minecraftforge.fluids.FluidStack;
 
+import lombok.Getter;
 import org.jetbrains.annotations.NotNull;
 
 import java.util.ArrayList;
@@ -20,6 +21,7 @@
 
 public class SteamEnergyRecipeHandler implements IRecipeHandler<EnergyStack> {
 
+    @Getter
     private final NotifiableFluidTank steamTank;
     private final double conversionRate; // mB steam per EU
 
diff --git a/src/main/java/com/gregtechceu/gtceu/api/machine/steam/SteamWorkableMachine.java b/src/main/java/com/gregtechceu/gtceu/api/machine/steam/SteamWorkableMachine.java
index 68a90d4de2b..2f90f65552b 100644
--- a/src/main/java/com/gregtechceu/gtceu/api/machine/steam/SteamWorkableMachine.java
+++ b/src/main/java/com/gregtechceu/gtceu/api/machine/steam/SteamWorkableMachine.java
@@ -4,7 +4,6 @@
 import com.gregtechceu.gtceu.api.capability.recipe.IO;
 import com.gregtechceu.gtceu.api.capability.recipe.IRecipeHandler;
 import com.gregtechceu.gtceu.api.capability.recipe.RecipeCapability;
-import com.gregtechceu.gtceu.api.gui.GuiTextures;
 import com.gregtechceu.gtceu.api.item.tool.GTToolType;
 import com.gregtechceu.gtceu.api.machine.feature.IMufflableMachine;
 import com.gregtechceu.gtceu.api.machine.feature.IRecipeLogicMachine;
@@ -14,11 +13,10 @@
 import com.gregtechceu.gtceu.api.sync_system.annotations.SaveField;
 import com.gregtechceu.gtceu.api.sync_system.annotations.SyncToClient;
 import com.gregtechceu.gtceu.common.machine.trait.CleanroomReceiverTrait;
+import com.gregtechceu.gtceu.common.mui.GTGuiTextures;
 import com.gregtechceu.gtceu.utils.ExtendedUseOnContext;
 import com.gregtechceu.gtceu.utils.ISubscription;
 
-import com.lowdragmc.lowdraglib.gui.texture.ResourceTexture;
-
 import net.minecraft.core.BlockPos;
 import net.minecraft.core.Direction;
 import net.minecraft.world.InteractionResult;
@@ -26,6 +24,7 @@
 import net.minecraft.world.level.block.state.BlockState;
 import net.minecraftforge.fluids.FluidType;
 
+import brachy.modularui.drawable.UITexture;
 import it.unimi.dsi.fastutil.objects.Object2ObjectOpenHashMap;
 import lombok.Getter;
 import lombok.Setter;
@@ -186,12 +185,12 @@ public void clientTick() {
     // ******* Rendering ********//
     //////////////////////////////////////
     @Override
-    public @Nullable ResourceTexture sideTips(Player player, BlockPos pos, BlockState state, Set<GTToolType> toolTypes,
-                                              Direction side) {
+    public @Nullable UITexture sideTips(Player player, BlockPos pos, BlockState state, Set<GTToolType> toolTypes,
+                                        Direction side) {
         if (toolTypes.contains(GTToolType.WRENCH)) {
             if (!player.isShiftKeyDown()) {
                 if (!hasFrontFacing() || side != getFrontFacing()) {
-                    return GuiTextures.TOOL_IO_FACING_ROTATION;
+                    return GTGuiTextures.TOOL_IO_FACING_ROTATION;
                 }
             }
         }
diff --git a/src/main/java/com/gregtechceu/gtceu/api/machine/trait/RecipeLogic.java b/src/main/java/com/gregtechceu/gtceu/api/machine/trait/RecipeLogic.java
index 2b8365e1536..91ebc16a6cc 100644
--- a/src/main/java/com/gregtechceu/gtceu/api/machine/trait/RecipeLogic.java
+++ b/src/main/java/com/gregtechceu/gtceu/api/machine/trait/RecipeLogic.java
@@ -5,8 +5,6 @@
 import com.gregtechceu.gtceu.api.capability.recipe.EURecipeCapability;
 import com.gregtechceu.gtceu.api.capability.recipe.IO;
 import com.gregtechceu.gtceu.api.capability.recipe.RecipeCapability;
-import com.gregtechceu.gtceu.api.gui.GuiTextures;
-import com.gregtechceu.gtceu.api.gui.fancy.IFancyTooltip;
 import com.gregtechceu.gtceu.api.machine.MetaMachine;
 import com.gregtechceu.gtceu.api.machine.TickableSubscription;
 import com.gregtechceu.gtceu.api.machine.feature.IRecipeLogicMachine;
@@ -27,8 +25,6 @@
 import com.gregtechceu.gtceu.common.cover.MachineControllerCover;
 import com.gregtechceu.gtceu.utils.GTMath;
 
-import com.lowdragmc.lowdraglib.gui.texture.IGuiTexture;
-
 import net.minecraft.nbt.CompoundTag;
 import net.minecraft.nbt.ListTag;
 import net.minecraft.nbt.Tag;
@@ -47,7 +43,7 @@
 
 import java.util.*;
 
-public class RecipeLogic extends MachineTrait implements IWorkable, IFancyTooltip {
+public class RecipeLogic extends MachineTrait implements IWorkable {
 
     public static final MachineTraitType<RecipeLogic> TYPE = new MachineTraitType<>(RecipeLogic.class, false);
 
@@ -304,6 +300,7 @@ public void handleRecipeWorking() {
                 }
                 progress++;
                 totalContinuousRunningTime++;
+                syncDataHolder.markClientSyncFieldDirty("progress");
             } else {
                 setWaiting(handleTick.reason());
 
@@ -344,6 +341,7 @@ public void handleRecipeWorking() {
     protected void regressRecipe() {
         if (progress > 0 && getRLMachine().regressWhenWaiting()) {
             this.progress = 1;
+            syncDataHolder.markClientSyncFieldDirty("progress");
         }
     }
 
@@ -367,6 +365,7 @@ public void findAndHandleRecipe() {
             lastOriginRecipe = null;
             handleSearchingRecipes(searchRecipe());
         }
+        syncDataHolder.markClientSyncFieldDirty("lastRecipe");
         recipeDirty = false;
     }
 
@@ -410,6 +409,7 @@ public void setupRecipe(GTRecipe recipe) {
             progress = 0;
             duration = 0;
             isActive = false;
+            syncDataHolder.resyncAllFields();
             return;
         }
         var handledIO = handleRecipeIO(recipe, IO.IN);
@@ -424,6 +424,7 @@ public void setupRecipe(GTRecipe recipe) {
             progress = 0;
             duration = recipe.duration;
             isActive = true;
+            syncDataHolder.resyncAllFields();
         }
     }
 
@@ -443,6 +444,7 @@ public void setStatus(Status status) {
             updateTickSubscription();
             if (this.status != Status.WAITING) {
                 waitingReason = null;
+                syncDataHolder.markClientSyncFieldDirty("waitingReason");
             }
         }
     }
@@ -450,6 +452,7 @@ public void setStatus(Status status) {
     public void setWaiting(@Nullable Component reason) {
         setStatus(Status.WAITING);
         waitingReason = reason;
+        syncDataHolder.markClientSyncFieldDirty("waitingReason");
         getRLMachine().onWaiting();
     }
 
@@ -538,6 +541,7 @@ public void onRecipeFinish() {
                 isActive = false;
                 // Force a recipe recheck.
                 lastRecipe = null;
+                syncDataHolder.resyncAllFields();
                 return;
             }
             if (getRLMachine().alwaysTryModifyRecipe()) {
@@ -547,6 +551,7 @@ public void onRecipeFinish() {
                         markLastRecipeDirty();
                     } else {
                         lastRecipe = modified;
+                        syncDataHolder.markClientSyncFieldDirty("lastRecipe");
                     }
                 } else {
                     markLastRecipeDirty();
@@ -562,6 +567,7 @@ public void onRecipeFinish() {
                 progress = 0;
                 duration = 0;
                 isActive = false;
+                syncDataHolder.resyncAllFields();
             }
         }
     }
@@ -583,6 +589,8 @@ public void interruptRecipe() {
             setStatus(Status.IDLE);
             progress = 0;
             duration = 0;
+            syncDataHolder.markClientSyncFieldDirty("progress");
+            syncDataHolder.markClientSyncFieldDirty("duration");
         }
     }
 
@@ -614,16 +622,7 @@ public void updateSound() {
         }
     }
 
-    @Override
-    public IGuiTexture getFancyTooltipIcon() {
-        if (showFancyTooltip()) {
-            return GuiTextures.INSUFFICIENT_INPUT;
-        }
-        return IGuiTexture.EMPTY;
-    }
-
-    @Override
-    public List<Component> getFancyTooltip() {
+    public List<Component> getWaitingReasons() {
         if (isWaiting() && waitingReason != null) {
             return List.of(waitingReason);
         }
@@ -633,11 +632,6 @@ public List<Component> getFancyTooltip() {
         return Collections.emptyList();
     }
 
-    @Override
-    public boolean showFancyTooltip() {
-        return waitingReason != null || !failureReasons.isEmpty();
-    }
-
     protected ChanceCacheMap makeChanceCaches() {
         ChanceCacheMap map = new ChanceCacheMap();
         for (RecipeCapability<?> cap : GTRegistries.RECIPE_CAPABILITIES.values()) {
diff --git a/src/main/java/com/gregtechceu/gtceu/api/machine/trait/feature/IAttachConfiguratorsTrait.java b/src/main/java/com/gregtechceu/gtceu/api/machine/trait/feature/IAttachConfiguratorsTrait.java
new file mode 100644
index 00000000000..10897a81b09
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/api/machine/trait/feature/IAttachConfiguratorsTrait.java
@@ -0,0 +1,12 @@
+package com.gregtechceu.gtceu.api.machine.trait.feature;
+
+import brachy.modularui.screen.ModularPanel;
+import brachy.modularui.value.sync.PanelSyncManager;
+import brachy.modularui.widgets.layout.Flow;
+
+public interface IAttachConfiguratorsTrait {
+
+    default void attachLeftConfigurators(Flow flow, ModularPanel<?> panel, PanelSyncManager syncManager) {}
+
+    default void attachRightConfigurators(Flow flow, ModularPanel<?> panel, PanelSyncManager syncManager) {}
+}
diff --git a/src/main/java/com/gregtechceu/gtceu/api/machine/trait/feature/IRenderingTrait.java b/src/main/java/com/gregtechceu/gtceu/api/machine/trait/feature/IRenderingTrait.java
index 6a2dc1a9296..a5d708c3d34 100644
--- a/src/main/java/com/gregtechceu/gtceu/api/machine/trait/feature/IRenderingTrait.java
+++ b/src/main/java/com/gregtechceu/gtceu/api/machine/trait/feature/IRenderingTrait.java
@@ -2,14 +2,13 @@
 
 import com.gregtechceu.gtceu.api.item.tool.GTToolType;
 
-import com.lowdragmc.lowdraglib.gui.texture.ResourceTexture;
-
 import net.minecraft.core.BlockPos;
 import net.minecraft.core.Direction;
 import net.minecraft.world.entity.player.Player;
 import net.minecraft.world.item.ItemStack;
 import net.minecraft.world.level.block.state.BlockState;
 
+import brachy.modularui.drawable.UITexture;
 import org.jetbrains.annotations.Nullable;
 
 import java.util.Set;
@@ -21,7 +20,7 @@ public interface IRenderingTrait {
 
     /**
      * Called to determine if the grid overlay should be rendered on this machine.
-     * 
+     *
      * @param player    Player looking at this machine
      * @param pos       Block pos
      * @param state     Block state
@@ -37,7 +36,7 @@ default boolean shouldRenderGridOverlay(Player player, BlockPos pos, BlockState
     /**
      * Called when the machine grid overlay is being rendered to determine the icon to be rendered within the grid
      * segment on a specifc side.
-     * 
+     *
      * @param player    Player looking at this machine
      * @param pos       Block pos
      * @param state     Block state
@@ -45,9 +44,9 @@ default boolean shouldRenderGridOverlay(Player player, BlockPos pos, BlockState
      * @param side      The machine side which this grid segment correspond to
      * @return The icon to be rendered, or null
      */
-    default @Nullable ResourceTexture getGridOverlayIcon(Player player, BlockPos pos, BlockState state,
-                                                         Set<GTToolType> toolTypes,
-                                                         Direction side) {
+    default @Nullable UITexture getGridOverlayIcon(Player player, BlockPos pos, BlockState state,
+                                                   Set<GTToolType> toolTypes,
+                                                   Direction side) {
         return null;
     }
 }
diff --git a/src/main/java/com/gregtechceu/gtceu/api/misc/forge/FluidTankHandler.java b/src/main/java/com/gregtechceu/gtceu/api/misc/forge/FluidTankHandler.java
new file mode 100644
index 00000000000..7c2e533a3ce
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/api/misc/forge/FluidTankHandler.java
@@ -0,0 +1,62 @@
+package com.gregtechceu.gtceu.api.misc.forge;
+
+import net.minecraftforge.fluids.FluidStack;
+import net.minecraftforge.fluids.IFluidTank;
+import net.minecraftforge.fluids.capability.IFluidHandler;
+
+import org.jetbrains.annotations.NotNull;
+
+public class FluidTankHandler implements IFluidHandler {
+
+    public static IFluidHandler getTankFluidHandler(IFluidTank tank) {
+        if (tank instanceof IFluidHandler fluidHandler) {
+            return fluidHandler;
+        }
+        return new FluidTankHandler(tank);
+    }
+
+    private final IFluidTank fluidTank;
+
+    public FluidTankHandler(IFluidTank tank) {
+        this.fluidTank = tank;
+    }
+
+    @Override
+    public int fill(FluidStack resource, FluidAction action) {
+        return this.fluidTank.fill(resource, action);
+    }
+
+    @Override
+    public @NotNull FluidStack drain(FluidStack resource, FluidAction action) {
+        FluidStack currentFluid = this.fluidTank.getFluid();
+        if (currentFluid.isEmpty() || !currentFluid.isFluidEqual(resource)) {
+            return FluidStack.EMPTY;
+        }
+        return this.fluidTank.drain(resource, action);
+    }
+
+    @Override
+    public @NotNull FluidStack drain(int maxDrain, FluidAction action) {
+        return this.fluidTank.drain(maxDrain, action);
+    }
+
+    @Override
+    public int getTanks() {
+        return 1;
+    }
+
+    @Override
+    public @NotNull FluidStack getFluidInTank(int tank) {
+        return this.fluidTank.getFluid();
+    }
+
+    @Override
+    public int getTankCapacity(int tank) {
+        return this.fluidTank.getCapacity();
+    }
+
+    @Override
+    public boolean isFluidValid(int tank, @NotNull FluidStack stack) {
+        return this.fluidTank.isFluidValid(stack);
+    }
+}
diff --git a/src/main/java/com/gregtechceu/gtceu/api/misc/virtualregistry/EntryTypes.java b/src/main/java/com/gregtechceu/gtceu/api/misc/virtualregistry/EntryTypes.java
index a2b274cfc11..524effb6f65 100644
--- a/src/main/java/com/gregtechceu/gtceu/api/misc/virtualregistry/EntryTypes.java
+++ b/src/main/java/com/gregtechceu/gtceu/api/misc/virtualregistry/EntryTypes.java
@@ -31,14 +31,9 @@ private EntryTypes(ResourceLocation location, Supplier<T> supplier) {
         this.factory = supplier;
     }
 
-    @Nullable
-    public static EntryTypes<? extends VirtualEntry> fromString(String name) {
-        return TYPES_MAP.getOrDefault(GTCEu.id(name), null);
-    }
-
     @Nullable
     public static EntryTypes<? extends VirtualEntry> fromLocation(ResourceLocation location) {
-        return TYPES_MAP.getOrDefault(location, null);
+        return TYPES_MAP.get(location);
     }
 
     public static <E extends VirtualEntry> EntryTypes<E> addEntryType(ResourceLocation location, Supplier<E> supplier) {
diff --git a/src/main/java/com/gregtechceu/gtceu/api/misc/virtualregistry/VirtualEnderRegistry.java b/src/main/java/com/gregtechceu/gtceu/api/misc/virtualregistry/VirtualEnderRegistry.java
index d76b54600b8..00a9d6203ba 100644
--- a/src/main/java/com/gregtechceu/gtceu/api/misc/virtualregistry/VirtualEnderRegistry.java
+++ b/src/main/java/com/gregtechceu/gtceu/api/misc/virtualregistry/VirtualEnderRegistry.java
@@ -3,24 +3,20 @@
 import com.gregtechceu.gtceu.GTCEu;
 
 import net.minecraft.nbt.CompoundTag;
+import net.minecraft.server.level.ServerLevel;
 import net.minecraft.world.level.saveddata.SavedData;
-import net.minecraftforge.server.ServerLifecycleHooks;
 
-import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 
-import java.util.HashMap;
-import java.util.Map;
-import java.util.Set;
-import java.util.UUID;
-import java.util.function.Predicate;
+import java.util.*;
 
 public class VirtualEnderRegistry extends SavedData {
 
     private static final String DATA_ID = GTCEu.MOD_ID + ".virtual_entry_data";
     private static final String PUBLIC_KEY = "Public";
     private static final String PRIVATE_KEY = "Private";
-    private static volatile VirtualEnderRegistry data;
+
+    private VirtualRegistryMap PUBLIC_REGISTRY = new VirtualRegistryMap();
     private final Map<UUID, VirtualRegistryMap> VIRTUAL_REGISTRIES = new HashMap<>();
 
     public VirtualEnderRegistry() {}
@@ -29,43 +25,34 @@ public VirtualEnderRegistry(CompoundTag name) {
         readFromNBT(name);
     }
 
-    public static VirtualEnderRegistry getInstance() {
-        if (data == null) {
-            var server = ServerLifecycleHooks.getCurrentServer();
-            if (server != null) {
-                data = server.overworld().getDataStorage()
-                        .computeIfAbsent(VirtualEnderRegistry::new, VirtualEnderRegistry::new, DATA_ID);
-            }
-        }
-
-        return data;
+    public static VirtualEnderRegistry get(ServerLevel sLvl) {
+        return sLvl.getServer().overworld().getDataStorage()
+                .computeIfAbsent(VirtualEnderRegistry::new, VirtualEnderRegistry::new, DATA_ID);
     }
 
-    /**
-     * To be called on server stopped event
-     */
-    public static void release() {
-        if (data != null) {
-            data = null;
-            GTCEu.LOGGER.debug("VirtualEnderRegistry has been unloaded");
-        }
+    public <T extends VirtualEntry> @Nullable T getEntry(@Nullable UUID owner, EntryTypes<T> type, String name) {
+        if (owner == null) return PUBLIC_REGISTRY.getEntry(type, name);
+        return getRegistry(owner).getEntry(type, name);
     }
 
-    public <T extends VirtualEntry> T getEntry(@Nullable UUID owner, EntryTypes<T> type, String name) {
-        return getRegistry(owner).getEntry(type, name);
+    public <T extends VirtualEntry> Map<String, VirtualEntry> getEntries(@Nullable UUID owner, EntryTypes<T> type) {
+        if (owner == null) return PUBLIC_REGISTRY.getEntries(type);
+        return VIRTUAL_REGISTRIES.get(owner).getEntries(type);
     }
 
     public void addEntry(@Nullable UUID owner, String name, VirtualEntry entry) {
-        getRegistry(owner).addEntry(name, entry);
+        if (owner == null) PUBLIC_REGISTRY.addEntry(name, entry);
+        else getRegistry(owner).addEntry(name, entry);
     }
 
     public boolean hasEntry(@Nullable UUID owner, EntryTypes<?> type, String name) {
+        if (owner == null) return PUBLIC_REGISTRY.contains(type, name);
         return getRegistry(owner).contains(type, name);
     }
 
-    public @NotNull <T extends VirtualEntry> T getOrCreateEntry(@Nullable UUID owner, EntryTypes<T> type, String name) {
+    public <T extends VirtualEntry> T getOrCreateEntry(@Nullable UUID owner, EntryTypes<T> type, String name) {
         if (!hasEntry(owner, type, name)) addEntry(owner, name, type.createInstance());
-        return getEntry(owner, type, name);
+        return Objects.requireNonNull(getEntry(owner, type, name));
     }
 
     /**
@@ -75,35 +62,33 @@ public boolean hasEntry(@Nullable UUID owner, EntryTypes<?> type, String name) {
      * @param type  Type of the registry to remove from
      * @param name  The name of the entry
      */
-    public void deleteEntry(@Nullable UUID owner, EntryTypes<?> type, String name) {
+    public void forceDeleteEntry(@Nullable UUID owner, EntryTypes<?> type, String name) {
+        if (owner == null) {
+            PUBLIC_REGISTRY.deleteEntry(type, name);
+            return;
+        }
+
         var registry = getRegistry(owner);
         if (registry.contains(type, name)) {
             registry.deleteEntry(type, name);
-            return;
         }
-        GTCEu.LOGGER.warn("Attempted to delete {} entry {} of type {}, which does not exist",
-                owner == null ? "public" : String.format("private [%s]", owner), name, type);
     }
 
-    public <T extends VirtualEntry> void deleteEntryIf(@Nullable UUID owner, EntryTypes<T> type, String name,
-                                                       Predicate<T> shouldDelete) {
+    public <T extends VirtualEntry> void tryDeleteEntry(@Nullable UUID owner, EntryTypes<T> type, String name) {
         T entry = getEntry(owner, type, name);
-        if (entry != null && shouldDelete.test(entry)) deleteEntry(owner, type, name);
-    }
-
-    public Set<String> getEntryNames(UUID owner, EntryTypes<?> type) {
-        return getRegistry(owner).getEntryNames(type);
+        if (entry == null) return;
+        if (entry.canRemove()) forceDeleteEntry(owner, type, name);
     }
 
     private VirtualRegistryMap getRegistry(UUID owner) {
-        if (data == null) getInstance();
-        return data.VIRTUAL_REGISTRIES.computeIfAbsent(owner, key -> new VirtualRegistryMap());
+        return VIRTUAL_REGISTRIES.computeIfAbsent(owner, key -> new VirtualRegistryMap());
     }
 
     public final void readFromNBT(CompoundTag nbt) {
         if (nbt.contains(PUBLIC_KEY)) {
-            VIRTUAL_REGISTRIES.put(null, new VirtualRegistryMap(nbt.getCompound(PUBLIC_KEY)));
+            PUBLIC_REGISTRY = new VirtualRegistryMap(nbt.getCompound(PUBLIC_KEY));
         }
+
         if (nbt.contains(PRIVATE_KEY)) {
             CompoundTag privateEntries = nbt.getCompound(PRIVATE_KEY);
             for (String owner : privateEntries.getAllKeys()) {
@@ -113,17 +98,14 @@ public final void readFromNBT(CompoundTag nbt) {
         }
     }
 
-    @NotNull
     @Override
-    public final CompoundTag save(@NotNull CompoundTag tag) {
+    public final CompoundTag save(CompoundTag tag) {
         var privateTag = new CompoundTag();
+        tag.put(PUBLIC_KEY, PUBLIC_REGISTRY.serializeNBT());
         for (var owner : VIRTUAL_REGISTRIES.keySet()) {
+            if (VIRTUAL_REGISTRIES.get(owner).isEmpty()) continue;
             var mapTag = VIRTUAL_REGISTRIES.get(owner).serializeNBT();
-            if (owner != null) {
-                privateTag.put(owner.toString(), mapTag);
-            } else {
-                tag.put(PUBLIC_KEY, mapTag);
-            }
+            privateTag.put(owner.toString(), mapTag);
         }
         tag.put(PRIVATE_KEY, privateTag);
         return tag;
diff --git a/src/main/java/com/gregtechceu/gtceu/api/misc/virtualregistry/VirtualEntry.java b/src/main/java/com/gregtechceu/gtceu/api/misc/virtualregistry/VirtualEntry.java
index b4f8c322012..38851cc9fa1 100644
--- a/src/main/java/com/gregtechceu/gtceu/api/misc/virtualregistry/VirtualEntry.java
+++ b/src/main/java/com/gregtechceu/gtceu/api/misc/virtualregistry/VirtualEntry.java
@@ -6,7 +6,6 @@
 import lombok.Getter;
 import lombok.Setter;
 import lombok.experimental.Accessors;
-import org.jetbrains.annotations.NotNull;
 
 import java.util.Locale;
 
@@ -19,8 +18,8 @@ public abstract class VirtualEntry implements INBTSerializable<CompoundTag> {
     protected static final String DESC_KEY = "description";
 
     @Setter
-    @NotNull
     private String description = "";
+    @Getter
     private int color = 0xFFFFFFFF;
     private String colorStr = DEFAULT_COLOR;
 
@@ -76,6 +75,6 @@ public void deserializeNBT(CompoundTag nbt) {
     }
 
     public boolean canRemove() {
-        return this.description.isEmpty();
+        return this.description.isBlank();
     }
 }
diff --git a/src/main/java/com/gregtechceu/gtceu/api/misc/virtualregistry/VirtualRegistryMap.java b/src/main/java/com/gregtechceu/gtceu/api/misc/virtualregistry/VirtualRegistryMap.java
index 3d48f8b0200..3601c71e247 100644
--- a/src/main/java/com/gregtechceu/gtceu/api/misc/virtualregistry/VirtualRegistryMap.java
+++ b/src/main/java/com/gregtechceu/gtceu/api/misc/virtualregistry/VirtualRegistryMap.java
@@ -1,21 +1,19 @@
 package com.gregtechceu.gtceu.api.misc.virtualregistry;
 
 import net.minecraft.nbt.CompoundTag;
+import net.minecraft.nbt.ListTag;
+import net.minecraft.nbt.Tag;
 import net.minecraft.resources.ResourceLocation;
 import net.minecraftforge.common.util.INBTSerializable;
 
-import org.jetbrains.annotations.NotNull;
+import it.unimi.dsi.fastutil.objects.Object2ObjectOpenHashMap;
 import org.jetbrains.annotations.Nullable;
 
-import java.util.Collections;
-import java.util.HashSet;
-import java.util.Map;
-import java.util.Set;
-import java.util.concurrent.ConcurrentHashMap;
+import java.util.*;
 
 public class VirtualRegistryMap implements INBTSerializable<CompoundTag> {
 
-    private final Map<EntryTypes<?>, Map<String, VirtualEntry>> registryMap = new ConcurrentHashMap<>();
+    private final Map<EntryTypes<?>, Map<String, VirtualEntry>> registryMap = new Object2ObjectOpenHashMap<>();
 
     public VirtualRegistryMap() {}
 
@@ -29,7 +27,11 @@ public VirtualRegistryMap(CompoundTag tag) {
     }
 
     public void addEntry(String name, VirtualEntry entry) {
-        registryMap.computeIfAbsent(entry.getType(), k -> new ConcurrentHashMap<>()).put(name, entry);
+        registryMap.computeIfAbsent(entry.getType(), k -> new Object2ObjectOpenHashMap<>()).put(name, entry);
+    }
+
+    public <T extends VirtualEntry> Map<String, VirtualEntry> getEntries(EntryTypes<T> type) {
+        return registryMap.getOrDefault(type, new Object2ObjectOpenHashMap<>());
     }
 
     public boolean contains(EntryTypes<?> type, String name) {
@@ -50,17 +52,18 @@ public void clear() {
         registryMap.clear();
     }
 
-    public Set<String> getEntryNames(EntryTypes<?> type) {
-        return new HashSet<>(registryMap.getOrDefault(type, Collections.emptyMap()).keySet());
+    public boolean isEmpty() {
+        return registryMap.isEmpty();
     }
 
     @Override
-    public @NotNull CompoundTag serializeNBT() {
+    public CompoundTag serializeNBT() {
         CompoundTag tag = new CompoundTag();
         for (Map.Entry<EntryTypes<?>, Map<String, VirtualEntry>> entry : registryMap.entrySet()) {
-            CompoundTag entriesTag = new CompoundTag();
-            for (Map.Entry<String, VirtualEntry> subEntry : entry.getValue().entrySet()) {
-                entriesTag.put(subEntry.getKey(), subEntry.getValue().serializeNBT());
+            ListTag entriesTag = new ListTag();
+            for (VirtualEntry innerEntry : entry.getValue().values()) {
+                if (innerEntry.canRemove()) continue;
+                entriesTag.add(innerEntry.serializeNBT());
             }
             tag.put(entry.getKey().toString(), entriesTag);
         }
@@ -70,17 +73,30 @@ public Set<String> getEntryNames(EntryTypes<?> type) {
     @Override
     public void deserializeNBT(CompoundTag nbt) {
         for (String entryTypeString : nbt.getAllKeys()) {
-            EntryTypes<?> type = entryTypeString.contains(":") ?
-                    EntryTypes.fromLocation(ResourceLocation.tryParse(entryTypeString)) :
-                    EntryTypes.fromString(entryTypeString);
-
+            ResourceLocation entryTypeLoc = ResourceLocation.tryParse(entryTypeString);
+            if (entryTypeLoc == null) continue;
+            EntryTypes<?> type = EntryTypes.fromLocation(entryTypeLoc);
             if (type == null) continue;
 
-            CompoundTag virtualEntries = nbt.getCompound(entryTypeString);
-            for (String name : virtualEntries.getAllKeys()) {
-                CompoundTag entryTag = virtualEntries.getCompound(name);
-                addEntry(name, type.createInstance(entryTag));
+            Tag virtualEntries = nbt.get(entryTypeString);
+
+            // backwards compat
+            if (virtualEntries instanceof CompoundTag compoundTag) {
+                for (String name : compoundTag.getAllKeys()) {
+                    CompoundTag entryTag = compoundTag.getCompound(name);
+                    VirtualEntry entry = type.createInstance(entryTag);
+                    if (entry.canRemove()) continue;
+                    addEntry(entry.getColorStr(), type.createInstance(entryTag));
+                }
+            } else {
+                ListTag listTag = (ListTag) virtualEntries;
+                for (int i = 0; i < Objects.requireNonNull(listTag).size(); i++) {
+                    var entry = type.createInstance(listTag.getCompound(i));
+                    if (entry.canRemove()) continue;
+                    addEntry(entry.getColorStr(), entry);
+                }
             }
+
         }
     }
 }
diff --git a/src/main/java/com/gregtechceu/gtceu/api/misc/virtualregistry/entries/VirtualItemStorage.java b/src/main/java/com/gregtechceu/gtceu/api/misc/virtualregistry/entries/VirtualItemStorage.java
index 755964107b0..80296879c10 100644
--- a/src/main/java/com/gregtechceu/gtceu/api/misc/virtualregistry/entries/VirtualItemStorage.java
+++ b/src/main/java/com/gregtechceu/gtceu/api/misc/virtualregistry/entries/VirtualItemStorage.java
@@ -8,7 +8,6 @@
 import net.minecraft.nbt.CompoundTag;
 
 import lombok.Getter;
-import org.jetbrains.annotations.NotNull;
 
 import javax.annotation.ParametersAreNonnullByDefault;
 
@@ -18,7 +17,6 @@ public class VirtualItemStorage extends VirtualEntry {
 
     protected static final int DEFAULT_SLOT_AMOUNT = 1;
 
-    @NotNull
     @Getter
     private final CustomItemStackHandler handler;
 
diff --git a/src/main/java/com/gregtechceu/gtceu/api/misc/virtualregistry/entries/VirtualRedstone.java b/src/main/java/com/gregtechceu/gtceu/api/misc/virtualregistry/entries/VirtualRedstone.java
index 74a1cfc7987..ac6c1437540 100644
--- a/src/main/java/com/gregtechceu/gtceu/api/misc/virtualregistry/entries/VirtualRedstone.java
+++ b/src/main/java/com/gregtechceu/gtceu/api/misc/virtualregistry/entries/VirtualRedstone.java
@@ -2,21 +2,16 @@
 
 import com.gregtechceu.gtceu.api.misc.virtualregistry.EntryTypes;
 import com.gregtechceu.gtceu.api.misc.virtualregistry.VirtualEntry;
-
-import net.minecraft.nbt.CompoundTag;
+import com.gregtechceu.gtceu.common.cover.ender.EnderRedstoneLinkCover;
 
 import it.unimi.dsi.fastutil.objects.Object2ShortMap;
 import it.unimi.dsi.fastutil.objects.Object2ShortOpenHashMap;
 import lombok.Getter;
 
-import java.util.UUID;
-
 public class VirtualRedstone extends VirtualEntry {
 
-    private static final String MEMBERS_KEY = "members";
-
     @Getter
-    private final Object2ShortMap<UUID> members = new Object2ShortOpenHashMap<>();
+    private final Object2ShortMap<EnderRedstoneLinkCover> members = new Object2ShortOpenHashMap<>();
 
     public VirtualRedstone() {}
 
@@ -24,17 +19,17 @@ public int getSignal() {
         return members.values().intStream().max().orElse(0);
     }
 
-    public void addMember(UUID uuid) {
-        members.put(uuid, (short) 0);
+    public void addMember(EnderRedstoneLinkCover cover) {
+        members.put(cover, (short) 0);
     }
 
-    public void setSignal(UUID uuid, int signal) {
-        if (!members.containsKey(uuid)) return;
-        members.put(uuid, (short) signal);
+    public void setSignal(EnderRedstoneLinkCover cover, int signal) {
+        if (!members.containsKey(cover)) return;
+        members.put(cover, (short) signal);
     }
 
-    public void removeMember(UUID uuid) {
-        members.removeShort(uuid);
+    public void removeMember(EnderRedstoneLinkCover cover) {
+        members.removeShort(cover);
     }
 
     @Override
@@ -42,25 +37,6 @@ public EntryTypes<? extends VirtualEntry> getType() {
         return EntryTypes.ENDER_REDSTONE;
     }
 
-    @Override
-    public CompoundTag serializeNBT() {
-        CompoundTag tag = super.serializeNBT();
-        CompoundTag tag2 = new CompoundTag();
-        for (var entry : members.object2ShortEntrySet())
-            tag2.putShort(entry.getKey().toString(), entry.getShortValue());
-        tag.put(MEMBERS_KEY, tag2);
-        return tag;
-    }
-
-    @Override
-    public void deserializeNBT(CompoundTag nbt) {
-        super.deserializeNBT(nbt);
-        CompoundTag tag = nbt.getCompound(MEMBERS_KEY);
-        for (String uuid : tag.getAllKeys()) {
-            members.put(UUID.fromString(uuid), tag.getShort(uuid));
-        }
-    }
-
     @Override
     public boolean equals(Object o) {
         if (!(o instanceof VirtualRedstone other)) return false;
diff --git a/src/main/java/com/gregtechceu/gtceu/api/misc/virtualregistry/entries/VirtualTank.java b/src/main/java/com/gregtechceu/gtceu/api/misc/virtualregistry/entries/VirtualTank.java
index b142de09b9a..cc0c8d95ea4 100644
--- a/src/main/java/com/gregtechceu/gtceu/api/misc/virtualregistry/entries/VirtualTank.java
+++ b/src/main/java/com/gregtechceu/gtceu/api/misc/virtualregistry/entries/VirtualTank.java
@@ -8,14 +8,12 @@
 import net.minecraftforge.fluids.capability.templates.FluidTank;
 
 import lombok.Getter;
-import org.jetbrains.annotations.NotNull;
 
 public class VirtualTank extends VirtualEntry {
 
     public static final int DEFAULT_CAPACITY = 160_000; // 160B for per second transfer
     protected static final String CAPACITY_KEY = "capacity";
     protected static final String FLUID_KEY = "fluid";
-    @NotNull
     @Getter
     private final FluidTank fluidTank;
     private int capacity;
diff --git a/src/main/java/com/gregtechceu/gtceu/api/misc/virtualregistry/entries/package-info.java b/src/main/java/com/gregtechceu/gtceu/api/misc/virtualregistry/entries/package-info.java
new file mode 100644
index 00000000000..d5df35c7c58
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/api/misc/virtualregistry/entries/package-info.java
@@ -0,0 +1,4 @@
+@NotNullByDefault
+package com.gregtechceu.gtceu.api.misc.virtualregistry.entries;
+
+import org.jetbrains.annotations.NotNullByDefault;
diff --git a/src/main/java/com/gregtechceu/gtceu/api/misc/virtualregistry/package-info.java b/src/main/java/com/gregtechceu/gtceu/api/misc/virtualregistry/package-info.java
new file mode 100644
index 00000000000..d99aeae2306
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/api/misc/virtualregistry/package-info.java
@@ -0,0 +1,4 @@
+@NotNullByDefault
+package com.gregtechceu.gtceu.api.misc.virtualregistry;
+
+import org.jetbrains.annotations.NotNullByDefault;
diff --git a/src/main/java/com/gregtechceu/gtceu/api/mui/GTGuiScreen.java b/src/main/java/com/gregtechceu/gtceu/api/mui/GTGuiScreen.java
new file mode 100644
index 00000000000..f4a84a9d66a
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/api/mui/GTGuiScreen.java
@@ -0,0 +1,39 @@
+package com.gregtechceu.gtceu.api.mui;
+
+import com.gregtechceu.gtceu.common.mui.GTGuiTheme;
+
+import net.minecraft.client.gui.navigation.ScreenRectangle;
+import net.minecraftforge.api.distmarker.Dist;
+import net.minecraftforge.api.distmarker.OnlyIn;
+
+import brachy.modularui.screen.ModularPanel;
+import brachy.modularui.screen.ModularScreen;
+import org.jetbrains.annotations.NotNull;
+
+import static com.gregtechceu.gtceu.GTCEu.MOD_ID;
+
+@OnlyIn(Dist.CLIENT)
+public class GTGuiScreen extends ModularScreen {
+
+    public GTGuiScreen(@NotNull ModularPanel<?> mainPanel) {
+        this(mainPanel, GTGuiTheme.STANDARD);
+    }
+
+    public GTGuiScreen(@NotNull ModularPanel<?> mainPanel, GTGuiTheme theme) {
+        this(MOD_ID, mainPanel, theme);
+    }
+
+    public GTGuiScreen(@NotNull String owner, @NotNull ModularPanel<?> mainPanel, GTGuiTheme theme) {
+        this(owner, mainPanel, theme.getId());
+    }
+
+    public GTGuiScreen(String owner, ModularPanel<?> mainPanel, String themeId) {
+        super(owner, mainPanel);
+        useTheme(themeId);
+    }
+
+    @Override
+    public @NotNull ScreenRectangle getRectangle() {
+        return super.getRectangle();
+    }
+}
diff --git a/src/main/java/com/gregtechceu/gtceu/api/mui/IItemUIHolder.java b/src/main/java/com/gregtechceu/gtceu/api/mui/IItemUIHolder.java
new file mode 100644
index 00000000000..21a2154c7a5
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/api/mui/IItemUIHolder.java
@@ -0,0 +1,51 @@
+package com.gregtechceu.gtceu.api.mui;
+
+import com.gregtechceu.gtceu.api.item.component.IInteractionItem;
+
+import net.minecraft.world.InteractionHand;
+import net.minecraft.world.InteractionResult;
+import net.minecraft.world.InteractionResultHolder;
+import net.minecraft.world.entity.player.Player;
+import net.minecraft.world.item.Item;
+import net.minecraft.world.item.ItemStack;
+import net.minecraft.world.item.context.UseOnContext;
+import net.minecraft.world.level.Level;
+import net.minecraftforge.api.distmarker.Dist;
+import net.minecraftforge.api.distmarker.OnlyIn;
+
+import brachy.modularui.api.IUIHolder;
+import brachy.modularui.factory.PlayerInventoryGuiData;
+import brachy.modularui.factory.PlayerInventoryUIFactory;
+import brachy.modularui.screen.ModularPanel;
+import brachy.modularui.screen.ModularScreen;
+
+public interface IItemUIHolder extends IUIHolder<PlayerInventoryGuiData<?>>, IInteractionItem {
+
+    default boolean shouldOpenUI() {
+        return true;
+    }
+
+    @Override
+    default InteractionResultHolder<ItemStack> use(Item item, Level level, Player player, InteractionHand usedHand) {
+        if (!shouldOpenUI())
+            return IInteractionItem.super.use(item, level, player, usedHand);
+        if (level.isClientSide)
+            PlayerInventoryUIFactory.INSTANCE.openFromHandClient(usedHand);
+        return InteractionResultHolder.sidedSuccess(player.getItemInHand(usedHand), level.isClientSide);
+    }
+
+    @Override
+    default InteractionResult useOn(UseOnContext context) {
+        if (!shouldOpenUI())
+            return IInteractionItem.super.useOn(context);
+        if (context.getLevel().isClientSide)
+            PlayerInventoryUIFactory.INSTANCE.openFromHandClient(context.getHand());
+        return InteractionResult.SUCCESS;
+    }
+
+    @Override
+    @OnlyIn(Dist.CLIENT)
+    default ModularScreen createScreen(PlayerInventoryGuiData<?> data, ModularPanel<?> mainPanel) {
+        return new GTGuiScreen(mainPanel);
+    }
+}
diff --git a/src/main/java/com/gregtechceu/gtceu/api/mui/factory/CoverUIFactory.java b/src/main/java/com/gregtechceu/gtceu/api/mui/factory/CoverUIFactory.java
new file mode 100644
index 00000000000..b426f33934e
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/api/mui/factory/CoverUIFactory.java
@@ -0,0 +1,84 @@
+package com.gregtechceu.gtceu.api.mui.factory;
+
+import com.gregtechceu.gtceu.GTCEu;
+import com.gregtechceu.gtceu.api.capability.GTCapability;
+import com.gregtechceu.gtceu.api.capability.ICoverable;
+import com.gregtechceu.gtceu.api.cover.CoverBehavior;
+import com.gregtechceu.gtceu.api.cover.IMuiCover;
+
+import net.minecraft.core.BlockPos;
+import net.minecraft.core.Direction;
+import net.minecraft.network.FriendlyByteBuf;
+import net.minecraft.server.level.ServerPlayer;
+import net.minecraft.world.entity.player.Player;
+import net.minecraft.world.level.block.entity.BlockEntity;
+
+import brachy.modularui.api.IUIHolder;
+import brachy.modularui.factory.AbstractUIFactory;
+import brachy.modularui.factory.GuiManager;
+import brachy.modularui.factory.SidedPosGuiData;
+import org.jetbrains.annotations.NotNull;
+
+import java.util.Objects;
+
+public class CoverUIFactory extends AbstractUIFactory<SidedPosGuiData> {
+
+    public static final CoverUIFactory INSTANCE = new CoverUIFactory();
+
+    private CoverUIFactory() {
+        super(GTCEu.id("cover"));
+    }
+
+    public void open(ServerPlayer player, IMuiCover cover) {
+        Objects.requireNonNull(player);
+        Objects.requireNonNull(cover);
+        if (cover.isRemoved()) {
+            throw new IllegalArgumentException("Can't open Cover GUI on invalid cover holder!");
+        }
+        if (player.level() != cover.self().coverHolder.getLevel()) {
+            throw new IllegalArgumentException("Cover must be in same dimension as the player!");
+        }
+        BlockPos pos = cover.self().coverHolder.getBlockPos();
+        Direction side = cover.self().attachedSide;
+        SidedPosGuiData data = new SidedPosGuiData(player, pos, side);
+        GuiManager.open(this, data, player);
+    }
+
+    @Override
+    public @NotNull IUIHolder<SidedPosGuiData> getGuiHolder(SidedPosGuiData data) {
+        BlockEntity be = data.getBlockEntity();
+        if (be == null) {
+            throw new IllegalStateException("Could not get gui for null BlockEntity!");
+        }
+        ICoverable coverHolder = be.getCapability(GTCapability.CAPABILITY_COVERABLE, data.getSide())
+                .resolve().orElse(null);
+        if (coverHolder == null) {
+            throw new IllegalStateException("Could not get CoverHolder for found BlockEntity!");
+        }
+        CoverBehavior cover = coverHolder.getCoverAtSide(data.getSide());
+        if (cover == null) {
+            throw new IllegalStateException("Could not find cover at side " + data.getSide() +
+                    " for found CoverHolder!");
+        }
+        if (!(cover instanceof IMuiCover uiCover)) {
+            throw new IllegalStateException("Cover at side " + data.getSide() + " is not a gui holder!");
+        }
+        return uiCover;
+    }
+
+    @Override
+    public boolean canInteractWith(Player player, SidedPosGuiData guiData) {
+        return guiData.getSquaredDistance(player) <= 8 * 8;
+    }
+
+    @Override
+    public void writeGuiData(SidedPosGuiData guiData, FriendlyByteBuf buffer) {
+        buffer.writeBlockPos(guiData.getBlockPos());
+        buffer.writeByte(guiData.getSide().get3DDataValue());
+    }
+
+    @Override
+    public @NotNull SidedPosGuiData readGuiData(Player player, FriendlyByteBuf buffer) {
+        return new SidedPosGuiData(player, buffer.readBlockPos(), Direction.from3DDataValue(buffer.readByte()));
+    }
+}
diff --git a/src/main/java/com/gregtechceu/gtceu/api/mui/factory/MachineUIFactory.java b/src/main/java/com/gregtechceu/gtceu/api/mui/factory/MachineUIFactory.java
new file mode 100644
index 00000000000..beaedb6ed98
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/api/mui/factory/MachineUIFactory.java
@@ -0,0 +1,94 @@
+package com.gregtechceu.gtceu.api.mui.factory;
+
+import com.gregtechceu.gtceu.GTCEu;
+import com.gregtechceu.gtceu.api.machine.MetaMachine;
+import com.gregtechceu.gtceu.api.machine.feature.IMuiMachine;
+import com.gregtechceu.gtceu.api.mui.GTGuiScreen;
+
+import net.minecraft.core.BlockPos;
+import net.minecraft.network.FriendlyByteBuf;
+import net.minecraft.server.level.ServerPlayer;
+import net.minecraft.world.entity.player.Player;
+import net.minecraftforge.api.distmarker.Dist;
+import net.minecraftforge.api.distmarker.OnlyIn;
+
+import brachy.modularui.api.IUIHolder;
+import brachy.modularui.factory.AbstractUIFactory;
+import brachy.modularui.factory.GuiManager;
+import brachy.modularui.factory.PosGuiData;
+import brachy.modularui.screen.ModularPanel;
+import brachy.modularui.screen.ModularScreen;
+import org.jetbrains.annotations.NotNull;
+
+import java.util.Objects;
+
+import static com.gregtechceu.gtceu.GTCEu.MOD_ID;
+
+public class MachineUIFactory extends AbstractUIFactory<PosGuiData> {
+
+    public static final MachineUIFactory INSTANCE = new MachineUIFactory();
+
+    private MachineUIFactory() {
+        super(GTCEu.id("machine"));
+    }
+
+    public void open(ServerPlayer player, IMuiMachine machine) {
+        Objects.requireNonNull(player);
+        Objects.requireNonNull(machine);
+        if (machine.self().isRemoved()) {
+            throw new IllegalArgumentException("Can't open invalid MetaMachine GUI!");
+        }
+        if (player.level() != machine.self().getLevel()) {
+            throw new IllegalArgumentException("MetaMachine must be in same dimension as the player!");
+        }
+        BlockPos pos = machine.self().getBlockPos();
+        PosGuiData data = new PosGuiData(player, pos);
+        GuiManager.open(this, data, player);
+    }
+
+    public void open(Player player, BlockPos pos) {
+        Objects.requireNonNull(player);
+        Objects.requireNonNull(pos);
+        PosGuiData data = new PosGuiData(player, pos);
+        GuiManager.open(this, data, (ServerPlayer) player);
+    }
+
+    @Override
+    public @NotNull IUIHolder<PosGuiData> getGuiHolder(PosGuiData data) {
+        MetaMachine machine = getMachine(data);
+        if (machine.getDefinition().getUI() != null) {
+            return machine.getDefinition().getUI();
+        }
+        return Objects.requireNonNull(castUIHolder(machine), "Found MetaMachine is not a gui holder!");
+    }
+
+    @Override
+    public boolean canInteractWith(Player player, PosGuiData guiData) {
+        return player == guiData.getPlayer() && getMachine(guiData) != null &&
+                guiData.getSquaredDistance(player) <= 8 * 8;
+    }
+
+    @Override
+    public void writeGuiData(PosGuiData guiData, FriendlyByteBuf buffer) {
+        buffer.writeBlockPos(guiData.getBlockPos());
+    }
+
+    @Override
+    public @NotNull PosGuiData readGuiData(Player player, FriendlyByteBuf buffer) {
+        return new PosGuiData(player, buffer.readBlockPos());
+    }
+
+    public static MetaMachine getMachine(PosGuiData data) {
+        return MetaMachine.getMachine(data.getLevel(), data.getBlockPos());
+    }
+
+    @Override
+    @OnlyIn(Dist.CLIENT)
+    public ModularScreen createScreen(PosGuiData data, ModularPanel<?> mainPanel) {
+        return new GTGuiScreen(MOD_ID, mainPanel, getThemeId(data));
+    }
+
+    public String getThemeId(PosGuiData data) {
+        return getMachine(data).getDefinition().getThemeId();
+    }
+}
diff --git a/src/main/java/com/gregtechceu/gtceu/api/mui/factory/ModularItemUIFactory.java b/src/main/java/com/gregtechceu/gtceu/api/mui/factory/ModularItemUIFactory.java
new file mode 100644
index 00000000000..6813c365668
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/api/mui/factory/ModularItemUIFactory.java
@@ -0,0 +1,33 @@
+package com.gregtechceu.gtceu.api.mui.factory;
+
+import com.gregtechceu.gtceu.GTCEu;
+
+import net.minecraft.network.FriendlyByteBuf;
+import net.minecraft.world.entity.player.Player;
+
+import brachy.modularui.api.IUIHolder;
+import brachy.modularui.factory.AbstractUIFactory;
+import brachy.modularui.factory.GuiData;
+import org.jetbrains.annotations.NotNull;
+
+public class ModularItemUIFactory extends AbstractUIFactory<GuiData> {
+
+    public static final ModularItemUIFactory INSTANCE = new ModularItemUIFactory();
+
+    protected ModularItemUIFactory() {
+        super(GTCEu.id("modular_item"));
+    }
+
+    @Override
+    public @NotNull IUIHolder<GuiData> getGuiHolder(GuiData data) {
+        return new ModularItemUIHolder(data.getPlayer());
+    }
+
+    @Override
+    public void writeGuiData(GuiData data, FriendlyByteBuf buf) {}
+
+    @Override
+    public @NotNull GuiData readGuiData(Player player, FriendlyByteBuf buf) {
+        return new GuiData(player);
+    }
+}
diff --git a/src/main/java/com/gregtechceu/gtceu/api/mui/factory/ModularItemUIHolder.java b/src/main/java/com/gregtechceu/gtceu/api/mui/factory/ModularItemUIHolder.java
new file mode 100644
index 00000000000..0312ff44c84
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/api/mui/factory/ModularItemUIHolder.java
@@ -0,0 +1,266 @@
+package com.gregtechceu.gtceu.api.mui.factory;
+
+import com.gregtechceu.gtceu.api.capability.GTCapabilityHelper;
+import com.gregtechceu.gtceu.api.item.module.AppliedItemModule;
+import com.gregtechceu.gtceu.api.item.module.IModularItem;
+import com.gregtechceu.gtceu.api.item.module.ItemModule;
+import com.gregtechceu.gtceu.api.item.module.ItemModuleSlot;
+import com.gregtechceu.gtceu.api.mui.GTGuiScreen;
+import com.gregtechceu.gtceu.common.mui.GTGuiTextures;
+import com.gregtechceu.gtceu.common.mui.GTMuiWidgets;
+
+import net.minecraft.network.FriendlyByteBuf;
+import net.minecraft.world.entity.player.Player;
+import net.minecraft.world.item.ItemStack;
+import net.minecraftforge.items.wrapper.PlayerArmorInvWrapper;
+
+import brachy.modularui.api.IPanelHandler;
+import brachy.modularui.api.IUIHolder;
+import brachy.modularui.api.drawable.IDrawable;
+import brachy.modularui.api.drawable.IKey;
+import brachy.modularui.api.widget.IWidget;
+import brachy.modularui.drawable.GuiDraw;
+import brachy.modularui.factory.GuiData;
+import brachy.modularui.screen.ModularPanel;
+import brachy.modularui.screen.ModularScreen;
+import brachy.modularui.screen.UISettings;
+import brachy.modularui.screen.viewport.ModularGuiContext;
+import brachy.modularui.theme.WidgetThemeEntry;
+import brachy.modularui.utils.Alignment;
+import brachy.modularui.value.sync.*;
+import brachy.modularui.widgets.*;
+import brachy.modularui.widgets.layout.Flow;
+import brachy.modularui.widgets.layout.Grid;
+import brachy.modularui.widgets.slot.ItemSlot;
+import lombok.AccessLevel;
+import lombok.Getter;
+import lombok.Setter;
+import org.jetbrains.annotations.NotNull;
+
+import java.util.List;
+
+@Setter(AccessLevel.PRIVATE)
+@Getter(AccessLevel.PRIVATE)
+public class ModularItemUIHolder implements IUIHolder<GuiData> {
+
+    private final Player player;
+    private boolean inventoryUnlocked = false;
+    private IntSyncValue selectedSlotSyncValue = null;
+    private int selectedSlot = -1;
+    private int panelCount = 0;
+    private DynamicSyncHandler dynamicSyncHandler = null;
+
+    public ModularItemUIHolder(Player player) {
+        this.player = player;
+    }
+
+    private void registerSyncValues(PanelSyncManager syncManager) {
+        dynamicSyncHandler = new DynamicSyncHandler();
+        dynamicSyncHandler.widgetProvider(this::getStackInfoWidget);
+        selectedSlotSyncValue = SyncHandlers.intNumber(this::getSelectedSlot, this::setSelectedSlot);
+        syncManager.syncValue("selectedSlot", selectedSlotSyncValue);
+    }
+
+    @Override
+    public ModularPanel<?> buildUI(GuiData data, PanelSyncManager syncManager, UISettings settings) {
+        registerSyncValues(syncManager);
+        return new ModularPanel<>("modularItem")
+                .leftRel(.2f)
+                .width(250)
+                .child(GTMuiWidgets.createTitleBar(IDrawable.EMPTY.asIcon().size(0), "Modules", 250,
+                        GTGuiTextures.BACKGROUND))
+                .child(playerInventory())
+                .child(new ToggleButton()
+                        .value(new BooleanSyncValue(this::isInventoryUnlocked, this::setInventoryUnlocked))
+                        .overlay(true, GTGuiTextures.BUTTON_LOCK)
+                        .overlay(false, GTGuiTextures.BUTTON_LOCK)
+                        .invertSelected(true)
+                        .left(7).bottom(7))
+                .child(new DynamicSyncedWidget<>()
+                        .syncHandler(dynamicSyncHandler)
+                        .initialChild(new TextWidget<>("Select an item")
+                                .center())
+                        .widthRel(1)
+                        .height(85)
+                        .top(5));
+    }
+
+    private IWidget getStackInfoWidget(PanelSyncManager psm, FriendlyByteBuf buf) {
+        ItemStack stack = getSelectedItem();
+        IModularItem modularItem = GTCapabilityHelper.getModularItem(stack);
+        List<ItemModuleSlot> slots = modularItem == null ? List.of() : modularItem.getSlots();
+        return Flow.col()
+                .horizontalCenter()
+                .widthRel(1)
+                .child(Flow.row()
+                        .coverChildren()
+                        .childPadding(5)
+                        .child(new ItemDisplayWidget().item(stack))
+                        .child(new TextWidget<>(IKey.dynamic(stack::getHoverName))))
+                .childIf(modularItem == null,
+                        () -> new TextWidget<>(IKey.str("This item does not accept modules")).center())
+                .childIf(modularItem != null, () -> new Grid()
+                        .minColWidth(100)
+                        .widthRel(1)
+                        .minRowHeight(10)
+                        .margin(5)
+                        .mapTo(2, slots.size(), index -> {
+                            assert modularItem != null;
+                            AppliedItemModule appliedModule = modularItem.getModuleInSlot(index);
+                            if (appliedModule == null) {
+                                return new ButtonWidget<>()
+                                        .height(10)
+                                        .widthRel(0.5f)
+                                        .backgroundOverlay(slots.get(index).getSlotTexture())
+                                        .overlay(IKey.lang("metaarmor.tooltip.modifier.empty").scale(0.5f));
+                            } else {
+                                ItemModule module = appliedModule.getModule();
+                                IPanelHandler panelHandler = psm.syncedPanel("module" + index, false,
+                                        (psm1, handler) -> createPanelForModule(psm1, handler, index));
+                                return new ButtonWidget<>()
+                                        .onMousePressed((x, y, button) -> {
+                                            panelHandler.openPanel();
+                                            return false;
+                                        })
+                                        .height(10)
+                                        .widthRel(0.5f)
+                                        .overlay(IKey.dynamic(() -> module.getDisplayName(appliedModule)).scale(0.5f))
+                                        .backgroundOverlay(slots.get(index).getSlotTexture())
+                                        .addTooltipElement(IKey.dynamic(module::getInfo));
+                            }
+                        }));
+    }
+
+    private ModularPanel<?> createPanelForModule(PanelSyncManager psm, IPanelHandler panelHandler, int index) {
+        ItemStack stack = getSelectedItem();
+        IModularItem modularItem = GTCapabilityHelper.getModularItem(stack);
+        assert modularItem != null;
+        AppliedItemModule appliedModule = modularItem.getModuleInSlot(index);
+        assert appliedModule != null;
+        ItemModule module = appliedModule.getModule();
+        ItemStack moduleItem = appliedModule.getModuleItem();
+        return new ModularPanel<>("module" + index)
+                .leftRelOffset(0.2f, 250 + 2 - 154 * (panelCount / 3))
+                .topRelOffset(0.5f, -83 + 80 * (panelCount++ % 3) + 2)
+                .width(154)
+                .height(80)
+                .child(Flow.col()
+                        .crossAxisAlignment(Alignment.CrossAxis.START)
+                        .left(5)
+                        .childPadding(3)
+                        .childIf(moduleItem == null || moduleItem.isEmpty(),
+                                () -> new TextWidget<>(IKey.dynamic(() -> module.getDisplayName(appliedModule)))
+                                        .scale(0.75f)
+                                        .horizontalCenter())
+                        .childIf(moduleItem != null && !moduleItem.isEmpty(), () -> {
+                            assert moduleItem != null;
+                            return Flow.row()
+                                    .coverChildren()
+                                    .padding(4)
+                                    .paddingLeft(0)
+                                    .childPadding(4)
+                                    .child(new ItemDisplayWidget().item(moduleItem))
+                                    .child(Flow.col()
+                                            .coverChildrenWidth()
+                                            .childPadding(2)
+                                            .heightRel(1)
+                                            .child(new TextWidget<>(
+                                                    IKey.dynamic(() -> module.getDisplayName(appliedModule)))
+                                                    .scale(0.75f)
+                                                    .left(0))
+                                            .child(new TextWidget<>(IKey.dynamic(moduleItem::getHoverName))
+                                                    .scale(0.6f)
+                                                    .left(0)));
+                        })
+                        .children(module.getSettings(appliedModule, psm, index)));
+    }
+
+    private ItemStack getSelectedItem() {
+        return player.getInventory().getItem(selectedSlot);
+    }
+
+    @Override
+    public ModularScreen createScreen(GuiData data, ModularPanel<?> mainPanel) {
+        return new GTGuiScreen(mainPanel);
+    }
+
+    private class InventorySlot extends ItemSlot {
+
+        private Integer index = null;
+
+        public InventorySlot index(int index) {
+            this.index = index;
+            return this;
+        }
+
+        private int getIndex() {
+            return index == null ? getSlot().getSlotIndex() : index;
+        }
+
+        @Override
+        public @NotNull Result onMousePressed(double mouseX, double mouseY, int button) {
+            if (inventoryUnlocked)
+                return super.onMousePressed(mouseX, mouseY, button);
+            selectedSlotSyncValue.setValue(getIndex());
+            dynamicSyncHandler.notifyUpdate(buf -> {});
+            return Result.SUCCESS;
+        }
+
+        @Override
+        public boolean onMouseReleased(double mouseX, double mouseY, int button) {
+            if (inventoryUnlocked)
+                return super.onMouseReleased(mouseX, mouseY, button);
+            return false;
+        }
+
+        @Override
+        protected void drawOverlay(ModularGuiContext context) {
+            if (inventoryUnlocked)
+                super.drawOverlay(context);
+            if (getIndex() == selectedSlot) {
+                GuiDraw.drawBorder(context.getGraphics(), 0, 0, 17, 17, 0xFFFFFF00, 1);
+            }
+        }
+
+        @Override
+        public void draw(ModularGuiContext context, WidgetThemeEntry<?> widgetTheme) {
+            if (!inventoryUnlocked && !isHovering() && getIndex() != selectedSlot) {
+                GuiDraw.drawRect(context.getGraphics(), 1, 1, 15, 15, 0x88444444);
+            }
+            super.draw(context, widgetTheme);
+        }
+    }
+
+    private Flow playerInventory() {
+        SlotGroupWidget slotGroupWidget = new SlotGroupWidget();
+        slotGroupWidget.coverChildren();
+        slotGroupWidget.name("player_inventory");
+        String key = "player";
+        for (int i = 0; i < 9; i++) {
+            slotGroupWidget.child(new InventorySlot()
+                    .syncHandler(key, i)
+                    .pos(i * 18, 3 * 18 + 4)
+                    .name("slot_" + i));
+        }
+        for (int i = 0; i < 27; i++) {
+            slotGroupWidget.child(new InventorySlot()
+                    .syncHandler(key, i + 9)
+                    .pos(i % 9 * 18, i / 9 * 18)
+                    .name("slot_" + (i + 9)));
+        }
+        SlotGroupWidget armorGroup = new SlotGroupWidget();
+        armorGroup.coverChildren();
+        armorGroup.name("player_armor");
+        PlayerArmorInvWrapper inv = new PlayerArmorInvWrapper(player.getInventory());
+        for (int i = 0; i < 4; i++) {
+            armorGroup.child(new InventorySlot()
+                    .index(36 + i)
+                    .slot(inv, i)
+                    .pos(0, (3 - i) * 18)
+                    .name("slot_" + (i + 36)));
+        }
+        return Flow.row()
+                .child(slotGroupWidget.bottom(7).leftRel(.5f))
+                .child(armorGroup.bottom(7).leftRelOffset(.5f, 162 / 2 + 20));
+    }
+}
diff --git a/src/main/java/com/gregtechceu/gtceu/api/mui/factory/PanelEditor.java b/src/main/java/com/gregtechceu/gtceu/api/mui/factory/PanelEditor.java
new file mode 100644
index 00000000000..a44f1c260a4
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/api/mui/factory/PanelEditor.java
@@ -0,0 +1,15 @@
+package com.gregtechceu.gtceu.api.mui.factory;
+
+import com.gregtechceu.gtceu.api.machine.MetaMachine;
+
+import brachy.modularui.factory.PosGuiData;
+import brachy.modularui.screen.ModularPanel;
+import brachy.modularui.screen.UISettings;
+import brachy.modularui.value.sync.PanelSyncManager;
+
+@FunctionalInterface
+public interface PanelEditor {
+
+    void editUI(PosGuiData data, PanelSyncManager syncManager, UISettings settings,
+                MetaMachine machine, ModularPanel<?> panel);
+}
diff --git a/src/main/java/com/gregtechceu/gtceu/api/mui/factory/PanelFactory.java b/src/main/java/com/gregtechceu/gtceu/api/mui/factory/PanelFactory.java
new file mode 100644
index 00000000000..0b166d5b795
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/api/mui/factory/PanelFactory.java
@@ -0,0 +1,63 @@
+package com.gregtechceu.gtceu.api.mui.factory;
+
+import com.gregtechceu.gtceu.api.machine.MetaMachine;
+import com.gregtechceu.gtceu.api.mui.GTGuiScreen;
+
+import net.minecraft.server.level.ServerPlayer;
+import net.minecraft.world.InteractionHand;
+import net.minecraft.world.InteractionResult;
+import net.minecraft.world.entity.player.Player;
+import net.minecraft.world.phys.BlockHitResult;
+import net.minecraftforge.api.distmarker.Dist;
+import net.minecraftforge.api.distmarker.OnlyIn;
+
+import brachy.modularui.api.IUIHolder;
+import brachy.modularui.factory.PosGuiData;
+import brachy.modularui.screen.ModularPanel;
+import brachy.modularui.screen.ModularScreen;
+import brachy.modularui.screen.UISettings;
+import brachy.modularui.value.sync.PanelSyncManager;
+
+@FunctionalInterface
+public interface PanelFactory extends IUIHolder<PosGuiData> {
+
+    @Override
+    default ModularPanel<?> buildUI(PosGuiData data, PanelSyncManager syncManager, UISettings settings) {
+        var machine = MachineUIFactory.getMachine(data);
+        return buildUIFunction(data, syncManager, settings, machine);
+    }
+
+    @Override
+    @OnlyIn(Dist.CLIENT)
+    default ModularScreen createScreen(PosGuiData data, ModularPanel<?> mainPanel) {
+        return new GTGuiScreen(mainPanel);
+    }
+
+    ModularPanel<?> buildUIFunction(PosGuiData data, PanelSyncManager syncManager, UISettings settings,
+                                    MetaMachine machine);
+
+    default boolean shouldOpenUI(Player player, InteractionHand hand, BlockHitResult hit) {
+        return true;
+    }
+
+    default InteractionResult tryToOpenUI(Player player, InteractionHand hand, BlockHitResult hit) {
+        if (this.shouldOpenUI(player, hand, hit)) {
+            if (player instanceof ServerPlayer serverPlayer) {
+                MachineUIFactory.INSTANCE.open(serverPlayer, hit.getBlockPos());
+            }
+            return InteractionResult.sidedSuccess(player.level().isClientSide);
+        } else {
+            return InteractionResult.PASS;
+        }
+    }
+
+    default PanelFactory andThen(PanelEditor... edits) {
+        return (data, syncManager, settings, machine) -> {
+            var panel = this.buildUIFunction(data, syncManager, settings, machine);
+            for (PanelEditor edit : edits) {
+                edit.editUI(data, syncManager, settings, machine, panel);
+            }
+            return panel;
+        };
+    }
+}
diff --git a/src/main/java/com/gregtechceu/gtceu/api/pattern/MultiblockShapeInfo.java b/src/main/java/com/gregtechceu/gtceu/api/pattern/MultiblockShapeInfo.java
index cc1c36353af..95e52709df7 100644
--- a/src/main/java/com/gregtechceu/gtceu/api/pattern/MultiblockShapeInfo.java
+++ b/src/main/java/com/gregtechceu/gtceu/api/pattern/MultiblockShapeInfo.java
@@ -4,31 +4,43 @@
 import com.gregtechceu.gtceu.api.data.RotationState;
 
 import com.lowdragmc.lowdraglib.utils.BlockInfo;
-import com.lowdragmc.lowdraglib.utils.Builder;
 
 import net.minecraft.core.Direction;
 import net.minecraft.world.level.block.Block;
 import net.minecraft.world.level.block.state.BlockState;
 
+import lombok.Getter;
+
+import java.util.*;
 import java.util.function.Supplier;
 
 public class MultiblockShapeInfo {
 
+    @Getter
     private final BlockInfo[][][] blocks; // [z][y][x]
 
     public MultiblockShapeInfo(BlockInfo[][][] blocks) {
         this.blocks = blocks;
     }
 
-    public BlockInfo[][][] getBlocks() {
-        return blocks;
-    }
-
     public static ShapeInfoBuilder builder() {
         return new ShapeInfoBuilder();
     }
 
-    public static class ShapeInfoBuilder extends Builder<BlockInfo, ShapeInfoBuilder> {
+    public static class ShapeInfoBuilder {
+
+        protected List<String[]> shape = new ArrayList<>();
+        protected Map<Character, BlockInfo> symbolMap = new LinkedHashMap<>();
+
+        public ShapeInfoBuilder aisle(String... data) {
+            this.shape.add(data);
+            return this;
+        }
+
+        public ShapeInfoBuilder where(char symbol, BlockInfo value) {
+            this.symbolMap.put(symbol, value);
+            return this;
+        }
 
         public ShapeInfoBuilder where(char symbol, BlockState blockState) {
             return where(symbol, BlockInfo.fromBlockState(blockState));
@@ -53,11 +65,29 @@ public ShapeInfoBuilder where(char symbol, MetaMachineBlock machine, Direction f
         }
 
         private BlockInfo[][][] bake() {
-            return this.bakeArray(BlockInfo.class, BlockInfo.EMPTY);
+            BlockInfo[][][] Ts = new BlockInfo[shape.get(0)[0].length()][shape.get(0).length][shape.size()];
+            for (int z = 0; z < shape.size(); z++) { // z
+                String[] aisleEntry = shape.get(z);
+                for (int y = 0; y < shape.get(0).length; y++) {
+                    String columnEntry = aisleEntry[y];
+                    for (int x = 0; x < columnEntry.length(); x++) {
+                        BlockInfo info = symbolMap.getOrDefault(columnEntry.charAt(x), BlockInfo.EMPTY);
+                        Ts[x][y][z] = info;
+                    }
+                }
+            }
+            return Ts;
         }
 
         public MultiblockShapeInfo build() {
             return new MultiblockShapeInfo(bake());
         }
+
+        public ShapeInfoBuilder shallowCopy() {
+            ShapeInfoBuilder builder = new ShapeInfoBuilder();
+            builder.shape = new ArrayList<>(this.shape);
+            builder.symbolMap = new HashMap<>(this.symbolMap);
+            return builder;
+        }
     }
 }
diff --git a/src/main/java/com/gregtechceu/gtceu/api/placeholder/MultiLineComponent.java b/src/main/java/com/gregtechceu/gtceu/api/placeholder/MultiLineComponent.java
index ac19946fe1b..f25c0c484a6 100644
--- a/src/main/java/com/gregtechceu/gtceu/api/placeholder/MultiLineComponent.java
+++ b/src/main/java/com/gregtechceu/gtceu/api/placeholder/MultiLineComponent.java
@@ -18,6 +18,7 @@
 import java.util.Collection;
 import java.util.List;
 import java.util.Objects;
+import java.util.function.UnaryOperator;
 
 @Accessors(chain = true)
 public class MultiLineComponent extends ArrayList<MutableComponent> {
@@ -134,6 +135,16 @@ public MultiLineComponent withStyle(Style style) {
         return out;
     }
 
+    public MultiLineComponent withStyle(UnaryOperator<Style> style) {
+        MultiLineComponent out = MultiLineComponent.empty();
+        for (MutableComponent c : this) {
+            out.append(MultiLineComponent.of(c.withStyle(style)));
+            out.appendNewline();
+        }
+        if (!out.isEmpty()) out.remove(out.size() - 1);
+        return out;
+    }
+
     public MultiLineComponent withStyle(ChatFormatting... style) {
         MultiLineComponent out = MultiLineComponent.empty();
         for (MutableComponent c : this) {
diff --git a/src/main/java/com/gregtechceu/gtceu/api/placeholder/Placeholder.java b/src/main/java/com/gregtechceu/gtceu/api/placeholder/Placeholder.java
index 0e80933bf96..81a527d1991 100644
--- a/src/main/java/com/gregtechceu/gtceu/api/placeholder/Placeholder.java
+++ b/src/main/java/com/gregtechceu/gtceu/api/placeholder/Placeholder.java
@@ -36,4 +36,12 @@ protected CompoundTag getData(PlaceholderContext ctx) {
             placeholderData.put(ctx.uuid().toString(), new CompoundTag());
         return placeholderData.getCompound(ctx.uuid().toString());
     }
+
+    public boolean isView() {
+        return isPure();
+    }
+
+    public boolean isPure() {
+        return false;
+    }
 }
diff --git a/src/main/java/com/gregtechceu/gtceu/api/placeholder/PlaceholderHandler.java b/src/main/java/com/gregtechceu/gtceu/api/placeholder/PlaceholderHandler.java
index 24519f75bb4..fda0841178e 100644
--- a/src/main/java/com/gregtechceu/gtceu/api/placeholder/PlaceholderHandler.java
+++ b/src/main/java/com/gregtechceu/gtceu/api/placeholder/PlaceholderHandler.java
@@ -6,27 +6,40 @@
 import com.gregtechceu.gtceu.api.placeholder.exceptions.UnexpectedBracketException;
 import com.gregtechceu.gtceu.api.placeholder.exceptions.UnknownPlaceholderException;
 import com.gregtechceu.gtceu.client.renderer.monitor.IMonitorRenderer;
+import com.gregtechceu.gtceu.common.mui.drawable.BorderDrawable;
+import com.gregtechceu.gtceu.common.mui.widgets.textfield.CodeEditorWidget;
 import com.gregtechceu.gtceu.data.lang.LangHandler;
-import com.gregtechceu.gtceu.utils.GTStringUtils;
 import com.gregtechceu.gtceu.utils.GTUtil;
 
-import com.lowdragmc.lowdraglib.gui.texture.TextTexture;
-import com.lowdragmc.lowdraglib.gui.widget.DraggableScrollableWidgetGroup;
-import com.lowdragmc.lowdraglib.gui.widget.TextTextureWidget;
-import com.lowdragmc.lowdraglib.gui.widget.Widget;
-import com.lowdragmc.lowdraglib.gui.widget.WidgetGroup;
-
 import net.minecraft.ChatFormatting;
 import net.minecraft.MethodsReturnNonnullByDefault;
 import net.minecraft.nbt.CompoundTag;
+import net.minecraft.network.chat.*;
 import net.minecraft.network.chat.MutableComponent;
 import net.minecraftforge.api.distmarker.Dist;
 import net.minecraftforge.api.distmarker.OnlyIn;
 
+import brachy.modularui.api.IPanelHandler;
+import brachy.modularui.api.drawable.IDrawable;
+import brachy.modularui.api.drawable.IKey;
+import brachy.modularui.api.value.IBoolValue;
+import brachy.modularui.api.value.IIntValue;
+import brachy.modularui.api.value.IStringValue;
+import brachy.modularui.drawable.GuiTextures;
+import brachy.modularui.screen.ModularPanel;
+import brachy.modularui.screen.RichTooltip;
+import brachy.modularui.value.StringValue;
+import brachy.modularui.value.sync.*;
+import brachy.modularui.widgets.ButtonWidget;
+import brachy.modularui.widgets.SortableListWidget;
+import brachy.modularui.widgets.TextWidget;
+import brachy.modularui.widgets.ToggleButton;
+import brachy.modularui.widgets.layout.Flow;
+import brachy.modularui.widgets.slot.ItemSlot;
+import brachy.modularui.widgets.textfield.TextFieldWidget;
 import it.unimi.dsi.fastutil.objects.Object2IntOpenHashMap;
 
 import java.util.*;
-import java.util.function.Consumer;
 
 import javax.annotation.Nullable;
 import javax.annotation.ParametersAreNonnullByDefault;
@@ -40,11 +53,16 @@ public class PlaceholderHandler {
     private static final char PLACEHOLDER_END = '}';
     private static final char ESCAPE = '\\';
     private static final char LITERAL_ESCAPE = '"';
+    private static final char SINGLE_ESCAPE = '\'';
     private static final char NEWLINE = '\n';
     private static final char ESCAPED_NEWLINE = 'n';
 
     private static final Map<String, Placeholder> placeholders = new HashMap<>();
 
+    public static final CodeEditorWidget.LanguageDefinition<PlaceholderContext> LANG_DEFINITION = new CodeEditorWidget.LanguageDefinition<>(
+            List.of("\\\\.", "\\{", "\\}", " ", "\"", "\\['", "'\\]"),
+            TokenFormatter::new);
+
     @OnlyIn(Dist.CLIENT)
     private static final class RendererHolder {
 
@@ -85,56 +103,81 @@ public static void addRenderer(String id, IPlaceholderRenderer renderer) {
     }
 
     public static MultiLineComponent processPlaceholder(List<MultiLineComponent> placeholder,
-                                                        PlaceholderContext context,
-                                                        Object2IntOpenHashMap<String> indices) throws PlaceholderException {
+                                                        @Nullable PlaceholderContext context) throws PlaceholderException {
         if (!placeholderExists(placeholder.get(0)))
             throw new UnknownPlaceholderException(placeholder.get(0).toString());
-        String name = placeholder.get(0).toString();
-        indices.addTo(name, 1);
-        context.index(indices.getInt(name));
-        return placeholders.get(name).apply(context,
+        if (context != null && context.level().isClientSide &&
+                !placeholders.get(placeholder.get(0).toString()).isView())
+            GTCEu.LOGGER.warn("Placeholder processing is running on client instead of server!");
+        return placeholders.get(placeholder.get(0).toString()).apply(context,
                 placeholder.subList(1, placeholder.size()));
     }
 
-    public static MultiLineComponent processPlaceholders(String s, PlaceholderContext ctx) {
-        if (ctx.level().isClientSide)
-            GTCEu.LOGGER.warn("Placeholder processing is running on client instead of server!");
+    public static MultiLineComponent processPlaceholders(String s, @Nullable PlaceholderContext ctx) {
         List<Exception> exceptions = new ArrayList<>();
         Object2IntOpenHashMap<String> indices = new Object2IntOpenHashMap<>();
         boolean escape = false;
         boolean escapeNext = false;
         boolean literalEscape = false;
+        boolean lineBeginningWhitespace = true;
+        int singleEscapes = 0;
+        char prev = '\0';
         int line = 1;
         int symbol = 1;
         Stack<List<MultiLineComponent>> stack = new Stack<>();
         stack.push(GTUtil.list(MultiLineComponent.empty()));
-        try {
-            for (char c : s.toCharArray()) {
-                if (escape || (literalEscape && c != LITERAL_ESCAPE)) {
-                    if (c == ESCAPED_NEWLINE && !literalEscape) {
+        for (char c : s.toCharArray()) {
+            if (!exceptions.isEmpty()) break;
+            if (c == '\'' && prev == '[') {
+                singleEscapes++;
+                symbol++;
+                prev = '\0';
+                continue;
+            }
+            if (c == ']' && prev == '\'') {
+                singleEscapes--;
+                if (singleEscapes < 0) {
+                    exceptions.add(new UnexpectedBracketException());
+                }
+                symbol++;
+                GTUtil.getLast(stack.peek()).append(c);
+                prev = c;
+                continue;
+            } else if (prev == '\'') GTUtil.getLast(stack.peek()).append('\'');
+            if (escape || ((literalEscape || singleEscapes > 0) && c != LITERAL_ESCAPE && c != SINGLE_ESCAPE)) {
+                if (c == ESCAPED_NEWLINE && !literalEscape && singleEscapes == 0) {
+                    GTUtil.getLast(stack.peek()).appendNewline();
+                    line++;
+                    lineBeginningWhitespace = true;
+                    symbol = 0;
+                } else if (c != NEWLINE) {
+                    lineBeginningWhitespace = false;
+                    GTUtil.getLast(stack.peek()).append(c);
+                } else lineBeginningWhitespace = false;
+            } else {
+                switch (c) {
+                    case ESCAPE -> escapeNext = true;
+                    case LITERAL_ESCAPE -> literalEscape = !literalEscape;
+                    case NEWLINE -> {
                         GTUtil.getLast(stack.peek()).appendNewline();
                         line++;
+                        lineBeginningWhitespace = true;
                         symbol = 0;
-                    } else if (c == NEWLINE) continue;
-                    else GTUtil.getLast(stack.peek()).append(c);
-                } else {
-                    switch (c) {
-                        case ESCAPE -> escapeNext = true;
-                        case LITERAL_ESCAPE -> literalEscape = !literalEscape;
-                        case NEWLINE -> {
-                            GTUtil.getLast(stack.peek()).appendNewline();
-                            line++;
-                            symbol = 0;
-                        }
-                        case ARG_SEPARATOR -> {
-                            if (stack.size() == 1) GTUtil.getLast(stack.peek()).append(c);
-                            else stack.peek().add(MultiLineComponent.empty());
-                        }
-                        case PLACEHOLDER_BEGIN -> stack.push(GTUtil.list(MultiLineComponent.empty()));
-                        case PLACEHOLDER_END -> {
-                            List<MultiLineComponent> placeholder = stack.pop();
+                    }
+                    case ARG_SEPARATOR -> {
+                        if (stack.size() == 1) GTUtil.getLast(stack.peek()).append(c);
+                        else if (!lineBeginningWhitespace) stack.peek().add(MultiLineComponent.empty());
+                    }
+                    case PLACEHOLDER_BEGIN -> {
+                        lineBeginningWhitespace = false;
+                        stack.push(GTUtil.list(MultiLineComponent.empty()));
+                    }
+                    case PLACEHOLDER_END -> {
+                        lineBeginningWhitespace = false;
+                        List<MultiLineComponent> placeholder = stack.pop();
+                        try {
                             if (stack.isEmpty()) throw new UnexpectedBracketException();
-                            MultiLineComponent result = processPlaceholder(placeholder, ctx, indices);
+                            MultiLineComponent result = processPlaceholder(placeholder, ctx);
                             if (result.isIgnoreSpaces() || stack.size() == 1) {
                                 GTUtil.getLast(stack.peek()).append(result);
                             } else {
@@ -158,29 +201,35 @@ public static MultiLineComponent processPlaceholders(String s, PlaceholderContex
                                     if (i != result.size() - 1) GTUtil.getLast(stack.peek()).appendNewline();
                                 }
                             }
+                        } catch (PlaceholderException e) {
+                            exceptions.add(e);
+                            e.setLineInfo(line, symbol);
                         }
-                        default -> GTUtil.getLast(stack.peek()).append(c);
+                    }
+                    default -> {
+                        lineBeginningWhitespace = false;
+                        if (c != SINGLE_ESCAPE) GTUtil.getLast(stack.peek()).append(c);
                     }
                 }
-                escape = escapeNext;
-                escapeNext = false;
-                symbol++;
+                if (stack.isEmpty()) break;
             }
-        } catch (PlaceholderException e) {
-            e.setLineInfo(line, symbol);
-            exceptions.add(e);
-        } catch (RuntimeException e) {
-            exceptions.add(e);
+            escape = escapeNext;
+            escapeNext = false;
+            symbol++;
+            prev = c;
         }
         if (stack.size() > 1) {
             PlaceholderException exception = new UnclosedBracketException();
             exception.setLineInfo(line, symbol);
             exceptions.add(exception);
         }
-        if (exceptions.isEmpty())
-            return stack.peek().stream().reduce(MultiLineComponent.empty(), MultiLineComponent::append);
-        MultiLineComponent out = MultiLineComponent.literal("Exceptions:");
-        out.appendNewline();
+        if (exceptions.isEmpty()) {
+            MultiLineComponent out = stack.peek().stream().reduce(MultiLineComponent.empty(),
+                    MultiLineComponent::append);
+            if (out.toTag().toString().length() > 16000) return MultiLineComponent.literal("Output too long");
+            return out;
+        }
+        MultiLineComponent out = MultiLineComponent.empty();
         exceptions.forEach(exception -> {
             out.append(exception.getMessage());
             out.appendNewline();
@@ -192,33 +241,314 @@ public static Set<String> getAllPlaceholderNames() {
         return placeholders.keySet();
     }
 
-    public static Widget getPlaceholderHandlerUI(String filter) {
-        DraggableScrollableWidgetGroup placeholderReference = new DraggableScrollableWidgetGroup(280, 15, 100, 200);
-        Consumer<String> onSearch = (newSearch) -> {
-            placeholderReference.clearAllWidgets();
-            int y = 2;
-            ArrayList<String> placeholders = new ArrayList<>(getAllPlaceholderNames());
-            placeholders.removeIf(s -> s == null || !s.contains(newSearch));
-            placeholders.sort(String::compareTo);
-            for (String placeholder : placeholders) {
-                TextTextureWidget placeholderName = new TextTextureWidget(0, y, 80, 15, placeholder);
-                placeholderName.getTextTexture().type = TextTexture.TextType.LEFT;
-                placeholderName.setHoverTooltips(GTStringUtils
-                        .toImmutable(LangHandler.getSingleOrMultiLang("gtceu.placeholder_info." + placeholder)));
-                placeholderReference.addWidget(placeholderName);
-                y += 15;
+    public static IPanelHandler createPlaceholderEditor(String name, PanelSyncManager syncManager,
+                                                        PlaceholderContext ctx,
+                                                        IStringValue<?> code,
+                                                        @Nullable DoubleSyncValue scaleDouble,
+                                                        @Nullable IIntValue<?> updateInterval,
+                                                        @Nullable IBoolValue<?> pause,
+                                                        @Nullable Runnable updateText) {
+        IPanelHandler helpPanel = syncManager.syncedPanel("placeholder_language_help",
+                true,
+                (syncManager1, panelHandler1) -> createHelpPanel());
+        InteractionSyncHandler runCodeOnce = new InteractionSyncHandler();
+        if (updateText != null) runCodeOnce.setOnMousePressed(mouseData -> updateText.run());
+        syncManager.syncValue("run_code_sync_handler", runCodeOnce);
+        // because the args are nullable, intellij complains about everything, even though childIf is used
+        // noinspection DataFlowIssue
+        return syncManager.syncedPanel(name, true, (psm, handler) -> new ModularPanel<>(name)
+                .size(400, 250)
+                .resizeableOnDrag(true)
+                .excludeAreaInRecipeViewer()
+                .child(Flow.row()
+                        .childIf(ctx.itemStackHandler() != null, () -> Flow.column()
+                                .coverChildren()
+                                .paddingLeft(4)
+                                .children(
+                                        ctx.itemStackHandler().getSlots(),
+                                        i -> new ItemSlot()
+                                                .slot(ctx.itemStackHandler(), i)
+                                                .addTooltipLine(
+                                                        IKey.lang("gtceu.gui.computer_monitor_cover.slot_tooltip", i))))
+                        .child(Flow.column()
+                                .widthRel(.8f)
+                                .padding(5)
+                                .child(Flow.row()
+                                        .height(20)
+                                        .childIf(scaleDouble != null,
+                                                () -> new TextWidget<>(
+                                                        IKey.lang("gtceu.gui.central_monitor.text_scale")))
+                                        .childIf(scaleDouble != null, () -> new TextFieldWidget()
+                                                .setNumbersDouble(x -> Math.max(x, 0))
+                                                .setDefaultNumber(1.0)
+                                                .value(scaleDouble)
+                                                .marginLeft(4))
+                                        .childIf(updateInterval != null,
+                                                () -> new TextWidget<>(
+                                                        IKey.lang("gtceu.gui.computer_monitor_cover.update_interval")))
+                                        .childIf(updateInterval != null, () -> new TextFieldWidget()
+                                                .setNumbers(1, 1000)
+                                                .setDefaultNumber(1)
+                                                .value(SyncHandlers.string(
+                                                        () -> String.valueOf(updateInterval.getIntValue()),
+                                                        s -> updateInterval.setIntValue(Integer.parseInt(s))))
+                                                .marginLeft(4))
+                                        .childIf(pause != null, () -> new ToggleButton()
+                                                .value(pause)
+                                                .background(false, GuiTextures.PAUSE)
+                                                .background(true, GuiTextures.PLAY)
+                                                .addTooltip(false, IKey.lang("gtceu.gui.central_monitor.pause"))
+                                                .addTooltip(true, IKey.lang("gtceu.gui.central_monitor.resume"))
+                                                .margin(4))
+                                        .childIf(updateText != null, () -> new ButtonWidget<>()
+                                                .background(GuiTextures.RIGHTLOAD)
+                                                .hoverBackground(GuiTextures.RIGHTLOAD, new BorderDrawable())
+                                                .addTooltipLine(IKey.lang("gtceu.gui.central_monitor.update_once"))
+                                                .syncHandler("run_code_sync_handler"))
+                                        .child(new ButtonWidget<>()
+                                                .background(GuiTextures.HELP)
+                                                .hoverBackground(GuiTextures.HELP, new BorderDrawable())
+                                                .margin(4)
+                                                .onMousePressed((mouseX, mouseY, button) -> {
+                                                    helpPanel.openPanel();
+                                                    return true;
+                                                })))
+                                .child(new CodeEditorWidget<>(PlaceholderHandler.LANG_DEFINITION)
+                                        .value(code)
+                                        .langContext(ctx)
+                                        .widthRel(.95f)
+                                        .heightRelOffset(1, -25)))
+                        .child(new SortableListWidget<String>()
+                                .widthRel(.2f)
+                                .paddingBottom(5)
+                                .excludeAreaInRecipeViewer()
+                                .children(PlaceholderHandler.getAllPlaceholderNames()
+                                        .stream()
+                                        .sorted()
+                                        .map(SortableListWidget.Item::new)
+                                        .map(w -> w
+                                                .child(new TextWidget<>(w.getWidgetValue())
+                                                        .sizeRel(1)
+                                                        .center())
+                                                .tooltip(new RichTooltip()
+                                                        .addDrawableLines(LangHandler
+                                                                .getSingleOrMultiLang(
+                                                                        "gtceu.placeholder_info." + w.getWidgetValue())
+                                                                .stream()
+                                                                .map(IKey::lang)
+                                                                .map(key -> (IDrawable) key)
+                                                                .toList())))
+                                        .toList()))));
+    }
+
+    public static ModularPanel<?> createHelpPanel() {
+        return new ModularPanel<>("placeholder_language_help")
+                .size(500, 250)
+                .child(Flow.column()
+                        .padding(5)
+                        .child(new TextWidget<>(IKey.lang("gtceu.gui.central_monitor.text_module_help")))
+                        .child(new CodeEditorWidget<>(LANG_DEFINITION)
+                                .padding(5)
+                                .widthRel(.95f)
+                                .height(100)
+                                .value(new StringValue(
+                                        """
+                                                Energy: {calc {energy}00.0 / {energyCapacity}}%
+                                                Bar: {repeat {calc {energy}0.0 / {energyCapacity}} {color green {block}}}
+                                                Status: \\
+                                                {if {cmp {energy} >= {calc 0.7 * {energyCapacity}}} {color green OK} \\
+                                                {if {cmp {energy} >= {calc 0.4 * {energyCapacity}}} {color yellow WARNING} \\
+                                                {if {cmp {energy} >= {calc 0.2 * {energyCapacity}}} {color red LOW} \\
+                                                {color red CRITICAL}}}}
+
+                                                {eval {if {cmp {energy} < {calc 0.5 * {energyCapacity}}} "{redstone set 15}" "{redstone set 0}"}
+                                                """))));
+    }
+
+    public static class TokenFormatter implements CodeEditorWidget.ITokenFormatter<PlaceholderContext> {
+
+        private boolean prevOpenBracket = false;
+        private boolean inString = false;
+        private int unclosedSingleEscapes = 0;
+        private int unclosedBrackets = 0;
+        private final StringBuilder everything = new StringBuilder();
+        private final Stack<Integer> pureStarts = new Stack<>();
+        private final Stack<Integer> viewStarts = new Stack<>();
+        private final Stack<String> openPlaceholders = new Stack<>();
+        private int ifDepth = 0;
+        private Component endOfLineValue = null;
+
+        @Override
+        public Component apply(String s, @Nullable PlaceholderContext ctx) {
+            if (s.equals("\0")) {
+                if (unclosedBrackets > 0) {
+                    onEncounteredError();
+                    return Component.literal(" ").withStyle(Style.EMPTY
+                            .withUnderlined(true)
+                            .withInsertion("")
+                            .withColor(0xFF0000)
+                            .withHoverEvent(new HoverEvent(
+                                    HoverEvent.Action.SHOW_TEXT,
+                                    unclosedBrackets == 1 ?
+                                            Component.translatable("gtceu.placeholder_editor.unclosed_bracket") :
+                                            Component.translatable("gtceu.placeholder_editor.unclosed_brackets",
+                                                    unclosedBrackets))));
+                }
+                if (unclosedSingleEscapes > 0) {
+                    onEncounteredError();
+                    return Component.literal(" ").withStyle(Style.EMPTY
+                            .withUnderlined(true)
+                            .withInsertion("")
+                            .withColor(0xFF0000)
+                            .withHoverEvent(new HoverEvent(
+                                    HoverEvent.Action.SHOW_TEXT,
+                                    unclosedSingleEscapes == 1 ?
+                                            Component.translatable("gtceu.placeholder_editor.unclosed_escape") :
+                                            Component.translatable("gtceu.placeholder_editor.unclosed_escapes",
+                                                    unclosedBrackets))));
+                }
+                return Component.empty();
+            }
+            if (s.matches("\\\\.")) {
+                prevOpenBracket = false;
+                everything.append(s);
+                return Component.literal(s).withStyle(ChatFormatting.GOLD);
+            }
+            if (inString && !s.equals("\"")) {
+                prevOpenBracket = false;
+                everything.append(s);
+                return Component.literal(s).withStyle(ChatFormatting.DARK_GREEN);
+            }
+            switch (s) {
+                case "\"" -> {
+                    inString = !inString;
+                    everything.append(s);
+                    return Component.literal(s).withStyle(ChatFormatting.DARK_GREEN);
+                }
+                case "['" -> {
+                    everything.append(s);
+                    unclosedSingleEscapes++;
+                    return Component.literal(s).withStyle(ChatFormatting.GOLD);
+                }
+                case "']" -> {
+                    everything.append(s);
+                    unclosedSingleEscapes--;
+                    if (unclosedSingleEscapes < 0) {
+                        onEncounteredError();
+                        return Component.literal(s).withStyle(Style.EMPTY
+                                .withColor(0xFF0000)
+                                .withHoverEvent(new HoverEvent(
+                                        HoverEvent.Action.SHOW_TEXT,
+                                        Component.translatable("gtceu.placeholder_editor.extra_closing_bracket"))));
+                    }
+                    return Component.literal(s).withStyle(ChatFormatting.GOLD);
+                }
+                case "{" -> {
+                    prevOpenBracket = true;
+                    unclosedBrackets++;
+                    everything.append(s);
+                    return Component.literal(s);
+                }
+                case "}" -> {
+                    prevOpenBracket = false;
+                    unclosedBrackets--;
+                    if (unclosedBrackets < 0) {
+                        unclosedBrackets = 0;
+                        onEncounteredError();
+                        return Component.literal(s).withStyle(Style.EMPTY
+                                .withColor(0xFF0000)
+                                .withHoverEvent(new HoverEvent(
+                                        HoverEvent.Action.SHOW_TEXT,
+                                        Component.translatable("gtceu.placeholder_editor.extra_closing_bracket"))));
+                    }
+                    everything.append(s);
+                    if (!openPlaceholders.empty()) {
+                        if (openPlaceholders.peek().equals("if")) ifDepth--;
+
+                        openPlaceholders.pop();
+                    }
+                    if (!pureStarts.empty()) {
+                        String result = processPlaceholders(everything.substring(pureStarts.peek()), ctx).toString();
+                        result = result.replaceAll("\\n", "\\\\n");
+                        int popped = pureStarts.peek();
+                        pureStarts.pop();
+                        viewStarts.pop();
+                        if (!everything.substring(popped).contains(" ")) return Component.literal(s);
+                        if (result.length() > 10) {
+                            result = result.substring(0, 10) + "…";
+                        }
+                        endOfLineValue = null;
+                        return Component.literal(s)
+                                .append(Component.literal("='%s'".formatted(result))
+                                        .withStyle(ChatFormatting.GRAY, ChatFormatting.UNDERLINE)
+                                        .withStyle(style -> style.withHoverEvent(new HoverEvent(
+                                                HoverEvent.Action.SHOW_TEXT,
+                                                Component.translatable("gtceu.placeholder_editor.constant_value")))
+                                                .withInsertion("")));
+                    }
+                    if (!viewStarts.empty() && ctx != null && !ctx.level().isClientSide()) {
+                        String result = processPlaceholders(everything.substring(viewStarts.peek()), ctx).toString();
+                        result = result.replaceAll("\\n", "\\\\n");
+                        if (result.length() > 10) {
+                            result = result.substring(0, 10) + "…";
+                        }
+                        viewStarts.pop();
+                        endOfLineValue = Component.literal("='%s'".formatted(result))
+                                .withStyle(ChatFormatting.DARK_GRAY)
+                                .withStyle(style -> style.withInsertion(""));
+                        return Component.literal(s);
+                    } else if (!viewStarts.empty()) viewStarts.pop();
+                    return Component.literal(s);
+                }
+            }
+            if (prevOpenBracket) {
+                prevOpenBracket = false;
+                if (getAllPlaceholderNames().contains(s)) {
+                    if (placeholders.get(s).isPure()) {
+                        pureStarts.push(everything.length() - 1);
+                    } else pureStarts.clear();
+                    if (placeholders.get(s).isView()) {
+                        viewStarts.push(everything.length() - 1);
+                    } else viewStarts.clear();
+                    everything.append(s);
+                    openPlaceholders.push(s);
+                    if (s.equals("if")) ifDepth++;
+                    else if (ifDepth > 0 && !placeholders.get(s).isView()) {
+                        return Component.literal(s)
+                                .withStyle(ChatFormatting.BLUE, ChatFormatting.UNDERLINE)
+                                .withStyle(style -> style.withHoverEvent(new HoverEvent(
+                                        HoverEvent.Action.SHOW_TEXT,
+                                        Component.translatable("gtceu.placeholder_editor.write_in_if"))));
+                    }
+                    return Component.literal(s).withStyle(ChatFormatting.BLUE);
+                } else {
+                    onEncounteredError();
+                    return Component.literal(s).withStyle(Style.EMPTY
+                            .withColor(0xFF0000)
+                            .withHoverEvent(new HoverEvent(
+                                    HoverEvent.Action.SHOW_TEXT,
+                                    Component.translatable("gtceu.placeholder_editor.no_placeholder",
+                                            s.replaceAll("\\n", "\\\\n")))));
+                }
+            }
+            everything.append(s);
+            if (s.contains("\n") && endOfLineValue != null) {
+                String start = s.substring(0, s.indexOf('\n'));
+                String end = s.substring(s.indexOf('\n'));
+                Component ret = Component.literal(start).append(endOfLineValue).append(end);
+                endOfLineValue = null;
+                return ret;
             }
-        };
-        onSearch.accept(filter);
-        TextTextureWidget placeholderReferenceLabel = new TextTextureWidget(
-                280, 0,
-                160, 15,
-                GTStringUtils.componentsToString(
-                        LangHandler.getMultiLang("gtceu.gui.computer_monitor_cover.placeholder_reference")));
-        placeholderReferenceLabel.getTextTexture().type = TextTexture.TextType.LEFT;
-        WidgetGroup out = new WidgetGroup();
-        out.addWidget(placeholderReferenceLabel);
-        out.addWidget(placeholderReference);
-        return out;
+            return Component.literal(s);
+        }
+
+        private void onEncounteredError() {
+            viewStarts.clear();
+            pureStarts.clear();
+            openPlaceholders.clear();
+            endOfLineValue = null;
+            ifDepth = 0;
+            unclosedSingleEscapes = 0;
+        }
     }
 }
diff --git a/src/main/java/com/gregtechceu/gtceu/api/recipe/GTRecipeType.java b/src/main/java/com/gregtechceu/gtceu/api/recipe/GTRecipeType.java
index 2f5e78e6acc..dd3dbd2353a 100644
--- a/src/main/java/com/gregtechceu/gtceu/api/recipe/GTRecipeType.java
+++ b/src/main/java/com/gregtechceu/gtceu/api/recipe/GTRecipeType.java
@@ -5,6 +5,8 @@
 import com.gregtechceu.gtceu.api.gui.SteamTexture;
 import com.gregtechceu.gtceu.api.recipe.category.GTRecipeCategory;
 import com.gregtechceu.gtceu.api.recipe.chance.boost.ChanceBoostFunction;
+import com.gregtechceu.gtceu.api.recipe.gui.GTRecipeTypeUILayout;
+import com.gregtechceu.gtceu.api.recipe.gui.GTRecipeTypeUIs;
 import com.gregtechceu.gtceu.api.recipe.lookup.RecipeAdditionHandler;
 import com.gregtechceu.gtceu.api.recipe.lookup.RecipeDB;
 import com.gregtechceu.gtceu.api.recipe.ui.GTRecipeTypeUI;
@@ -138,6 +140,13 @@ public GTRecipeType setMaxSize(IO io, RecipeCapability<?> cap, int max) {
         return this;
     }
 
+    public GTRecipeType UI(UnaryOperator<GTRecipeTypeUILayout.Builder> builder) {
+        var recipeLayout = builder.apply(new GTRecipeTypeUILayout.Builder()).build();
+        recipeLayout.setRecipeType(this);
+        GTRecipeTypeUIs.addRecipeTypeUI(this, recipeLayout);
+        return this;
+    }
+
     public GTRecipeType setSlotOverlay(boolean isOutput, boolean isFluid, IGuiTexture slotOverlay) {
         this.recipeUI.setSlotOverlay(isOutput, isFluid, slotOverlay);
         return this;
diff --git a/src/main/java/com/gregtechceu/gtceu/api/recipe/gui/GTRecipeTypeUILayout.java b/src/main/java/com/gregtechceu/gtceu/api/recipe/gui/GTRecipeTypeUILayout.java
new file mode 100644
index 00000000000..c914115b2f3
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/api/recipe/gui/GTRecipeTypeUILayout.java
@@ -0,0 +1,312 @@
+package com.gregtechceu.gtceu.api.recipe.gui;
+
+import com.gregtechceu.gtceu.api.capability.recipe.*;
+import com.gregtechceu.gtceu.api.machine.trait.NotifiableFluidTank;
+import com.gregtechceu.gtceu.api.machine.trait.NotifiableItemStackHandler;
+import com.gregtechceu.gtceu.api.recipe.GTRecipeType;
+import com.gregtechceu.gtceu.common.mui.GTMuiWidgets;
+
+import brachy.modularui.api.drawable.IDrawable;
+import brachy.modularui.drawable.UITexture;
+import brachy.modularui.screen.ModularPanel;
+import brachy.modularui.theme.ThemeAPI;
+import brachy.modularui.value.sync.DoubleSyncValue;
+import brachy.modularui.value.sync.PanelSyncManager;
+import brachy.modularui.value.sync.SyncHandlers;
+import brachy.modularui.widget.ParentWidget;
+import brachy.modularui.widgets.ProgressWidget;
+import brachy.modularui.widgets.SlotGroupWidget;
+import brachy.modularui.widgets.layout.Flow;
+import brachy.modularui.widgets.slot.FluidSlot;
+import brachy.modularui.widgets.slot.ItemSlot;
+import brachy.modularui.widgets.slot.ModularSlot;
+import brachy.modularui.widgets.slot.SlotGroup;
+import it.unimi.dsi.fastutil.ints.*;
+import it.unimi.dsi.fastutil.objects.Object2ReferenceOpenHashMap;
+import lombok.Getter;
+import lombok.Setter;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+
+import java.util.*;
+import java.util.function.DoubleSupplier;
+
+public class GTRecipeTypeUILayout {
+
+    @Setter
+    @Getter
+    private GTRecipeType recipeType;
+    @Getter
+    private UITexture progressBar;
+    @Getter
+    private int progressSize;
+    @Getter
+    private ProgressWidget.Direction progressDirection;
+    @Getter
+    private Set<IO> IOs = new HashSet<>();
+    @Getter
+    private Map<IO, Map<RecipeCapability<?>, Int2ObjectOpenHashMap<IDrawable>>> overlays = new EnumMap<>(IO.class);
+    private Map<IO, Map<RecipeCapability<?>, Int2IntArrayMap>> gridLength = new EnumMap<>(IO.class);
+    private Map<IO, Map<RecipeCapability<?>, Int2IntArrayMap>> gridWidths = new EnumMap<>(IO.class);
+
+    private ParentWidget<?> parentWidget = null;
+
+    public GTRecipeTypeUILayout() {}
+
+    public ParentWidget<?> getBackedSlotsRow(@NotNull PanelSyncManager syncManager,
+                                             @NotNull String themeId,
+                                             @Nullable NotifiableItemStackHandler inputItems,
+                                             @Nullable NotifiableItemStackHandler outputItems,
+                                             @Nullable NotifiableFluidTank inputFluids,
+                                             @Nullable NotifiableFluidTank outputFluids,
+                                             DoubleSupplier progressSupplier, int tier) {
+        if (recipeType != null) {
+            var backedSlotsPanel = new ParentWidget<>();
+            backedSlotsPanel.coverChildren();
+            var backedSlotsRow = Flow.row();
+            backedSlotsRow.coverChildrenHeight();
+
+            int rowWidthPx = 0;
+
+            // List<IO> IOs = new ArrayList<>();
+            if (inputItems != null || inputFluids != null) {
+                IOs.add(IO.IN);
+            }
+            if (outputFluids != null || outputItems != null) {
+                IOs.add(IO.OUT);
+            }
+
+            Map<IO, ParentWidget<?>> colWidgetGroups = new Object2ReferenceOpenHashMap<>();
+
+            int slotLeftShiftPx = 0;
+            for (var io : IOs) {
+                boolean in = io == IO.IN;
+
+                var caps = (in ? recipeType.maxInputs : recipeType.maxOutputs);
+                int slotGroupHeightPx = 0;
+
+                Flow ioColumn = Flow.col();
+                // ioColumn.coverChildrenWidth();
+                int slotGroupWidthPx = 0;
+
+                var widgetGroups = new ArrayList<ParentWidget<?>>();
+
+                for (var recipeCap : caps.keySet()) {
+                    int maxRecipeTypeSlots = caps.get(recipeCap);
+                    int maxMachineSlots = 0;
+                    if (maxRecipeTypeSlots == 0 || recipeCap == EURecipeCapability.CAP) continue;
+                    if (recipeCap == ItemRecipeCapability.CAP) {
+                        if (in && inputItems == null) continue;
+                        if (!in && outputItems == null) continue;
+                        maxMachineSlots = in ? inputItems.getSlots() : outputItems.getSlots();
+                    } else if (recipeCap == FluidRecipeCapability.CAP) {
+                        if (in && inputFluids == null) continue;
+                        if (!in && outputFluids == null) continue;
+                        maxMachineSlots = in ? inputFluids.getTanks() : outputFluids.getTanks();
+                    }
+
+                    var grid = createGrid(io, recipeCap, 's', tier, maxMachineSlots);
+
+                    slotGroupHeightPx += 18 * grid.length;
+
+                    IDrawable defaultSlotBackground = (recipeCap == ItemRecipeCapability.CAP ?
+                            ThemeAPI.INSTANCE.getTheme(themeId).getItemSlotTheme().theme().getBackground() :
+                            ThemeAPI.INSTANCE.getTheme(themeId).getFluidSlotTheme().theme().getBackground());
+
+                    SlotGroupWidget.Builder slotWidgetBuilder = SlotGroupWidget.builder()
+                            .matrix(grid);
+
+                    if (recipeCap == ItemRecipeCapability.CAP) {
+                        var handler = in ? inputItems : outputItems;
+                        SlotGroup group = new SlotGroup("item_" + io.name(), grid[0].length());
+                        if (handler != null) {
+                            slotWidgetBuilder.key('s', i -> {
+                                var overlay = IDrawable.EMPTY;
+
+                                if (overlays.containsKey(io) && overlays.get(io).containsKey(recipeCap)) {
+                                    overlay = overlays.get(io).get(recipeCap).get(i) != null ?
+                                            overlays.get(io).get(recipeCap).get(i) : IDrawable.EMPTY;
+                                }
+
+                                return new ItemSlot().slot(new ModularSlot(handler, i)
+                                        .slotGroup(group))
+                                        .background(defaultSlotBackground, overlay);
+                            });
+                        }
+                    } else if (recipeCap == FluidRecipeCapability.CAP) {
+                        var handler = in ? inputFluids : outputFluids;
+                        String syncHandlerName = "fluid_" + io.name();
+                        for (int i = 0; i < maxMachineSlots; i++) {
+                            syncManager.syncValue(syncHandlerName, i, SyncHandlers.fluidSlot(handler.getStorages()[i]));
+                        }
+                        if (handler != null) {
+                            slotWidgetBuilder.key('s', i -> {
+                                var overlay = IDrawable.EMPTY;
+
+                                if (overlays.containsKey(io) && overlays.get(io).containsKey(recipeCap)) {
+                                    overlay = overlays.get(io).get(recipeCap).get(i) != null ?
+                                            overlays.get(io).get(recipeCap).get(i) : IDrawable.EMPTY;
+                                }
+
+                                return new FluidSlot()
+                                        .syncHandler(syncHandlerName, i)
+                                        .background(defaultSlotBackground, overlay);
+                            });
+                        }
+                    }
+
+                    // calculate full width of each column
+                    slotGroupWidthPx = Math.max(slotGroupWidthPx, Math.min(maxRecipeTypeSlots, grid[0].length()) * 18);
+
+                    widgetGroups.add(slotWidgetBuilder.build()
+                            .name(recipeCap.name + "_" + io.name())
+                            .leftRel(io == IO.IN ? 0f : 1));
+                }
+
+                ioColumn.size(slotGroupWidthPx, slotGroupHeightPx);
+                for (var g : widgetGroups) {
+                    ioColumn.child(g);
+                }
+                slotLeftShiftPx += (slotGroupWidthPx / 2) * ((io == io.IN) ? -1 : 1);
+
+                rowWidthPx += slotGroupWidthPx;
+                colWidgetGroups.put(io, ioColumn);
+            }
+            // 2 px padding plus each half of the progress bar (1)
+            backedSlotsRow.childPadding((progressSize / 2) + 2);
+            for (var ioColumn : colWidgetGroups.entrySet()) {
+                var col = ioColumn.getValue();
+                var io = ioColumn.getKey();
+                backedSlotsRow.child(col.posRel(io == IO.IN ? 0f : 1f, 0.5f));
+            }
+
+            // same padding as (1) + half a slot on each side
+            rowWidthPx += progressSize + 4 + 18;
+            backedSlotsRow.width(rowWidthPx);
+
+            backedSlotsPanel.child(backedSlotsRow.left(slotLeftShiftPx));
+
+            DoubleSyncValue progressPercent = syncManager.getOrCreateSyncHandler("progressPercent",
+                    DoubleSyncValue.class, () -> new DoubleSyncValue(progressSupplier));
+
+            backedSlotsPanel.child(new ProgressWidget()
+                    .center()
+                    .value(progressPercent)
+                    .name("progressBar")
+                    .texture(progressBar, progressSize)
+                    .size(progressSize)
+                    .direction(progressDirection));
+            return backedSlotsPanel;
+        }
+        return ModularPanel.defaultPanel("empty");
+    }
+
+    public String[] createGrid(IO io, RecipeCapability<?> cap, char key, int tier, int maxMachineSlots) {
+        int maxWidth = 3;
+        if (gridWidths.containsKey(io) && gridWidths.get(io).containsKey(cap)) {
+            int width = gridWidths.get(io).get(cap).get(tier);
+            if (width != 0) maxWidth = width;
+        }
+        int maxSlots = (io == IO.IN ? recipeType.getMaxInputs(cap) : recipeType.getMaxOutputs(cap));
+        if (gridLength.containsKey(io) && gridLength.get(io).containsKey(cap)) {
+            int length = gridLength.get(io).get(cap).get(tier);
+            if (length != 0) maxSlots = length;
+        }
+        maxSlots = Math.min(maxMachineSlots, maxSlots);
+        maxWidth = Math.min(maxSlots, maxWidth);
+        return GTMuiWidgets.createGrid(maxSlots, maxWidth, io.support(IO.OUT), key);
+    }
+
+    public static class Builder {
+
+        private UITexture progressBar;
+        private int progressSize;
+        private ProgressWidget.Direction fillDirection;
+        private Map<IO, Map<RecipeCapability<?>, Int2ObjectOpenHashMap<IDrawable>>> overlays = new EnumMap<>(IO.class);
+        private Map<IO, Map<RecipeCapability<?>, Int2IntArrayMap>> gridLength = new EnumMap<>(IO.class);
+        private Map<IO, Map<RecipeCapability<?>, Int2IntArrayMap>> gridWidths = new EnumMap<>(IO.class);
+
+        public Builder setSlotOverlay(IO ioMode, int slotIndex, RecipeCapability<?> cap, IDrawable overlay) {
+            overlays.computeIfAbsent(ioMode, it -> new Object2ReferenceOpenHashMap<>())
+                    .computeIfAbsent(cap, it -> new Int2ObjectOpenHashMap<>())
+                    .put(slotIndex, overlay);
+            return this;
+        }
+
+        public Builder setItemSlotOverlay(IO ioMode, int slotIndex, IDrawable overlay) {
+            return setSlotOverlay(ioMode, slotIndex, ItemRecipeCapability.CAP, overlay);
+        }
+
+        public Builder setFluidSlotOverlay(IO ioMode, int slotIndex, IDrawable overlay) {
+            return setSlotOverlay(ioMode, slotIndex, FluidRecipeCapability.CAP, overlay);
+        }
+
+        public Builder setItemSlotsOverlay(IO ioMode, int slotIndexStart, int slotIndexEnd, IDrawable overlay) {
+            for (int i = slotIndexStart; i <= slotIndexEnd; i++) {
+                setSlotOverlay(ioMode, i, ItemRecipeCapability.CAP, overlay);
+            }
+            return this;
+        }
+
+        public Builder setFluidSlotsOverlay(IO ioMode, int slotIndexStart, int slotIndexEnd, IDrawable overlay) {
+            for (int i = slotIndexStart; i <= slotIndexEnd; i++) {
+                setSlotOverlay(ioMode, i, FluidRecipeCapability.CAP, overlay);
+            }
+            return this;
+        }
+
+        public Builder setProgressBar(UITexture progressBar, int progressSize) {
+            return setProgressBar(progressBar, progressSize, ProgressWidget.Direction.RIGHT);
+        }
+
+        public Builder setProgressBar(UITexture progressBar, int progressSize, ProgressWidget.Direction fillDirection) {
+            this.progressBar = progressBar;
+            this.progressSize = progressSize;
+            this.fillDirection = fillDirection;
+            return this;
+        }
+
+        public Builder setIOSlotLength(IO ioMode, RecipeCapability<?> cap, int tier, int value) {
+            gridLength.computeIfAbsent(ioMode, it -> new Object2ReferenceOpenHashMap<>())
+                    .computeIfAbsent(cap, it -> new Int2IntArrayMap())
+                    .put(tier, value);
+            return this;
+        }
+
+        public Builder setIOSlotLengths(IO ioMode, RecipeCapability<?> cap, int startTier, int endTier, int value) {
+            for (int i = startTier; i <= endTier; i++) {
+                gridLength.computeIfAbsent(ioMode, it -> new Object2ReferenceOpenHashMap<>())
+                        .computeIfAbsent(cap, it -> new Int2IntArrayMap())
+                        .put(i, value);
+            }
+            return this;
+        }
+
+        public Builder setIOSlotWidth(IO ioMode, RecipeCapability<?> cap, int tier, int value) {
+            gridWidths.computeIfAbsent(ioMode, it -> new Object2ReferenceOpenHashMap<>())
+                    .computeIfAbsent(cap, it -> new Int2IntArrayMap())
+                    .put(tier, value);
+            return this;
+        }
+
+        public Builder setIOSlotWidths(IO ioMode, RecipeCapability<?> cap, int startTier, int endTier, int value) {
+            for (int i = startTier; i <= endTier; i++) {
+                gridWidths.computeIfAbsent(ioMode, it -> new Object2ReferenceOpenHashMap<>())
+                        .computeIfAbsent(cap, it -> new Int2IntArrayMap())
+                        .put(i, value);
+            }
+            return this;
+        }
+
+        public GTRecipeTypeUILayout build() {
+            GTRecipeTypeUILayout layout = new GTRecipeTypeUILayout();
+            layout.progressBar = progressBar;
+            layout.progressSize = progressSize;
+            layout.progressDirection = fillDirection;
+            layout.overlays = overlays;
+            layout.gridLength = gridLength;
+            layout.gridWidths = gridWidths;
+            return layout;
+        }
+    }
+}
diff --git a/src/main/java/com/gregtechceu/gtceu/api/recipe/gui/GTRecipeTypeUIs.java b/src/main/java/com/gregtechceu/gtceu/api/recipe/gui/GTRecipeTypeUIs.java
new file mode 100644
index 00000000000..4ef04d6e89b
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/api/recipe/gui/GTRecipeTypeUIs.java
@@ -0,0 +1,15 @@
+package com.gregtechceu.gtceu.api.recipe.gui;
+
+import com.gregtechceu.gtceu.api.recipe.GTRecipeType;
+
+import java.util.HashMap;
+import java.util.Map;
+
+public class GTRecipeTypeUIs {
+
+    public static Map<GTRecipeType, GTRecipeTypeUILayout> recipeTypeUIs = new HashMap<>();
+
+    public static void addRecipeTypeUI(GTRecipeType recipeType, GTRecipeTypeUILayout layout) {
+        recipeTypeUIs.put(recipeType, layout);
+    }
+}
diff --git a/src/main/java/com/gregtechceu/gtceu/api/recipe/gui/GTRecipeViewerUILayout.java b/src/main/java/com/gregtechceu/gtceu/api/recipe/gui/GTRecipeViewerUILayout.java
new file mode 100644
index 00000000000..32807be3015
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/api/recipe/gui/GTRecipeViewerUILayout.java
@@ -0,0 +1,120 @@
+package com.gregtechceu.gtceu.api.recipe.gui;
+
+import com.gregtechceu.gtceu.api.GTValues;
+import com.gregtechceu.gtceu.api.capability.recipe.IO;
+import com.gregtechceu.gtceu.api.capability.recipe.ItemRecipeCapability;
+import com.gregtechceu.gtceu.common.mui.GTGuiTextures;
+
+import brachy.modularui.api.drawable.IDrawable;
+import brachy.modularui.widget.ParentWidget;
+import brachy.modularui.widgets.ProgressWidget;
+import brachy.modularui.widgets.SlotGroupWidget;
+import brachy.modularui.widgets.layout.Flow;
+import it.unimi.dsi.fastutil.objects.Object2ReferenceOpenHashMap;
+
+import java.util.ArrayList;
+import java.util.Map;
+
+public class GTRecipeViewerUILayout {
+
+    public final GTRecipeTypeUILayout layout;
+
+    private ParentWidget<? extends ParentWidget<?>> overrideWidget;
+
+    public GTRecipeViewerUILayout(GTRecipeTypeUILayout layout) {
+        this.layout = layout;
+    }
+
+    public GTRecipeViewerUILayout overrideWidget(ParentWidget<? extends ParentWidget<?>> overrideWidget) {
+        this.overrideWidget = overrideWidget;
+        return this;
+    }
+
+    public ParentWidget<?> getRecipeWidget() {
+        if (layout.getRecipeType() != null) {
+            var parentWidget = new ParentWidget<>();
+            parentWidget.coverChildren();
+            var slotsRow = Flow.row();
+            slotsRow.coverChildrenHeight();
+
+            int rowWidthPx = 0;
+
+            Map<IO, ParentWidget<?>> colWidgetGroups = new Object2ReferenceOpenHashMap<>();
+
+            int slotLeftShiftPx = 0;
+            for (var io : layout.getIOs()) {
+                boolean in = io == IO.IN;
+
+                var caps = (in ? layout.getRecipeType().maxInputs : layout.getRecipeType().maxOutputs);
+                int slotGroupHeightPx = 0;
+
+                Flow ioColumn = Flow.col();
+                // ioColumn.coverChildrenWidth();
+                int slotGroupWidthPx = 0;
+
+                var widgetGroups = new ArrayList<ParentWidget<?>>();
+
+                for (var recipeCap : caps.keySet()) {
+                    int maxRecipeTypeSlots = caps.get(recipeCap);
+
+                    var grid = layout.createGrid(io, recipeCap, 's', GTValues.MAX, Integer.MAX_VALUE);
+
+                    slotGroupHeightPx += 18 * grid.length;
+
+                    IDrawable defaultSlotBackground = (recipeCap == ItemRecipeCapability.CAP ?
+                            GTGuiTextures.SLOT : GTGuiTextures.FLUID_SLOT);
+
+                    SlotGroupWidget.Builder slotWidgetBuilder = SlotGroupWidget.builder()
+                            .matrix(grid);
+                    var overlays = layout.getOverlays();
+                    slotWidgetBuilder.key('s', i -> {
+                        var widget = new IDrawable.DrawableWidget(defaultSlotBackground);
+                        if (overlays.containsKey(io) && overlays.get(io).containsKey(recipeCap)) {
+                            widget.overlay(overlays.get(io).get(recipeCap).get(i));
+                        }
+                        return widget;
+                    });
+
+                    // calculate full width of each column
+                    slotGroupWidthPx = Math.max(slotGroupWidthPx, Math.min(maxRecipeTypeSlots, grid[0].length()) * 18);
+
+                    widgetGroups.add(slotWidgetBuilder.build()
+                            .name(recipeCap.name + "_" + io.name())
+                            .leftRel(io == IO.IN ? 0 : 1));
+                }
+
+                ioColumn.size(slotGroupWidthPx, slotGroupHeightPx);
+                for (var g : widgetGroups) {
+                    ioColumn.child(g);
+                }
+                slotLeftShiftPx += (slotGroupWidthPx / 2) * ((io == io.IN) ? -1 : 1);
+
+                rowWidthPx += slotGroupWidthPx;
+                colWidgetGroups.put(io, ioColumn);
+            }
+            // 2 px padding plus each half of the progress bar (1)
+            slotsRow.childPadding((layout.getProgressSize() / 2) + 2);
+            for (var ioColumn : colWidgetGroups.entrySet()) {
+                var col = ioColumn.getValue();
+                var io = ioColumn.getKey();
+                slotsRow.child(col.posRel(io == IO.IN ? 0f : 1f, 0.5f));
+            }
+
+            // same padding as (1) + half a slot on each side
+            rowWidthPx += layout.getProgressSize() + 4 + 18;
+            slotsRow.width(rowWidthPx);
+
+            parentWidget.child(slotsRow.left(slotLeftShiftPx));
+
+            parentWidget.child(new ProgressWidget()
+                    .center()
+                    // .progress(() -> 0.5f)
+                    .name("progressBar")
+                    .texture(layout.getProgressBar(), layout.getProgressSize())
+                    .size(layout.getProgressSize())
+                    .direction(layout.getProgressDirection()));
+            return parentWidget;
+        }
+        return new ParentWidget<>();
+    }
+}
diff --git a/src/main/java/com/gregtechceu/gtceu/api/registry/registrate/MachineBuilder.java b/src/main/java/com/gregtechceu/gtceu/api/registry/registrate/MachineBuilder.java
index c1b59704aa3..1a69692c5c3 100644
--- a/src/main/java/com/gregtechceu/gtceu/api/registry/registrate/MachineBuilder.java
+++ b/src/main/java/com/gregtechceu/gtceu/api/registry/registrate/MachineBuilder.java
@@ -6,7 +6,6 @@
 import com.gregtechceu.gtceu.api.blockentity.BlockEntityCreationInfo;
 import com.gregtechceu.gtceu.api.capability.recipe.RecipeCapability;
 import com.gregtechceu.gtceu.api.data.RotationState;
-import com.gregtechceu.gtceu.api.gui.editor.EditableMachineUI;
 import com.gregtechceu.gtceu.api.item.MetaMachineItem;
 import com.gregtechceu.gtceu.api.machine.MachineDefinition;
 import com.gregtechceu.gtceu.api.machine.MetaMachine;
@@ -14,6 +13,7 @@
 import com.gregtechceu.gtceu.api.machine.multiblock.PartAbility;
 import com.gregtechceu.gtceu.api.machine.property.GTMachineModelProperties;
 import com.gregtechceu.gtceu.api.machine.trait.RecipeLogic;
+import com.gregtechceu.gtceu.api.mui.factory.PanelFactory;
 import com.gregtechceu.gtceu.api.recipe.GTRecipe;
 import com.gregtechceu.gtceu.api.recipe.GTRecipeType;
 import com.gregtechceu.gtceu.api.recipe.modifier.RecipeModifier;
@@ -47,6 +47,7 @@
 import net.minecraft.world.phys.shapes.VoxelShape;
 import net.minecraftforge.client.model.generators.BlockModelBuilder;
 
+import brachy.modularui.theme.ThemeAPI;
 import com.tterrag.registrate.AbstractRegistrate;
 import com.tterrag.registrate.builders.BlockBuilder;
 import com.tterrag.registrate.builders.ItemBuilder;
@@ -144,10 +145,12 @@ public class MachineBuilder<DEFINITION extends MachineDefinition, TYPE extends M
     @Getter
     private boolean regressWhenWaiting = true;
     private boolean allowCoverOnFront = false;
-    private Supplier<BlockState> appearance;
-    @Getter // getter for KJS
+    @Getter
     @Nullable
-    private EditableMachineUI editableUI;
+    private PanelFactory ui = null;
+    @Getter
+    private String themeId = ThemeAPI.DEFAULT_ID;
+    private Supplier<BlockState> appearance;
     @Getter // getter for KJS
     @Nullable
     private String langValue = null;
@@ -296,8 +299,8 @@ public TYPE appearance(Supplier<BlockState> appearance) {
         return getThis();
     }
 
-    public TYPE editableUI(EditableMachineUI editableUI) {
-        this.editableUI = editableUI;
+    public TYPE ui(PanelFactory ui) {
+        this.ui = ui;
         return getThis();
     }
 
@@ -511,6 +514,16 @@ public TYPE abilities(PartAbility... abilities) {
         return getThis();
     }
 
+    public TYPE themeId(String themeId) {
+        this.themeId = themeId;
+        return getThis();
+    }
+
+    public TYPE themeId(Function<Integer, String> themeId) {
+        this.themeId = themeId.apply(tier);
+        return getThis();
+    }
+
     public TYPE modelProperty(Property<?> property) {
         return modelProperty(property, null);
     }
@@ -674,6 +687,12 @@ public DEFINITION register() {
             blockEntityBuilder = blockEntityBuilder.renderer(() -> BlockEntityWithBERModelRenderer::new);
         }
         var blockEntity = blockEntityBuilder.register();
+        if (this.ui != null) {
+            definition.setUI(ui);
+        }
+        if (this.themeId != null) {
+            definition.setThemeId(themeId);
+        }
         definition.setRecipeTypes(recipeTypes);
         definition.setBlockSupplier(block);
         definition.setItemSupplier(item);
@@ -701,9 +720,6 @@ public DEFINITION register() {
         if (appearance == null) {
             appearance = block::getDefaultState;
         }
-        if (editableUI != null) {
-            definition.setEditableUI(editableUI);
-        }
         definition.setAppearance(appearance);
         definition.setAllowExtendedFacing(allowExtendedFacing);
         definition.setShape(shape);
diff --git a/src/main/java/com/gregtechceu/gtceu/api/sync_system/SyncDataHolder.java b/src/main/java/com/gregtechceu/gtceu/api/sync_system/SyncDataHolder.java
index 03f195340e3..c0aff5655e7 100644
--- a/src/main/java/com/gregtechceu/gtceu/api/sync_system/SyncDataHolder.java
+++ b/src/main/java/com/gregtechceu/gtceu/api/sync_system/SyncDataHolder.java
@@ -117,7 +117,7 @@ private static Tag serializeField(ISyncManaged holder, FieldSyncData field,
                         new ValueTransformer.TransformerContext<>(holder, field.type, currentValue, field.fieldName,
                                 writeClientFields, fullSync));
             } else if (currentValue instanceof ISyncManaged syncObj) {
-                return syncObj.getSyncDataHolder().serializeNBT(writeClientFields);
+                return syncObj.getSyncDataHolder().serializeNBT(writeClientFields, fullSync);
             } else {
                 GTCEu.LOGGER.error("Sync: Failed to serialize field {} in class {}: Missing value transformer for {}",
                         field.fieldName, holder.getClass().getName(), field.type);
diff --git a/src/main/java/com/gregtechceu/gtceu/api/sync_system/data_transformers/ValueTransformer.java b/src/main/java/com/gregtechceu/gtceu/api/sync_system/data_transformers/ValueTransformer.java
index 95128ec835c..2442e2362ee 100644
--- a/src/main/java/com/gregtechceu/gtceu/api/sync_system/data_transformers/ValueTransformer.java
+++ b/src/main/java/com/gregtechceu/gtceu/api/sync_system/data_transformers/ValueTransformer.java
@@ -5,7 +5,6 @@
 
 import net.minecraft.nbt.Tag;
 
-import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 
 /**
@@ -28,7 +27,7 @@ public interface ValueTransformer<T> {
      *                     being written to the server save.
      *
      */
-    record TransformerContext<U>(@NotNull ISyncManaged holder, @NotNull TypeDeclaration type,
+    record TransformerContext<U>(ISyncManaged holder, TypeDeclaration type,
                                  @Nullable U currentValue, @Nullable String fieldName, boolean isClientSync,
                                  boolean isClientFullSyncUpdate) {}
 
diff --git a/src/main/java/com/gregtechceu/gtceu/api/sync_system/data_transformers/gtceu/CoverBehaviorTransformer.java b/src/main/java/com/gregtechceu/gtceu/api/sync_system/data_transformers/gtceu/CoverBehaviorTransformer.java
index 74e9cb6e3f2..f091ec14ee2 100644
--- a/src/main/java/com/gregtechceu/gtceu/api/sync_system/data_transformers/gtceu/CoverBehaviorTransformer.java
+++ b/src/main/java/com/gregtechceu/gtceu/api/sync_system/data_transformers/gtceu/CoverBehaviorTransformer.java
@@ -20,7 +20,7 @@ public class CoverBehaviorTransformer implements ValueTransformer<CoverBehavior>
     public Tag serializeNBT(@Nullable CoverBehavior value,
                             CoverBehaviorTransformer.TransformerContext<CoverBehavior> context) {
         if (value != null) {
-            return serialize(value, context.isClientSync());
+            return serialize(value, context.isClientSync(), context.isClientFullSyncUpdate());
         }
         return new CompoundTag();
     }
@@ -36,12 +36,12 @@ public Tag serializeNBT(@Nullable CoverBehavior value,
         return null;
     }
 
-    private CompoundTag serialize(CoverBehavior cover, boolean isSync) {
+    private CompoundTag serialize(CoverBehavior cover, boolean isSync, boolean fullSync) {
         var compound = new CompoundTag();
 
         compound.putInt("side", cover.attachedSide.ordinal());
         compound.putString("coverType", cover.coverDefinition.getId().toString());
-        CompoundTag serializedCover = cover.getSyncDataHolder().serializeNBT(isSync);
+        CompoundTag serializedCover = cover.getSyncDataHolder().serializeNBT(isSync, fullSync);
         compound.put("data", serializedCover);
 
         return compound;
diff --git a/src/main/java/com/gregtechceu/gtceu/api/transfer/item/CustomItemStackHandler.java b/src/main/java/com/gregtechceu/gtceu/api/transfer/item/CustomItemStackHandler.java
index 812a4c8c804..a9f86bdc9b6 100644
--- a/src/main/java/com/gregtechceu/gtceu/api/transfer/item/CustomItemStackHandler.java
+++ b/src/main/java/com/gregtechceu/gtceu/api/transfer/item/CustomItemStackHandler.java
@@ -56,6 +56,12 @@ public void clear() {
         onContentsChanged.run();
     }
 
+    public NonNullList<ItemStack> toList() {
+        NonNullList<ItemStack> list = NonNullList.create();
+        for (int slot = 0; slot < getSlots(); slot++) list.add(getStackInSlot(slot));
+        return list;
+    }
+
     public void dropInventoryInWorld(Level world, BlockPos pos) {
         for (ItemStack stack : stacks) {
             Block.popResource(world, pos, stack);
diff --git a/src/main/java/com/gregtechceu/gtceu/client/CharTypedEvent.java b/src/main/java/com/gregtechceu/gtceu/client/CharTypedEvent.java
new file mode 100644
index 00000000000..77935f7f852
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/client/CharTypedEvent.java
@@ -0,0 +1,21 @@
+package com.gregtechceu.gtceu.client;
+
+import net.minecraftforge.eventbus.api.Cancelable;
+import net.minecraftforge.eventbus.api.Event;
+
+import lombok.AllArgsConstructor;
+import lombok.Getter;
+
+/**
+ * Fired when the corresponding GLFW event is triggered, before Minecraft's handling.
+ * Cancelling this event will also cancel further handling by Minecraft, like firing the
+ * {@link net.minecraftforge.client.event.ScreenEvent.CharacterTyped} event.
+ */
+@AllArgsConstructor
+@Getter
+@Cancelable
+public class CharTypedEvent extends Event {
+
+    private final char codepoint;
+    private final int modifiers;
+}
diff --git a/src/main/java/com/gregtechceu/gtceu/client/ClientProxy.java b/src/main/java/com/gregtechceu/gtceu/client/ClientProxy.java
index 9a0574d59a7..cdcd5e6eabc 100644
--- a/src/main/java/com/gregtechceu/gtceu/client/ClientProxy.java
+++ b/src/main/java/com/gregtechceu/gtceu/client/ClientProxy.java
@@ -31,10 +31,7 @@
 import com.gregtechceu.gtceu.client.renderer.machine.impl.BoilerMultiPartRender;
 import com.gregtechceu.gtceu.common.CommonEventListener;
 import com.gregtechceu.gtceu.common.CommonProxy;
-import com.gregtechceu.gtceu.common.data.GTBlockEntities;
-import com.gregtechceu.gtceu.common.data.GTEntityTypes;
-import com.gregtechceu.gtceu.common.data.GTMaterialBlocks;
-import com.gregtechceu.gtceu.common.data.GTParticleTypes;
+import com.gregtechceu.gtceu.common.data.*;
 import com.gregtechceu.gtceu.common.data.models.GTModels;
 import com.gregtechceu.gtceu.common.entity.GTBoat;
 import com.gregtechceu.gtceu.common.item.DrumMachineItem;
@@ -54,6 +51,8 @@
 import com.gregtechceu.gtceu.utils.data.RuntimeBlockstateProvider;
 import com.gregtechceu.gtceu.utils.input.SyncedKeyMapping;
 
+import net.minecraft.client.Minecraft;
+import net.minecraft.client.Timer;
 import net.minecraft.client.model.BoatModel;
 import net.minecraft.client.model.ChestBoatModel;
 import net.minecraft.client.renderer.blockentity.HangingSignRenderer;
@@ -66,13 +65,19 @@
 import net.minecraftforge.eventbus.api.EventPriority;
 import net.minecraftforge.eventbus.api.SubscribeEvent;
 import net.minecraftforge.fml.event.lifecycle.FMLClientSetupEvent;
+import net.minecraftforge.fml.event.lifecycle.FMLConstructModEvent;
 import net.minecraftforge.registries.ForgeRegistries;
 
 import com.google.common.collect.BiMap;
 import com.google.common.collect.HashBiMap;
+import com.mojang.blaze3d.systems.RenderSystem;
+import lombok.Getter;
 
 public class ClientProxy extends CommonProxy {
 
+    @Getter
+    private static final Timer timer60Fps = new Timer(60f, 0);
+
     public static final BiMap<ResourceLocation, GTOreDefinition> CLIENT_ORE_VEINS = HashBiMap.create();
     public static final BiMap<ResourceLocation, BedrockFluidDefinition> CLIENT_FLUID_VEINS = HashBiMap.create();
     public static final BiMap<ResourceLocation, BedrockOreDefinition> CLIENT_BEDROCK_ORE_VEINS = HashBiMap.create();
@@ -84,6 +89,7 @@ public ClientProxy() {
 
     public static void init() {
         if (!GTCEu.isDataGen()) {
+
             ClientCacheManager.registerClientCache(GTClientCache.instance, "gtceu");
             Layers.registerLayer(OreRenderLayer::new, "ore_veins");
             Layers.registerLayer(FluidRenderLayer::new, "bedrock_fluids");
@@ -92,6 +98,15 @@ public static void init() {
         initializeDynamicRenders();
     }
 
+    @Override
+    public void preInit(FMLConstructModEvent event) {
+        super.preInit(event);
+        if (!GTCEu.isDataGen()) {
+            // enable stencil bits, must call on render thread
+            RenderSystem.recordRenderCall(() -> Minecraft.getInstance().getMainRenderTarget().enableStencil());
+        }
+    }
+
     @SubscribeEvent
     public void onRegisterEntityRenderers(EntityRenderersEvent.RegisterRenderers event) {
         event.registerEntityRenderer(GTEntityTypes.DYNAMITE.get(), ThrownItemRenderer::new);
diff --git a/src/main/java/com/gregtechceu/gtceu/client/EarlyKeyPressEvent.java b/src/main/java/com/gregtechceu/gtceu/client/EarlyKeyPressEvent.java
new file mode 100644
index 00000000000..222a9536cb3
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/client/EarlyKeyPressEvent.java
@@ -0,0 +1,26 @@
+package com.gregtechceu.gtceu.client;
+
+import net.minecraftforge.client.event.InputEvent.Key;
+import net.minecraftforge.client.event.ScreenEvent.KeyPressed;
+import net.minecraftforge.eventbus.api.Cancelable;
+import net.minecraftforge.eventbus.api.Event;
+
+import lombok.AllArgsConstructor;
+import lombok.Getter;
+
+/**
+ * Fired when the corresponding GLFW event is triggered, before Minecraft's handling.
+ * Cancelling this event will also cancel further handling by Minecraft, like detecting
+ * ESC to pause the game, other controls, and firing the {@link Key} and {@link KeyPressed}
+ * events.
+ */
+@AllArgsConstructor
+@Getter
+@Cancelable
+public class EarlyKeyPressEvent extends Event {
+
+    private final int key;
+    private final int scanCode;
+    private final int action;
+    private final int modifiers;
+}
diff --git a/src/main/java/com/gregtechceu/gtceu/client/GuiSpriteManager.java b/src/main/java/com/gregtechceu/gtceu/client/GuiSpriteManager.java
new file mode 100644
index 00000000000..8a9611e67f0
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/client/GuiSpriteManager.java
@@ -0,0 +1,49 @@
+package com.gregtechceu.gtceu.client;
+
+import com.gregtechceu.gtceu.GTCEu;
+
+import net.minecraft.client.renderer.texture.TextureAtlasSprite;
+import net.minecraft.client.renderer.texture.TextureManager;
+import net.minecraft.client.resources.TextureAtlasHolder;
+import net.minecraft.resources.ResourceLocation;
+
+import org.jetbrains.annotations.NotNull;
+
+/**
+ * 1.21 has this class in vanilla, it can be used via {@code Minecraft.getGuiSprites()}.<br>
+ * Here in 1.20 land, though, we have to implement it ourselves.
+ * <p>
+ * Note that the atlas JSON <i>should</i> be kept, as MC 1.21 only adds textures in gui/sprites to the atlas. We want
+ * all of them.
+ */
+public class GuiSpriteManager extends TextureAtlasHolder {
+
+    public static final ResourceLocation LOCATION_GUI = GTCEu.id("textures/atlas/gui.png");
+
+    private static final ResourceLocation atlasInfoLocation = GTCEu.id("gui");
+    private static GuiSpriteManager instance = null;
+
+    GuiSpriteManager(TextureManager textureManager) {
+        super(textureManager, LOCATION_GUI, atlasInfoLocation);
+
+        if (instance != null) {
+            throw new IllegalStateException("Cannot create more than one GuiTextureAtlas instance!");
+        }
+        instance = this;
+    }
+
+    public static GuiSpriteManager getInstance() {
+        if (instance == null) {
+            throw new IllegalStateException("Cannot get GuiTextureAtlas instance before it's initialized!");
+        }
+        return instance;
+    }
+
+    /**
+     * Gets a sprite associated with the passed resource location.
+     */
+    @Override
+    public @NotNull TextureAtlasSprite getSprite(@NotNull ResourceLocation location) {
+        return super.getSprite(location);
+    }
+}
diff --git a/src/main/java/com/gregtechceu/gtceu/client/HudGuiOverlay.java b/src/main/java/com/gregtechceu/gtceu/client/HudGuiOverlay.java
index 489aff1cec8..36caac4a0c5 100644
--- a/src/main/java/com/gregtechceu/gtceu/client/HudGuiOverlay.java
+++ b/src/main/java/com/gregtechceu/gtceu/client/HudGuiOverlay.java
@@ -4,6 +4,7 @@
 import com.gregtechceu.gtceu.api.item.armor.ArmorComponentItem;
 import com.gregtechceu.gtceu.api.item.component.IItemComponent;
 import com.gregtechceu.gtceu.api.item.component.IItemHUDProvider;
+import com.gregtechceu.gtceu.api.item.module.IHUDProviderItemModule;
 
 import net.minecraft.client.Minecraft;
 import net.minecraft.client.gui.GuiGraphics;
@@ -23,7 +24,8 @@ public class HudGuiOverlay implements IGuiOverlay {
     public void render(ForgeGui forgeGui, GuiGraphics guiGraphics, float partialTick, int screenWidth,
                        int screenHeight) {
         Minecraft mc = Minecraft.getInstance();
-        if (mc.isWindowActive() && mc.level != null && !mc.options.renderDebug && !mc.options.hideGui) {
+        if (mc.isWindowActive() && mc.level != null && mc.player != null && !mc.options.renderDebug &&
+                !mc.options.hideGui) {
             renderHUDMetaArmor(mc.player.getItemBySlot(EquipmentSlot.HEAD), guiGraphics);
             renderHUDMetaArmor(mc.player.getItemBySlot(EquipmentSlot.CHEST), guiGraphics);
             renderHUDMetaArmor(mc.player.getItemBySlot(EquipmentSlot.LEGS), guiGraphics);
@@ -39,6 +41,7 @@ private static void renderHUDMetaArmor(@NotNull ItemStack stack, GuiGraphics gui
                 IItemHUDProvider.tryDrawHud(provider, stack, guiGraphics);
             }
         }
+        IHUDProviderItemModule.tryDrawHUD(stack, guiGraphics);
     }
 
     private static void renderHUDMetaItem(@NotNull ItemStack stack, GuiGraphics guiGraphics) {
@@ -49,5 +52,6 @@ private static void renderHUDMetaItem(@NotNull ItemStack stack, GuiGraphics guiG
                 }
             }
         }
+        IHUDProviderItemModule.tryDrawHUD(stack, guiGraphics);
     }
 }
diff --git a/src/main/java/com/gregtechceu/gtceu/client/ModClientEventListener.java b/src/main/java/com/gregtechceu/gtceu/client/ModClientEventListener.java
new file mode 100644
index 00000000000..c1a8d8a6937
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/client/ModClientEventListener.java
@@ -0,0 +1,31 @@
+package com.gregtechceu.gtceu.client;
+
+import com.gregtechceu.gtceu.GTCEu;
+import com.gregtechceu.gtceu.common.data.GTMenuTypes;
+
+import net.minecraft.client.Minecraft;
+import net.minecraft.client.gui.screens.MenuScreens;
+import net.minecraftforge.api.distmarker.Dist;
+import net.minecraftforge.client.event.RegisterClientReloadListenersEvent;
+import net.minecraftforge.eventbus.api.SubscribeEvent;
+import net.minecraftforge.fml.common.Mod;
+import net.minecraftforge.fml.event.lifecycle.FMLClientSetupEvent;
+
+import brachy.modularui.screen.ContainerScreenWrapper;
+import brachy.modularui.screen.ModularContainerMenu;
+
+@Mod.EventBusSubscriber(modid = GTCEu.MOD_ID, value = Dist.CLIENT, bus = Mod.EventBusSubscriber.Bus.MOD)
+public class ModClientEventListener {
+
+    @SubscribeEvent
+    public static void registerScreens(FMLClientSetupEvent event) {
+        // noinspection deprecation,RedundantCast
+        event.enqueueWork(() -> MenuScreens.register(GTMenuTypes.MODULAR_CONTAINER.get(),
+                (MenuScreens.ScreenConstructor<ModularContainerMenu, ContainerScreenWrapper>) ContainerScreenWrapper::new));
+    }
+
+    @SubscribeEvent
+    public static void registerClientReloadListeners(RegisterClientReloadListenersEvent event) {
+        event.registerReloadListener(new GuiSpriteManager(Minecraft.getInstance().textureManager));
+    }
+}
diff --git a/src/main/java/com/gregtechceu/gtceu/client/model/ItemBakedModel.java b/src/main/java/com/gregtechceu/gtceu/client/model/ItemBakedModel.java
deleted file mode 100644
index 254706cf370..00000000000
--- a/src/main/java/com/gregtechceu/gtceu/client/model/ItemBakedModel.java
+++ /dev/null
@@ -1,50 +0,0 @@
-package com.gregtechceu.gtceu.client.model;
-
-import com.lowdragmc.lowdraglib.client.model.ModelFactory;
-
-import net.minecraft.client.renderer.block.model.ItemOverrides;
-import net.minecraft.client.renderer.block.model.ItemTransforms;
-import net.minecraft.client.renderer.texture.MissingTextureAtlasSprite;
-import net.minecraft.client.renderer.texture.TextureAtlasSprite;
-import net.minecraft.client.resources.model.BakedModel;
-import net.minecraftforge.api.distmarker.Dist;
-import net.minecraftforge.api.distmarker.OnlyIn;
-
-@OnlyIn(Dist.CLIENT)
-public interface ItemBakedModel extends BakedModel {
-
-    @Override
-    default boolean useAmbientOcclusion() {
-        return true;
-    }
-
-    @Override
-    default boolean isGui3d() {
-        return true;
-    }
-
-    @Override
-    default boolean usesBlockLight() {
-        return true;
-    }
-
-    @Override
-    default boolean isCustomRenderer() {
-        return false;
-    }
-
-    @Override
-    default TextureAtlasSprite getParticleIcon() {
-        return ModelFactory.getBlockSprite(MissingTextureAtlasSprite.getLocation());
-    }
-
-    @Override
-    default ItemTransforms getTransforms() {
-        return ModelFactory.MODEL_TRANSFORM_BLOCK;
-    }
-
-    @Override
-    default ItemOverrides getOverrides() {
-        return ItemOverrides.EMPTY;
-    }
-}
diff --git a/src/main/java/com/gregtechceu/gtceu/client/renderer/BlockHighlightRenderer.java b/src/main/java/com/gregtechceu/gtceu/client/renderer/BlockHighlightRenderer.java
index d0a7a3849ec..684ebe3602a 100644
--- a/src/main/java/com/gregtechceu/gtceu/client/renderer/BlockHighlightRenderer.java
+++ b/src/main/java/com/gregtechceu/gtceu/client/renderer/BlockHighlightRenderer.java
@@ -3,7 +3,6 @@
 import com.gregtechceu.gtceu.api.blockentity.PipeBlockEntity;
 import com.gregtechceu.gtceu.api.capability.GTCapabilityHelper;
 import com.gregtechceu.gtceu.api.capability.ICoverable;
-import com.gregtechceu.gtceu.api.gui.GuiTextures;
 import com.gregtechceu.gtceu.api.item.PipeBlockItem;
 import com.gregtechceu.gtceu.api.item.tool.GTToolType;
 import com.gregtechceu.gtceu.api.item.tool.IToolGridHighlight;
@@ -14,8 +13,7 @@
 import com.gregtechceu.gtceu.client.util.RenderUtil;
 import com.gregtechceu.gtceu.common.item.behavior.CoverPlaceBehavior;
 import com.gregtechceu.gtceu.common.item.tool.rotation.CustomBlockRotations;
-
-import com.lowdragmc.lowdraglib.gui.texture.ResourceTexture;
+import com.gregtechceu.gtceu.common.mui.GTGuiTextures;
 
 import net.minecraft.client.Camera;
 import net.minecraft.client.Minecraft;
@@ -34,9 +32,11 @@
 import net.minecraftforge.api.distmarker.Dist;
 import net.minecraftforge.api.distmarker.OnlyIn;
 
+import brachy.modularui.drawable.UITexture;
 import com.mojang.blaze3d.systems.RenderSystem;
 import com.mojang.blaze3d.vertex.*;
 import lombok.experimental.ExtensionMethod;
+import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 import org.joml.Quaternionfc;
 import org.joml.Vector3f;
@@ -78,9 +78,11 @@ public static void renderBlockHighlight(PoseStack poseStack, Camera camera, Bloc
                         gridHighlight = new IToolGridHighlight() {
 
                             @Override
-                            public @Nullable ResourceTexture sideTips(Player player, BlockPos pos, BlockState state,
-                                                                      Set<GTToolType> toolTypes, Direction side) {
-                                return behavior.showSideTip(state, side) ? GuiTextures.TOOL_FRONT_FACING_ROTATION :
+                            public @Nullable UITexture sideTips(@NotNull Player player, @NotNull BlockPos pos,
+                                                                @NotNull BlockState state,
+                                                                @NotNull Set<GTToolType> toolTypes,
+                                                                @NotNull Direction side) {
+                                return behavior.showSideTip(state, side) ? GTGuiTextures.TOOL_FRONT_FACING_ROTATION :
                                         null;
                             }
                         };
@@ -116,7 +118,7 @@ public static void renderBlockHighlight(PoseStack poseStack, Camera camera, Bloc
                         poseStack.scale(1f / 16, 1f / 16, 0);
                         poseStack.translate(-8, -8, 0);
 
-                        drawResourceTexture(poseStack, multiBufferSource, texture, 0xffffffff,
+                        drawOverlayTexture(poseStack, multiBufferSource, texture, 0xffffffff,
                                 4, 4, 8, 8);
 
                         RenderSystem.disableBlend();
@@ -134,7 +136,7 @@ public static void renderBlockHighlight(PoseStack poseStack, Camera camera, Bloc
                 poseStack.pushPose();
 
                 drawGridOverlays(poseStack, multiBufferSource, cameraPos, target,
-                        side -> coverable.hasCover(side) ? null : GuiTextures.TOOL_ATTACH_COVER);
+                        side -> coverable.hasCover(side) ? null : GTGuiTextures.TOOL_ATTACH_COVER);
 
                 poseStack.popPose();
             }
@@ -160,7 +162,7 @@ public static void renderBlockHighlight(PoseStack poseStack, Camera camera, Bloc
     private static float bColour;
 
     private static void drawGridOverlays(PoseStack poseStack, MultiBufferSource bufferSource, Vec3 cameraPos,
-                                         BlockHitResult blockHitResult, Function<Direction, ResourceTexture> texture) {
+                                         BlockHitResult blockHitResult, Function<Direction, UITexture> texture) {
         rColour = gColour = 0.2F + (float) Math.sin((System.currentTimeMillis() % (Mth.PI * 800)) / 800) / 2;
         bColour = 1f;
         BlockPos blockPos = blockHitResult.getBlockPos();
@@ -199,12 +201,12 @@ private static void drawGridOverlays(PoseStack poseStack, MultiBufferSource buff
         shiftX.rotate(rotation);
         shiftY.rotate(rotation);
 
-        ResourceTexture leftBlocked = texture.apply(left);
-        ResourceTexture rightBlocked = texture.apply(right);
-        ResourceTexture topBlocked = texture.apply(top);
-        ResourceTexture bottomBlocked = texture.apply(bottom);
-        ResourceTexture frontBlocked = texture.apply(front);
-        ResourceTexture backBlocked = texture.apply(back);
+        UITexture leftBlocked = texture.apply(left);
+        UITexture rightBlocked = texture.apply(right);
+        UITexture topBlocked = texture.apply(top);
+        UITexture bottomBlocked = texture.apply(bottom);
+        UITexture frontBlocked = texture.apply(front);
+        UITexture backBlocked = texture.apply(back);
 
         topRight.add(cubeCenter);
         bottomRight.add(cubeCenter);
@@ -241,30 +243,30 @@ private static void drawGridOverlays(PoseStack poseStack, MultiBufferSource buff
 
         if (leftBlocked != null) {
             int color = attachSide == left ? 0xffffffff : 0x44ffffff;
-            drawResourceTextureWithMargin(poseStack, bufferSource, leftBlocked, color, 0, 6, 4, 4, MARGIN);
+            drawOverlayTextureWithMargin(poseStack, bufferSource, leftBlocked, color, 0, 6, MARGIN);
         }
         if (topBlocked != null) {
             int color = attachSide == top ? 0xffffffff : 0x44ffffff;
-            drawResourceTextureWithMargin(poseStack, bufferSource, topBlocked, color, 6, 12, 4, 4, MARGIN);
+            drawOverlayTextureWithMargin(poseStack, bufferSource, topBlocked, color, 6, 12, MARGIN);
         }
         if (rightBlocked != null) {
             int color = attachSide == right ? 0xffffffff : 0x44ffffff;
-            drawResourceTextureWithMargin(poseStack, bufferSource, rightBlocked, color, 12, 6, 4, 4, MARGIN);
+            drawOverlayTextureWithMargin(poseStack, bufferSource, rightBlocked, color, 12, 6, MARGIN);
         }
         if (bottomBlocked != null) {
             int color = attachSide == bottom ? 0xffffffff : 0x44ffffff;
-            drawResourceTextureWithMargin(poseStack, bufferSource, bottomBlocked, color, 6, 0, 4, 4, MARGIN);
+            drawOverlayTextureWithMargin(poseStack, bufferSource, bottomBlocked, color, 6, 0, MARGIN);
         }
         if (frontBlocked != null) {
             int color = attachSide == front ? 0xffffffff : 0x44ffffff;
-            drawResourceTextureWithMargin(poseStack, bufferSource, frontBlocked, color, 6, 6, 4, 4, MARGIN);
+            drawOverlayTextureWithMargin(poseStack, bufferSource, frontBlocked, color, 6, 6, MARGIN);
         }
         if (backBlocked != null) {
             int color = attachSide == back ? 0xffffffff : 0x44ffffff;
-            drawResourceTextureWithMargin(poseStack, bufferSource, backBlocked, color, 0, 0, 4, 4, MARGIN);
-            drawResourceTextureWithMargin(poseStack, bufferSource, backBlocked, color, 12, 0, 4, 4, MARGIN);
-            drawResourceTextureWithMargin(poseStack, bufferSource, backBlocked, color, 0, 12, 4, 4, MARGIN);
-            drawResourceTextureWithMargin(poseStack, bufferSource, backBlocked, color, 12, 12, 4, 4, MARGIN);
+            drawOverlayTextureWithMargin(poseStack, bufferSource, backBlocked, color, 0, 0, MARGIN);
+            drawOverlayTextureWithMargin(poseStack, bufferSource, backBlocked, color, 12, 0, MARGIN);
+            drawOverlayTextureWithMargin(poseStack, bufferSource, backBlocked, color, 0, 12, MARGIN);
+            drawOverlayTextureWithMargin(poseStack, bufferSource, backBlocked, color, 12, 12, MARGIN);
         }
         RenderSystem.disableBlend();
         RenderSystem.enableDepthTest();
@@ -286,13 +288,13 @@ private static void drawLine(PoseStack.Pose pose, VertexConsumer buffer, Vector3
                 .endVertex();
     }
 
-    private static void drawResourceTexture(PoseStack poseStack, MultiBufferSource bufferSource,
-                                            ResourceTexture texture, int color,
-                                            float x, float y, float w, float h) {
-        VertexConsumer consumer = bufferSource.getBuffer(RenderType.text(texture.imageLocation));
+    private static void drawOverlayTexture(PoseStack poseStack, MultiBufferSource bufferSource,
+                                           UITexture texture, int color,
+                                           float x, float y, float w, float h) {
+        VertexConsumer consumer = bufferSource.getBuffer(RenderType.text(texture.location));
         var pose = poseStack.last().pose();
-        float u0 = texture.offsetX, v0 = texture.offsetY;
-        float u1 = texture.imageWidth, v1 = texture.imageHeight;
+        float u0 = texture.u0, v0 = texture.v0;
+        float u1 = texture.u1, v1 = texture.v1;
         // spotless:off
         consumer.vertex(pose, x, y + h, 0).color(color).uv(u0, v0 + v1).uv2(LightTexture.FULL_BRIGHT).endVertex();
         consumer.vertex(pose, x + w, y + h, 0).color(color).uv(u0 + u1, v0 + v1).uv2(LightTexture.FULL_BRIGHT).endVertex();
@@ -301,10 +303,10 @@ private static void drawResourceTexture(PoseStack poseStack, MultiBufferSource b
         // spotless:on
     }
 
-    private static void drawResourceTextureWithMargin(PoseStack poseStack, MultiBufferSource bufferSource,
-                                                      ResourceTexture texture, int color,
-                                                      float x, float y, float w, float h, float m) {
-        drawResourceTexture(poseStack, bufferSource, texture, color,
-                x + m, y + m, w - 2 * m, h - 2 * m);
+    private static void drawOverlayTextureWithMargin(PoseStack poseStack, MultiBufferSource bufferSource,
+                                                     UITexture texture, int color,
+                                                     float x, float y, float m) {
+        drawOverlayTexture(poseStack, bufferSource, texture, color,
+                x + m, y + m, (float) 4 - 2 * m, (float) 4 - 2 * m);
     }
 }
diff --git a/src/main/java/com/gregtechceu/gtceu/client/renderer/GTRenderTypes.java b/src/main/java/com/gregtechceu/gtceu/client/renderer/GTRenderTypes.java
index ce3fea89a5d..6a66429ae93 100644
--- a/src/main/java/com/gregtechceu/gtceu/client/renderer/GTRenderTypes.java
+++ b/src/main/java/com/gregtechceu/gtceu/client/renderer/GTRenderTypes.java
@@ -40,6 +40,40 @@ public class GTRenderTypes extends RenderType {
                         .createCompositeState(false));
     });
 
+    private static final RenderType INWORLD_GUI = create("inworld_gui", DefaultVertexFormat.POSITION_COLOR_TEX_LIGHTMAP,
+            VertexFormat.Mode.QUADS,
+            RenderType.TRANSIENT_BUFFER_SIZE, false, true,
+            RenderType.CompositeState.builder()
+                    .setShaderState(RENDERTYPE_TRANSLUCENT_SHADER)
+                    .setTextureState(RenderStateShard.NO_TEXTURE)
+                    .setTransparencyState(TRANSLUCENT_TRANSPARENCY)
+                    .setLightmapState(LIGHTMAP)
+                    .createCompositeState(false));
+    private static final RenderType GUI_TRIANGLE_STRIP = RenderType.create("gui_triangle_strip",
+            DefaultVertexFormat.POSITION_COLOR, VertexFormat.Mode.TRIANGLE_STRIP, 256, false, false,
+            RenderType.CompositeState.builder()
+                    .setShaderState(RenderStateShard.RENDERTYPE_GUI_SHADER)
+                    .setTransparencyState(RenderStateShard.TRANSLUCENT_TRANSPARENCY)
+                    .setDepthTestState(RenderStateShard.LEQUAL_DEPTH_TEST)
+                    .createCompositeState(false));
+
+    private static final RenderType GUI_TRIANGLE_FAN = RenderType.create("gui_triangle_fan",
+            DefaultVertexFormat.POSITION_COLOR, VertexFormat.Mode.TRIANGLE_FAN, 256, false, false,
+            RenderType.CompositeState.builder()
+                    .setShaderState(RenderStateShard.RENDERTYPE_GUI_SHADER)
+                    .setTransparencyState(RenderStateShard.TRANSLUCENT_TRANSPARENCY)
+                    .setDepthTestState(RenderStateShard.LEQUAL_DEPTH_TEST)
+                    .createCompositeState(false));
+
+    private static final RenderType GUI_OVERLAY_TRIANGLE_FAN = RenderType.create("gui_overlay_triangle_fan",
+            DefaultVertexFormat.POSITION_COLOR, VertexFormat.Mode.TRIANGLE_FAN, 256, false, false,
+            RenderType.CompositeState.builder()
+                    .setShaderState(RenderStateShard.RENDERTYPE_GUI_OVERLAY_SHADER)
+                    .setTransparencyState(RenderStateShard.TRANSLUCENT_TRANSPARENCY)
+                    .setDepthTestState(RenderStateShard.NO_DEPTH_TEST)
+                    .setWriteMaskState(RenderStateShard.COLOR_WRITE)
+                    .createCompositeState(false));
+
     private GTRenderTypes(String name, VertexFormat format, VertexFormat.Mode mode, int bufferSize,
                           boolean affectsCrumbling, boolean sortOnUpload, Runnable setupState, Runnable clearState) {
         super(name, format, mode, bufferSize, affectsCrumbling, sortOnUpload, setupState, clearState);
@@ -56,4 +90,20 @@ public static RenderType getMonitor() {
     public static RenderType guiTexture(ResourceLocation texture) {
         return GUI_TEXTURE.apply(texture);
     }
+
+    public static RenderType inWorldGui() {
+        return INWORLD_GUI;
+    }
+
+    public static RenderType guiTriangleStrip() {
+        return GUI_TRIANGLE_STRIP;
+    }
+
+    public static RenderType guiTriangleFan() {
+        return GUI_TRIANGLE_FAN;
+    }
+
+    public static RenderType guiOverlayTriangleFan() {
+        return GUI_OVERLAY_TRIANGLE_FAN;
+    }
 }
diff --git a/src/main/java/com/gregtechceu/gtceu/client/renderer/cover/FacadeCoverRenderer.java b/src/main/java/com/gregtechceu/gtceu/client/renderer/cover/FacadeCoverRenderer.java
index ce935bc334a..c08ed35ed3c 100644
--- a/src/main/java/com/gregtechceu/gtceu/client/renderer/cover/FacadeCoverRenderer.java
+++ b/src/main/java/com/gregtechceu/gtceu/client/renderer/cover/FacadeCoverRenderer.java
@@ -3,7 +3,6 @@
 import com.gregtechceu.gtceu.api.cover.CoverBehavior;
 import com.gregtechceu.gtceu.api.item.ComponentItem;
 import com.gregtechceu.gtceu.client.model.BaseBakedModel;
-import com.gregtechceu.gtceu.client.model.ItemBakedModel;
 import com.gregtechceu.gtceu.client.model.TextureOverrideModel;
 import com.gregtechceu.gtceu.client.util.FacadeBlockAndTintGetter;
 import com.gregtechceu.gtceu.client.util.GTQuadTransformers;
@@ -12,6 +11,8 @@
 import com.gregtechceu.gtceu.common.item.behavior.FacadeItemBehaviour;
 import com.gregtechceu.gtceu.utils.GTUtil;
 
+import com.lowdragmc.lowdraglib.client.model.ModelFactory;
+
 import net.minecraft.Util;
 import net.minecraft.client.Minecraft;
 import net.minecraft.client.color.block.BlockColors;
@@ -19,6 +20,7 @@
 import net.minecraft.client.renderer.block.model.BakedQuad;
 import net.minecraft.client.renderer.block.model.ItemOverrides;
 import net.minecraft.client.renderer.block.model.ItemTransforms;
+import net.minecraft.client.renderer.texture.MissingTextureAtlasSprite;
 import net.minecraft.client.renderer.texture.TextureAtlasSprite;
 import net.minecraft.client.resources.model.BakedModel;
 import net.minecraft.client.resources.model.BlockModelRotation;
@@ -67,7 +69,7 @@ public class FacadeCoverRenderer extends BaseBakedModel implements ICoverRendere
     });
 
     public static final FacadeCoverRenderer INSTANCE = new FacadeCoverRenderer();
-    private static final Int2ObjectMap<ItemBakedModel> CACHE = new Int2ObjectArrayMap<>();
+    private static final Int2ObjectMap<BakedModel> CACHE = new Int2ObjectArrayMap<>();
 
     @OnlyIn(Dist.CLIENT)
     private @Nullable BakedModel defaultItemModel;
@@ -110,7 +112,7 @@ public static void clearItemModelCache() {
         }
 
         int hash = facadeState.hashCode();
-        ItemBakedModel model = CACHE.computeIfAbsent(hash, $ -> new ItemBakedModel() {
+        BakedModel model = CACHE.computeIfAbsent(hash, $ -> new BakedModel() {
 
             private final FacadeBlockAndTintGetter level = new FacadeBlockAndTintGetter(mc.level,
                     BlockPos.ZERO, facadeState, null);
@@ -127,6 +129,41 @@ public static void clearItemModelCache() {
                                                      @Nullable RenderType renderType) {
                 return getFacadeQuads(facadeState, level, rand, extraData, renderType);
             }
+
+            @Override
+            public boolean useAmbientOcclusion() {
+                return true;
+            }
+
+            @Override
+            public boolean isGui3d() {
+                return true;
+            }
+
+            @Override
+            public boolean usesBlockLight() {
+                return true;
+            }
+
+            @Override
+            public boolean isCustomRenderer() {
+                return false;
+            }
+
+            @Override
+            public TextureAtlasSprite getParticleIcon() {
+                return ModelFactory.getBlockSprite(MissingTextureAtlasSprite.getLocation());
+            }
+
+            @Override
+            public ItemTransforms getTransforms() {
+                return ModelFactory.MODEL_TRANSFORM_BLOCK;
+            }
+
+            @Override
+            public ItemOverrides getOverrides() {
+                return ItemOverrides.EMPTY;
+            }
         });
         return Collections.singletonList(model);
     }
diff --git a/src/main/java/com/gregtechceu/gtceu/client/renderer/item/decorator/GTTankItemFluidPreview.java b/src/main/java/com/gregtechceu/gtceu/client/renderer/item/decorator/GTTankItemFluidPreview.java
index be518be13ad..ac15b2744fd 100644
--- a/src/main/java/com/gregtechceu/gtceu/client/renderer/item/decorator/GTTankItemFluidPreview.java
+++ b/src/main/java/com/gregtechceu/gtceu/client/renderer/item/decorator/GTTankItemFluidPreview.java
@@ -15,6 +15,7 @@
 import net.minecraftforge.fluids.capability.IFluidHandlerItem;
 
 import com.mojang.blaze3d.systems.RenderSystem;
+import com.mojang.blaze3d.vertex.*;
 import lombok.Getter;
 import lombok.Setter;
 import org.jetbrains.annotations.Range;
diff --git a/src/main/java/com/gregtechceu/gtceu/client/renderer/machine/impl/CentralMonitorRender.java b/src/main/java/com/gregtechceu/gtceu/client/renderer/machine/impl/CentralMonitorRender.java
index 68719e58cba..fd1757e5a47 100644
--- a/src/main/java/com/gregtechceu/gtceu/client/renderer/machine/impl/CentralMonitorRender.java
+++ b/src/main/java/com/gregtechceu/gtceu/client/renderer/machine/impl/CentralMonitorRender.java
@@ -43,7 +43,7 @@ public void render(CentralMonitorMachine machine, float partialTick, PoseStack p
         RenderUtil.rotateToFace(poseStack, machine.getFrontFacing(), machine.getUpwardsFacing());
         poseStack.translate(-machine.getRightDist() - 0.5f, -machine.getUpDist() - 0.5f, SCREEN_OFFSET_Z);
 
-        if (machine.getRecipeLogic().isActive()) {
+        if (machine.getRecipeLogic().isWorking()) {
             for (MonitorGroup group : machine.getMonitorGroups()) {
                 ItemStack itemStack = group.getItemStackHandler().getStackInSlot(0);
                 if (!(itemStack.getItem() instanceof ComponentItem item)) {
@@ -54,7 +54,7 @@ public void render(CentralMonitorMachine machine, float partialTick, PoseStack p
                         continue;
                     }
                     poseStack.pushPose();
-                    module.getRenderer(group.getItemStackHandler().getStackInSlot(0))
+                    module.getRenderer(group.getItemStackHandler().getStackInSlot(0), machine, group)
                             .render(machine, group, partialTick, poseStack, buffer, packedLight, packedOverlay);
                     poseStack.popPose();
                 }
diff --git a/src/main/java/com/gregtechceu/gtceu/client/renderer/monitor/MonitorGuiRenderer.java b/src/main/java/com/gregtechceu/gtceu/client/renderer/monitor/MonitorGuiRenderer.java
new file mode 100644
index 00000000000..66819fe5073
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/client/renderer/monitor/MonitorGuiRenderer.java
@@ -0,0 +1,228 @@
+package com.gregtechceu.gtceu.client.renderer.monitor;
+
+import com.gregtechceu.gtceu.api.machine.MetaMachine;
+import com.gregtechceu.gtceu.api.machine.feature.IMuiMachine;
+import com.gregtechceu.gtceu.api.mui.factory.MachineUIFactory;
+import com.gregtechceu.gtceu.common.machine.multiblock.electric.CentralMonitorMachine;
+import com.gregtechceu.gtceu.common.machine.multiblock.electric.monitor.MonitorGroup;
+import com.gregtechceu.gtceu.common.machine.multiblock.part.monitor.AdvancedMonitorPartMachine;
+import com.gregtechceu.gtceu.common.machine.multiblock.part.monitor.MonitorPartMachine;
+import com.gregtechceu.gtceu.utils.GTUtil;
+
+import net.minecraft.client.Minecraft;
+import net.minecraft.client.gui.screens.Screen;
+import net.minecraft.client.renderer.MultiBufferSource;
+import net.minecraft.core.BlockPos;
+import net.minecraft.world.entity.player.Player;
+import net.minecraft.world.level.Level;
+import net.minecraft.world.phys.BlockHitResult;
+import net.minecraft.world.phys.HitResult;
+import net.minecraftforge.common.ForgeMod;
+import net.minecraftforge.common.MinecraftForge;
+
+import brachy.modularui.api.MCHelper;
+import brachy.modularui.factory.GuiManager;
+import brachy.modularui.factory.PosGuiData;
+import brachy.modularui.screen.*;
+import com.mojang.blaze3d.pipeline.RenderTarget;
+import com.mojang.blaze3d.pipeline.TextureTarget;
+import com.mojang.blaze3d.vertex.*;
+import com.mojang.datafixers.util.Pair;
+import org.joml.Vector2d;
+import org.lwjgl.glfw.GLFW;
+
+public class MonitorGuiRenderer implements IMonitorRenderer {
+
+    private static final int RESOLUTION_COEF = 2;
+
+    private ModularScreen screen;
+    private Screen vanillaScreen;
+    private int width = 200, height = 200;
+    private int mouseX = -1, mouseY = -1;
+    private final Level targetLevel;
+    private final BlockPos targetPos;
+    private final RenderTarget renderTarget = new TextureTarget(width, height, true, Minecraft.ON_OSX);
+
+    public MonitorGuiRenderer(Pair<Level, BlockPos> target) {
+        MinecraftForge.EVENT_BUS.register(this);
+        this.targetLevel = target.getFirst();
+        this.targetPos = target.getSecond();
+        if (target.getSecond() == null) {
+            screen = null;
+            vanillaScreen = null;
+            return;
+        }
+        MetaMachine targetMachine = MetaMachine.getMachine(target.getFirst(), target.getSecond());
+        if (targetMachine != null &&
+                (targetMachine.getDefinition().getUI() != null || targetMachine instanceof IMuiMachine)) {
+            GuiManager.openFromClient(MachineUIFactory.INSTANCE,
+                    new PosGuiData(MCHelper.getPlayer(), target.getSecond()));
+        } else {
+            screen = null;
+            vanillaScreen = null;
+        }
+    }
+
+    /*
+     * @SubscribeEvent
+     * public void openClientInWorldUI(InWorldMUIOpenEvent event) {
+     * if (this.targetPos != null && event.getGuiData() instanceof PosGuiData posGuiData) {
+     * if (posGuiData.getBlockPos().asLong() == targetPos.asLong() && posGuiData.getLevel() == targetLevel) {
+     * this.screen = event.getScreen();
+     * this.vanillaScreen = event.getVanillaScreen();
+     * this.vanillaScreen.init(MCHelper.getMc(), this.width, this.height);
+     * this.screen.onResize(this.width, this.height);
+     * ModularPanel<?> mainPanel = this.screen.getMainPanel();
+     * for (IWidget child : mainPanel.getChildren()) {
+     * if (child instanceof SlotGroupWidget slotGroupWidget && slotGroupWidget.nameContains("player_inventory")) {
+     * slotGroupWidget.disabled();
+     * mainPanel.height(mainPanel.getArea().height - slotGroupWidget.getArea().height);
+     * mainPanel.scheduleResize();
+     * }
+     * }
+     * }
+     * }
+     * }
+     * 
+     * 
+     * @SubscribeEvent
+     * public void keyPressedEvent(EarlyKeyPressEvent event) {
+     * if (mouseX < 0 || mouseX > width || mouseY < 0 || mouseY > height || MCHelper.getCurrentScreen() != null)
+     * return;
+     * screen.getContext().updateLatestKey(event.getKey(), event.getScanCode(), event.getModifiers());
+     * boolean early = ClientScreenHandler.handleKeyboardInput(screen, vanillaScreen,
+     * event.getAction() == InputConstants.PRESS,
+     * ClientScreenHandler.InputPhase.EARLY, event.getKey(), event.getScanCode(), event.getModifiers());
+     * if (early) event.setCanceled(true);
+     * else {
+     * boolean late = ClientScreenHandler.handleKeyboardInput(screen, vanillaScreen,
+     * event.getAction() == InputConstants.PRESS,
+     * ClientScreenHandler.InputPhase.LATE, event.getKey(), event.getScanCode(), event.getModifiers());
+     * if (late) event.setCanceled(true);
+     * }
+     * }
+     * 
+     * @SubscribeEvent
+     * public void charTyped(CharTypedEvent event) {
+     * if (mouseX < 0 || mouseX > width || mouseY < 0 || mouseY > height || MCHelper.getCurrentScreen() != null)
+     * return;
+     * screen.getContext().updateLatestTypedChar(event.getCodepoint(), event.getModifiers());
+     * if (screen.charTyped(event.getCodepoint(), event.getModifiers())) event.setCanceled(true);
+     * }
+     * 
+     * 
+     * @SubscribeEvent
+     * public void onInWorldGuiRender(InWorldMUIRenderEvent event) {
+     * renderGuiToBuffer(event.getGraphics(), event.getPartialTick());
+     * }
+     * 
+     * @SuppressWarnings("UnstableApiUsage")
+     * public void renderGuiToBuffer(GuiGraphics guiGraphics, float partialTick) {
+     * if (screen == null || MCHelper.getPlayer() == null) return;
+     * screen.getContext().setGraphics(guiGraphics);
+     * screen.onFrameUpdate();
+     * if (width * height == 0) return;
+     * if (renderTarget.width != RESOLUTION_COEF * width || renderTarget.height != RESOLUTION_COEF * height)
+     * renderTarget.resize(RESOLUTION_COEF * width, RESOLUTION_COEF * height, Minecraft.ON_OSX);
+     * renderTarget.enableStencil();
+     * renderTarget.clear(Minecraft.ON_OSX);
+     * 
+     * renderTarget.bindWrite(true);
+     * 
+     * RenderSystem.clear(256, Minecraft.ON_OSX);
+     * Matrix4f matrix4f = new Matrix4f().setOrtho(0.0F, RESOLUTION_COEF * width, RESOLUTION_COEF * height, 0.0F,
+     * 1000.0F,
+     * ForgeHooksClient.getGuiFarPlane());
+     * RenderSystem.setProjectionMatrix(matrix4f, VertexSorting.ORTHOGRAPHIC_Z);
+     * PoseStack posestack = RenderSystem.getModelViewStack();
+     * posestack.pushPose();
+     * posestack.setIdentity();
+     * posestack.translate(0.0D, 0.0D, 1000F - ForgeHooksClient.getGuiFarPlane());
+     * posestack.scale(RESOLUTION_COEF, RESOLUTION_COEF, RESOLUTION_COEF);
+     * RenderSystem.applyModelViewMatrix();
+     * 
+     * ClientScreenHandler.drawScreen(guiGraphics, screen, vanillaScreen, mouseX, mouseY, partialTick);
+     * ClientScreenHandler.drawDebugScreen(guiGraphics, screen, screen);
+     * 
+     * posestack.popPose();
+     * RenderSystem.applyModelViewMatrix();
+     * 
+     * renderTarget.unbindWrite();
+     * Minecraft.getInstance().getMainRenderTarget().bindWrite(true);
+     * }
+     * 
+     * public void renderGui(int maxWidth, int maxHeight, PoseStack poseStack, MultiBufferSource buffer,
+     * float partialTick, int mouseX, int mouseY) {
+     * poseStack.scale(1 / 256f, 1 / 256f, 1 / 256e3f);
+     * boolean resized = false;
+     * if (maxWidth * 256 != width) {
+     * width = maxWidth * 256;
+     * resized = true;
+     * }
+     * if (maxHeight * 256 != height) {
+     * height = maxHeight * 256;
+     * resized = true;
+     * }
+     * if (resized) screen.onResize(width, height);
+     * screen.getContext().updateState(mouseX, mouseY, partialTick);
+     * screen.onFrameUpdate();
+     * AnimatorManager.INSTANCE.onDraw(null);
+     * if (width * height == 0) return;
+     * RenderSystem.setShaderTexture(0, renderTarget.getColorTextureId());
+     * ShaderInstance shaderInstance = MCHelper.getMc().gameRenderer.blitShader;
+     * shaderInstance.setSampler("DiffuseSampler", renderTarget.getColorTextureId());
+     * Matrix4f pose = poseStack.last().pose();
+     * double fov = ((IGameRenderer) MCHelper.getMc().gameRenderer).gtceu$getFov(partialTick);
+     * if (shaderInstance.PROJECTION_MATRIX != null)
+     * shaderInstance.PROJECTION_MATRIX.set(MCHelper.getMc().gameRenderer.getProjectionMatrix(fov));
+     * 
+     * if (shaderInstance.MODEL_VIEW_MATRIX != null) shaderInstance.MODEL_VIEW_MATRIX.set(pose);
+     * shaderInstance.apply();
+     * Tesselator tesselator = RenderSystem.renderThreadTesselator();
+     * BufferBuilder bufferbuilder = tesselator.getBuilder();
+     * bufferbuilder.begin(VertexFormat.Mode.QUADS, DefaultVertexFormat.POSITION_TEX_COLOR);
+     * bufferbuilder.vertex(0.0D, height, 0.0D).uv(0.0F, 0.0F).color(255, 255, 255, 255).endVertex();
+     * bufferbuilder.vertex(width, height, 0.0D).uv(1, 0.0F).color(255, 255, 255, 255).endVertex();
+     * bufferbuilder.vertex(width, 0.0D, 0.0D).uv(1, 1).color(255, 255, 255, 255).endVertex();
+     * bufferbuilder.vertex(0.0D, 0.0D, 0.0D).uv(0.0F, 1).color(255, 255, 255, 255).endVertex();
+     * BufferUploader.draw(bufferbuilder.end());
+     * shaderInstance.clear();
+     * }
+     */
+
+    @Override
+    public void render(CentralMonitorMachine machine, MonitorGroup group, float partialTick, PoseStack poseStack,
+                       MultiBufferSource buffer, int packedLight, int packedOverlay) {
+        if (screen == null || group.isEmpty()) return;
+        BlockPos rel = group.getRow(0, machine::toRelative).get(0);
+        BlockPos size = GTUtil.getLast(group.getRow(-1, machine::toRelative))
+                .offset(-rel.getX() + 1, -rel.getY() + 1, -rel.getZ() + 1);
+        poseStack.translate(rel.getX(), rel.getY(), rel.getZ());
+        Player player = MCHelper.getPlayer();
+        HitResult hit = player.pick(player.getAttributeValue(ForgeMod.BLOCK_REACH.get()), partialTick, false);
+        double mouseX = -1, mouseY = -1;
+        if (hit instanceof BlockHitResult blockHit) {
+            BlockPos pos = blockHit.getBlockPos();
+            BlockPos relPos = machine.toRelative(pos);
+            if (MetaMachine.getMachine(player.level(), pos) instanceof MonitorPartMachine monitor) {
+                Vector2d monitorMousePos = monitor.getMousePos(hit);
+                mouseX = relPos.getX() - rel.getX() + monitorMousePos.x();
+                mouseY = relPos.getY() - rel.getY() + 1 - monitorMousePos.y();
+                if (monitor instanceof AdvancedMonitorPartMachine advancedMonitor && mouseX >= 0 && mouseY >= 0 &&
+                        mouseX <= width && mouseY <= height) {
+                    if (advancedMonitor.isClickedThisFrame()) {
+                        this.screen.onMousePressed(mouseX * 256, mouseY * 256, GLFW.GLFW_MOUSE_BUTTON_LEFT);
+                        this.vanillaScreen.mouseClicked(mouseX * 256, mouseY * 256, GLFW.GLFW_MOUSE_BUTTON_LEFT);
+                        advancedMonitor.setClickedThisFrame(false);
+                    }
+                }
+            }
+        }
+        if (mouseX >= 0 && mouseY >= 0 && mouseX * 256 <= width && mouseY * 256 <= height) {
+            this.mouseX = (int) (mouseX * 256);
+            this.mouseY = (int) (mouseY * 256);
+        }
+        // renderGui(size.getX(), size.getY(), poseStack, buffer, partialTick, (int) (mouseX * 256), (int) (mouseY *
+        // 256));
+    }
+}
diff --git a/src/main/java/com/gregtechceu/gtceu/client/renderer/placeholder/ModulePlaceholderRenderer.java b/src/main/java/com/gregtechceu/gtceu/client/renderer/placeholder/ModulePlaceholderRenderer.java
index 1df2c9ef08f..067a14a5110 100644
--- a/src/main/java/com/gregtechceu/gtceu/client/renderer/placeholder/ModulePlaceholderRenderer.java
+++ b/src/main/java/com/gregtechceu/gtceu/client/renderer/placeholder/ModulePlaceholderRenderer.java
@@ -22,7 +22,8 @@ public void render(CentralMonitorMachine machine, MonitorGroup group, float part
         if (stack.getItem() instanceof IComponentItem componentItem) {
             for (IItemComponent component : componentItem.getComponents()) {
                 if (component instanceof IMonitorModuleItem module) {
-                    module.getRenderer(stack).render(machine, group, partialTick, poseStack, buffer, packedLight,
+                    module.getRenderer(stack, machine, group).render(machine, group, partialTick, poseStack, buffer,
+                            packedLight,
                             packedOverlay);
                 }
             }
diff --git a/src/main/java/com/gregtechceu/gtceu/client/util/StaticFaceBakery.java b/src/main/java/com/gregtechceu/gtceu/client/util/StaticFaceBakery.java
index dd7b1c9a7c0..426619e17d4 100644
--- a/src/main/java/com/gregtechceu/gtceu/client/util/StaticFaceBakery.java
+++ b/src/main/java/com/gregtechceu/gtceu/client/util/StaticFaceBakery.java
@@ -1,7 +1,5 @@
 package com.gregtechceu.gtceu.client.util;
 
-import com.lowdragmc.lowdraglib.client.bakedpipeline.FaceQuad;
-
 import net.minecraft.client.renderer.FaceInfo;
 import net.minecraft.client.renderer.block.model.*;
 import net.minecraft.client.renderer.texture.TextureAtlasSprite;
@@ -25,6 +23,8 @@
 
 public class StaticFaceBakery {
 
+    public static final AABB BLOCK = new AABB(0, 0, 0, 1, 1, 1);
+
     public static final AABB SLIGHTLY_OVER_BLOCK = new AABB(-0.001f, -0.001f, -0.001f,
             1.001f, 1.001f, 1.001f);
     public static final AABB OUTPUT_OVERLAY = new AABB(-.006f, -.006f, -.006f,
@@ -71,7 +71,7 @@ public static BakedQuad bakeFace(AABB cube, Direction face, TextureAtlasSprite s
 
     public static BakedQuad bakeFace(Direction face, TextureAtlasSprite sprite, ModelState rotation, int tintIndex,
                                      int emissivity, boolean cull, boolean shade) {
-        return bakeFace(FaceQuad.BLOCK, face, sprite, rotation, tintIndex, emissivity, cull, shade);
+        return bakeFace(BLOCK, face, sprite, rotation, tintIndex, emissivity, cull, shade);
     }
 
     public static BakedQuad bakeFace(Direction face, TextureAtlasSprite sprite, ModelState rotation, int tintIndex,
diff --git a/src/main/java/com/gregtechceu/gtceu/common/CommonEventListener.java b/src/main/java/com/gregtechceu/gtceu/common/CommonEventListener.java
index aa13751d7bd..fe7bb936654 100644
--- a/src/main/java/com/gregtechceu/gtceu/common/CommonEventListener.java
+++ b/src/main/java/com/gregtechceu/gtceu/common/CommonEventListener.java
@@ -25,9 +25,10 @@
 import com.gregtechceu.gtceu.api.fluids.FluidState;
 import com.gregtechceu.gtceu.api.fluids.store.FluidStorageKeys;
 import com.gregtechceu.gtceu.api.item.armor.ArmorComponentItem;
+import com.gregtechceu.gtceu.api.item.module.AppliedItemModule;
+import com.gregtechceu.gtceu.api.item.module.IModularItem;
 import com.gregtechceu.gtceu.api.item.tool.GTToolType;
 import com.gregtechceu.gtceu.api.machine.MetaMachine;
-import com.gregtechceu.gtceu.api.misc.virtualregistry.VirtualEnderRegistry;
 import com.gregtechceu.gtceu.api.pattern.MultiblockWorldSavedData;
 import com.gregtechceu.gtceu.api.registry.GTRegistries;
 import com.gregtechceu.gtceu.common.capability.EnvironmentalHazardSavedData;
@@ -71,9 +72,11 @@
 import net.minecraft.server.level.ServerLevel;
 import net.minecraft.server.level.ServerPlayer;
 import net.minecraft.world.Difficulty;
+import net.minecraft.world.damagesource.DamageSource;
 import net.minecraft.world.effect.MobEffectInstance;
 import net.minecraft.world.entity.Entity;
 import net.minecraft.world.entity.EquipmentSlot;
+import net.minecraft.world.entity.LivingEntity;
 import net.minecraft.world.entity.Mob;
 import net.minecraft.world.entity.ai.attributes.AttributeModifier;
 import net.minecraft.world.entity.ai.attributes.Attributes;
@@ -314,7 +317,6 @@ public static void serverStarting(ServerStartingEvent event) {
     @SubscribeEvent
     public static void serverStopped(ServerStoppedEvent event) {
         ServerCache.instance.clear();
-        VirtualEnderRegistry.release();
     }
 
     @SubscribeEvent
@@ -362,7 +364,7 @@ public static void onDatapackSync(OnDatapackSyncEvent event) {
     }
 
     @SubscribeEvent(priority = EventPriority.LOW)
-    public static void onEntityLivingFallEvent(LivingFallEvent event) {
+    public static void onLivingFall(LivingFallEvent event) {
         if (event.getEntity() instanceof ServerPlayer player) {
             if (player.fallDistance < 3.2f)
                 return;
@@ -387,6 +389,24 @@ public static void onEntityLivingFallEvent(LivingFallEvent event) {
     }
 
     @SubscribeEvent
+    public static void onLivingTick(LivingEvent.LivingTickEvent event) {
+        LivingEntity entity = event.getEntity();
+
+        for (ItemStack stack : entity.getArmorSlots()) {
+            IModularItem modularItem = GTCapabilityHelper.getModularItem(stack);
+            if (modularItem == null) continue;
+            modularItem.getAppliedModules().forEach(appliedItemModule -> appliedItemModule.armorTick(entity));
+        }
+
+        if (entity instanceof Player player) {
+            for (ItemStack stack : entity.getAllSlots()) {
+                IModularItem modularItem = GTCapabilityHelper.getModularItem(stack);
+                if (modularItem == null) continue;
+                modularItem.getAppliedModules().forEach(appliedItemModule -> appliedItemModule.inventoryTick(player));
+            }
+        }
+    }
+
     public static void playerTickEvent(TickEvent.PlayerTickEvent event) {
         Player player = event.player;
         if (event.phase == TickEvent.Phase.START && !player.level().isClientSide) {
@@ -427,20 +447,59 @@ public static void playerTickEvent(TickEvent.PlayerTickEvent event) {
     @SubscribeEvent
     public static void stepAssistHandler(LivingEvent.LivingTickEvent event) {
         float MAGIC_STEP_HEIGHT = 1.0023f;
-        if (event.getEntity() == null || !(event.getEntity() instanceof Player player)) return;
-        CompoundTag tag = player.getItemBySlot(EquipmentSlot.FEET).getOrCreateTag();
-        if (!player.isCrouching() && player.getItemBySlot(EquipmentSlot.FEET).is(CustomTags.STEP_BOOTS) &&
+        LivingEntity entity = event.getEntity();
+        CompoundTag tag = entity.getItemBySlot(EquipmentSlot.FEET).getOrCreateTag();
+        if (!entity.isCrouching() && entity.getItemBySlot(EquipmentSlot.FEET).is(CustomTags.STEP_BOOTS) &&
                 (!tag.contains("stepAssist") || tag.getBoolean("stepAssist"))) {
-            if (player.getStepHeight() < MAGIC_STEP_HEIGHT) {
-                player.setMaxUpStep(MAGIC_STEP_HEIGHT);
+            if (entity.getStepHeight() < MAGIC_STEP_HEIGHT) {
+                entity.setMaxUpStep(MAGIC_STEP_HEIGHT);
+            }
+        } else if (entity.getStepHeight() == MAGIC_STEP_HEIGHT) {
+            entity.setMaxUpStep(0.6f);
+        }
+    }
+
+    @SubscribeEvent
+    public static void onLivingEquipmentChange(LivingEquipmentChangeEvent event) {
+        final LivingEntity entity = event.getEntity();
+        final ItemStack old = event.getFrom();
+        final ItemStack current = event.getTo();
+
+        if (ItemStack.matches(old, current)) {
+            return;
+        }
+
+        if (!old.isEmpty()) {
+            IModularItem modularItem = GTCapabilityHelper.getModularItem(old);
+            if (modularItem != null)
+                modularItem.getAppliedModules().forEach(appliedItemModule -> appliedItemModule.unequip(entity));
+        }
+
+        if (!current.isEmpty()) {
+            IModularItem modularItem = GTCapabilityHelper.getModularItem(current);
+            if (modularItem != null)
+                modularItem.getAppliedModules().forEach(appliedItemModule -> appliedItemModule.equip(entity));
+        }
+    }
+
+    @SubscribeEvent
+    public static void onLivingHurt(LivingHurtEvent event) {
+        final LivingEntity entity = event.getEntity();
+        final DamageSource source = event.getSource();
+
+        for (final ItemStack stack : entity.getArmorSlots()) {
+            float amount = event.getAmount();
+            IModularItem modularItem = GTCapabilityHelper.getModularItem(stack);
+            if (modularItem == null) continue;
+            for (AppliedItemModule appliedItemModule : modularItem.getAppliedModules()) {
+                amount = appliedItemModule.changeDamage(entity, amount, source);
             }
-        } else if (player.getStepHeight() == MAGIC_STEP_HEIGHT) {
-            player.setMaxUpStep(0.6f);
+            event.setAmount(amount);
         }
     }
 
     @SubscribeEvent
-    public static void onEntityDie(LivingDeathEvent event) {
+    public static void onLivingDie(LivingDeathEvent event) {
         if (event.getEntity() instanceof Player player) {
             MedicalConditionTracker tracker = GTCapabilityHelper.getMedicalConditionTracker(player);
             if (tracker == null) {
diff --git a/src/main/java/com/gregtechceu/gtceu/common/CommonProxy.java b/src/main/java/com/gregtechceu/gtceu/common/CommonProxy.java
index ccd0d830521..eb916f73a8d 100644
--- a/src/main/java/com/gregtechceu/gtceu/common/CommonProxy.java
+++ b/src/main/java/com/gregtechceu/gtceu/common/CommonProxy.java
@@ -16,9 +16,9 @@
 import com.gregtechceu.gtceu.api.data.worldgen.WorldGenLayers;
 import com.gregtechceu.gtceu.api.data.worldgen.generator.IndicatorGenerators;
 import com.gregtechceu.gtceu.api.data.worldgen.generator.VeinGenerators;
-import com.gregtechceu.gtceu.api.gui.factory.CoverUIFactory;
-import com.gregtechceu.gtceu.api.gui.factory.GTUIEditorFactory;
-import com.gregtechceu.gtceu.api.gui.factory.MachineUIFactory;
+import com.gregtechceu.gtceu.api.mui.factory.CoverUIFactory;
+import com.gregtechceu.gtceu.api.mui.factory.MachineUIFactory;
+import com.gregtechceu.gtceu.api.mui.factory.ModularItemUIFactory;
 import com.gregtechceu.gtceu.api.recipe.chance.logic.ChanceLogic;
 import com.gregtechceu.gtceu.api.recipe.ingredient.*;
 import com.gregtechceu.gtceu.api.recipe.lookup.ingredient.*;
@@ -32,6 +32,7 @@
 import com.gregtechceu.gtceu.common.item.tool.rotation.CustomBlockRotations;
 import com.gregtechceu.gtceu.common.machine.multiblock.electric.FusionReactorMachine;
 import com.gregtechceu.gtceu.common.machine.owner.MachineOwner;
+import com.gregtechceu.gtceu.common.mui.GTGuiTextures;
 import com.gregtechceu.gtceu.common.network.GTNetwork;
 import com.gregtechceu.gtceu.common.registry.GTRegistration;
 import com.gregtechceu.gtceu.common.unification.material.MaterialRegistryManager;
@@ -55,8 +56,6 @@
 import com.gregtechceu.gtceu.utils.input.KeyBind;
 import com.gregtechceu.gtceu.utils.input.SyncedKeyMappings;
 
-import com.lowdragmc.lowdraglib.gui.factory.UIFactory;
-
 import net.minecraft.core.registries.BuiltInRegistries;
 import net.minecraft.server.packs.PackType;
 import net.minecraft.server.packs.repository.Pack;
@@ -79,6 +78,7 @@
 import net.minecraftforge.fml.javafmlmod.FMLModContainer;
 import net.minecraftforge.registries.RegisterEvent;
 
+import brachy.modularui.factory.GuiManager;
 import com.google.common.collect.Multimaps;
 import com.tterrag.registrate.providers.ProviderType;
 import com.tterrag.registrate.providers.RegistrateLangProvider;
@@ -98,6 +98,13 @@ public CommonProxy() {
         GTCEuAPI.materialManager = MaterialRegistryManager.getInstance();
         ConfigHolder.init();
         GTCEuAPI.initializeHighTier();
+
+        // MUI stuff
+        GTGuiTextures.init();
+        GuiManager.registerFactory(MachineUIFactory.INSTANCE);
+        GuiManager.registerFactory(CoverUIFactory.INSTANCE);
+        GuiManager.registerFactory(ModularItemUIFactory.INSTANCE);
+
         if (GTCEu.isDev()) {
             ConfigHolder.INSTANCE.recipes.generateLowQualityGems = true;
             ConfigHolder.INSTANCE.compat.energy.enableFEConverters = true;
@@ -114,9 +121,6 @@ public CommonProxy() {
     public static void init() {
         GTCEu.LOGGER.info("GTCEu common proxy init!");
         GTNetwork.init();
-        UIFactory.register(MachineUIFactory.INSTANCE);
-        UIFactory.register(CoverUIFactory.INSTANCE);
-        UIFactory.register(GTUIEditorFactory.INSTANCE);
 
         // Initialize the model generator before any content is loaded so machine models can use the generated data
         GregTechDatagen.initPre();
@@ -142,6 +146,10 @@ public static void init() {
 
         GTCovers.init();
         GTCreativeModeTabs.init();
+
+        IEventBus modBus = FMLJavaModLoadingContext.get().getModEventBus();
+        GTMenuTypes.init(modBus);
+
         GTBlocks.init();
         GTFluids.init();
         GTEntityTypes.init();
@@ -152,6 +160,7 @@ public static void init() {
         GTMachines.init();
 
         GTFoods.init();
+        GTItemModules.init();
         GTItems.init();
         GTDimensionMarkers.init();
         ChanceLogic.init();
@@ -202,6 +211,9 @@ public static void init() {
         FusionReactorMachine.registerFusionTier(GTValues.UV, " (MKIII)");
     }
 
+    @SubscribeEvent
+    public void preInit(FMLConstructModEvent event) {}
+
     private static void initMaterials() {
         // First, register other mods' Registries
         MaterialRegistryManager managerInternal = (MaterialRegistryManager) GTCEuAPI.materialManager;
diff --git a/src/main/java/com/gregtechceu/gtceu/common/block/EquipmentFoundryBlock.java b/src/main/java/com/gregtechceu/gtceu/common/block/EquipmentFoundryBlock.java
new file mode 100644
index 00000000000..51e6415e601
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/common/block/EquipmentFoundryBlock.java
@@ -0,0 +1,48 @@
+package com.gregtechceu.gtceu.common.block;
+
+import com.gregtechceu.gtceu.common.data.GTBlockEntities;
+
+import net.minecraft.MethodsReturnNonnullByDefault;
+import net.minecraft.core.BlockPos;
+import net.minecraft.world.InteractionHand;
+import net.minecraft.world.InteractionResult;
+import net.minecraft.world.entity.player.Player;
+import net.minecraft.world.level.Level;
+import net.minecraft.world.level.block.BaseEntityBlock;
+import net.minecraft.world.level.block.RenderShape;
+import net.minecraft.world.level.block.entity.BlockEntity;
+import net.minecraft.world.level.block.state.BlockState;
+import net.minecraft.world.phys.BlockHitResult;
+
+import brachy.modularui.factory.BlockEntityUIFactory;
+import org.jetbrains.annotations.Nullable;
+
+import javax.annotation.ParametersAreNonnullByDefault;
+
+@SuppressWarnings("deprecation")
+@ParametersAreNonnullByDefault
+@MethodsReturnNonnullByDefault
+public class EquipmentFoundryBlock extends BaseEntityBlock {
+
+    public EquipmentFoundryBlock(Properties properties) {
+        super(properties);
+    }
+
+    @Override
+    public RenderShape getRenderShape(BlockState state) {
+        return RenderShape.MODEL;
+    }
+
+    @Override
+    public @Nullable BlockEntity newBlockEntity(BlockPos pos, BlockState state) {
+        return GTBlockEntities.EQUIPMENT_FOUNDRY.get().create(pos, state);
+    }
+
+    @Override
+    public InteractionResult use(BlockState state, Level level, BlockPos pos,
+                                 Player player, InteractionHand hand, BlockHitResult hit) {
+        if (!level.isClientSide)
+            BlockEntityUIFactory.INSTANCE.open(player, pos);
+        return InteractionResult.sidedSuccess(level.isClientSide);
+    }
+}
diff --git a/src/main/java/com/gregtechceu/gtceu/common/blockentity/CableBlockEntity.java b/src/main/java/com/gregtechceu/gtceu/common/blockentity/CableBlockEntity.java
index be3caf82361..4aace455656 100644
--- a/src/main/java/com/gregtechceu/gtceu/common/blockentity/CableBlockEntity.java
+++ b/src/main/java/com/gregtechceu/gtceu/common/blockentity/CableBlockEntity.java
@@ -6,7 +6,6 @@
 import com.gregtechceu.gtceu.api.capability.GTCapabilityHelper;
 import com.gregtechceu.gtceu.api.capability.IEnergyContainer;
 import com.gregtechceu.gtceu.api.data.chemical.material.properties.WireProperties;
-import com.gregtechceu.gtceu.api.gui.GuiTextures;
 import com.gregtechceu.gtceu.api.item.tool.GTToolType;
 import com.gregtechceu.gtceu.api.machine.TickableSubscription;
 import com.gregtechceu.gtceu.api.machine.feature.IDataInfoProvider;
@@ -15,13 +14,12 @@
 import com.gregtechceu.gtceu.common.block.CableBlock;
 import com.gregtechceu.gtceu.common.data.GTMaterialBlocks;
 import com.gregtechceu.gtceu.common.item.behavior.PortableScannerBehavior;
+import com.gregtechceu.gtceu.common.mui.GTGuiTextures;
 import com.gregtechceu.gtceu.common.pipelike.cable.*;
 import com.gregtechceu.gtceu.utils.FormattingUtil;
 import com.gregtechceu.gtceu.utils.GTMath;
 import com.gregtechceu.gtceu.utils.GTUtil;
 
-import com.lowdragmc.lowdraglib.gui.texture.ResourceTexture;
-
 import net.minecraft.ChatFormatting;
 import net.minecraft.MethodsReturnNonnullByDefault;
 import net.minecraft.core.BlockPos;
@@ -35,6 +33,7 @@
 import net.minecraftforge.common.capabilities.Capability;
 import net.minecraftforge.common.util.LazyOptional;
 
+import brachy.modularui.drawable.UITexture;
 import lombok.Getter;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
@@ -320,8 +319,8 @@ public static void onBlockEntityRegister(BlockEntityType<CableBlockEntity> cable
     //////////////////////////////////////
 
     @Override
-    public ResourceTexture getPipeTexture(boolean isBlock) {
-        return isBlock ? GuiTextures.TOOL_WIRE_CONNECT : GuiTextures.TOOL_WIRE_BLOCK;
+    public UITexture getPipeTexture(boolean isBlock) {
+        return isBlock ? GTGuiTextures.TOOL_WIRE_CONNECT : GTGuiTextures.TOOL_WIRE_BLOCK;
     }
 
     @Override
diff --git a/src/main/java/com/gregtechceu/gtceu/common/blockentity/EquipmentFoundryBlockEntity.java b/src/main/java/com/gregtechceu/gtceu/common/blockentity/EquipmentFoundryBlockEntity.java
new file mode 100644
index 00000000000..6f9b88c25e0
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/common/blockentity/EquipmentFoundryBlockEntity.java
@@ -0,0 +1,299 @@
+package com.gregtechceu.gtceu.common.blockentity;
+
+import com.gregtechceu.gtceu.api.capability.GTCapabilityHelper;
+import com.gregtechceu.gtceu.api.item.module.AppliedItemModule;
+import com.gregtechceu.gtceu.api.item.module.IModularItem;
+import com.gregtechceu.gtceu.api.item.module.ItemModuleSlot;
+import com.gregtechceu.gtceu.api.mui.GTGuiScreen;
+import com.gregtechceu.gtceu.api.sync_system.ISyncManaged;
+import com.gregtechceu.gtceu.api.sync_system.SyncDataHolder;
+import com.gregtechceu.gtceu.api.sync_system.annotations.SaveField;
+import com.gregtechceu.gtceu.api.transfer.item.CustomItemStackHandler;
+import com.gregtechceu.gtceu.common.data.GTBlocks;
+import com.gregtechceu.gtceu.common.data.GTRecipeTypes;
+import com.gregtechceu.gtceu.common.mui.GTGuiTextures;
+import com.gregtechceu.gtceu.common.mui.GTGuiTheme;
+import com.gregtechceu.gtceu.common.mui.GTMuiWidgets;
+import com.gregtechceu.gtceu.common.recipe.type.EquipmentFoundryRecipe;
+
+import net.minecraft.core.BlockPos;
+import net.minecraft.core.Direction;
+import net.minecraft.core.NonNullList;
+import net.minecraft.world.entity.player.Player;
+import net.minecraft.world.item.ItemStack;
+import net.minecraft.world.level.block.Block;
+import net.minecraft.world.level.block.entity.BlockEntity;
+import net.minecraft.world.level.block.entity.BlockEntityType;
+import net.minecraft.world.level.block.state.BlockState;
+import net.minecraftforge.common.capabilities.Capability;
+import net.minecraftforge.common.capabilities.ForgeCapabilities;
+import net.minecraftforge.common.capabilities.ICapabilityProvider;
+import net.minecraftforge.common.util.LazyOptional;
+import net.minecraftforge.items.wrapper.CombinedInvWrapper;
+import net.minecraftforge.items.wrapper.RecipeWrapper;
+
+import brachy.modularui.api.IUIHolder;
+import brachy.modularui.factory.PosGuiData;
+import brachy.modularui.screen.ModularPanel;
+import brachy.modularui.screen.ModularScreen;
+import brachy.modularui.screen.UISettings;
+import brachy.modularui.value.sync.PanelSyncManager;
+import brachy.modularui.widget.Widget;
+import brachy.modularui.widgets.layout.Grid;
+import brachy.modularui.widgets.slot.ItemSlot;
+import brachy.modularui.widgets.slot.ModularSlot;
+import lombok.Getter;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Optional;
+
+public class EquipmentFoundryBlockEntity extends BlockEntity
+                                         implements ICapabilityProvider, IUIHolder<PosGuiData>, ISyncManaged {
+
+    public static final int MAX_MODIFIER_SLOTS = 10;
+
+    @Getter
+    private final SyncDataHolder syncDataHolder = new SyncDataHolder(this);
+
+    @SaveField
+    private final CustomItemStackHandler equipmentSlot;
+    @SaveField
+    private final CustomItemStackHandler moduleSlots;
+
+    public EquipmentFoundryBlockEntity(BlockEntityType<?> type, BlockPos pos, BlockState blockState) {
+        super(type, pos, blockState);
+        this.equipmentSlot = new CustomItemStackHandler(1) {
+
+            @Override
+            public int getSlotLimit(int slot) {
+                return 1;
+            }
+
+            @Override
+            public @NotNull ItemStack insertItem(int slot, @NotNull ItemStack stack, boolean simulate) {
+                ItemStack itemStack = super.insertItem(slot, stack, simulate);
+                if (!simulate) onEquipmentSlotChanged(null, List.of());
+                return itemStack;
+            }
+
+            @Override
+            public @NotNull ItemStack extractItem(int slot, int amount, boolean simulate) {
+                ItemStack itemStack = super.extractItem(slot, amount, simulate);
+                if (!simulate) onEquipmentSlotChanged(null, List.of());
+                return itemStack;
+            }
+        };
+
+        this.equipmentSlot.setFilter(
+                stack -> GTCapabilityHelper.getModularItem(stack) != null);
+
+        this.moduleSlots = new CustomItemStackHandler(MAX_MODIFIER_SLOTS) {
+
+            @Override
+            public int getSlotLimit(int slot) {
+                return 1;
+            }
+
+            @Override
+            public boolean isItemValid(int slot, @NotNull ItemStack stack) {
+                return super.isItemValid(slot, stack) && (!isModifierSlotBlocked(slot) || stack.isEmpty()) &&
+                        isModuleValid(slot, stack);
+            }
+
+            @Override
+            public void onContentsChanged(int slot) {
+                super.onContentsChanged(slot);
+                onModifierSlotChanged(slot);
+            }
+        };
+    }
+
+    public boolean isModuleValid(int slot, @NotNull ItemStack stack) {
+        if (this.getLevel() == null) {
+            return false;
+        }
+        NonNullList<ItemStack> stacks = NonNullList.create();
+        stacks.add(this.equipmentSlot.getStackInSlot(0));
+        stacks.add(stack);
+        RecipeWrapper newWrapper = new RecipeWrapper(new CustomItemStackHandler(stacks));
+
+        return getLevel().getRecipeManager()
+                .getRecipeFor(GTRecipeTypes.EQUIPMENT_FOUNDRY_RECIPES.get(), newWrapper, this.getLevel())
+                .map(recipe -> recipe.matches(newWrapper, slot)).orElse(false);
+    }
+
+    @Override
+    public ModularPanel<?> buildUI(PosGuiData posGuiData, PanelSyncManager panelSyncManager, UISettings uiSettings) {
+        List<ItemSlot> moduleSlots = new ArrayList<>();
+        for (int i = 0; i < MAX_MODIFIER_SLOTS; i++) {
+            moduleSlots.add(new ItemSlot()
+                    .background()
+                    .slot(new ModularSlot(this.moduleSlots, i)
+                            .singletonSlotGroup()));
+        }
+        return new ModularPanel<>("equipment_foundry")
+                .size(168, 75)
+                .bindPlayerInventory(-80)
+                .child(GTMuiWidgets.createTitleBar(GTBlocks.EQUIPMENT_FOUNDRY.asStack(), 176,
+                        GTGuiTextures.BACKGROUND_STEEL))
+                .child(new ItemSlot()
+                        .left(10)
+                        .top(28)
+                        .background()
+                        .slot(equipmentSlot, 0)
+                        .slot(new ModularSlot(equipmentSlot, 0)
+                                .singletonSlotGroup()
+                                .changeListener((stack, onlyAmount, client, init) -> {
+                                    onEquipmentSlotChanged(posGuiData.getPlayer(), moduleSlots);
+
+                                })))
+                .child(new Grid()
+                        .background()
+                        .left(34)
+                        .top(-1)
+                        .minColWidth(26)
+                        .minRowHeight(39)
+                        .mapTo(5, moduleSlots));
+    }
+
+    /*
+     * @Override
+     * public ModularUI createUI(Player entityPlayer) {
+     * ModularUI modularUI = new ModularUI(176, 166, this, entityPlayer);
+     * modularUI.background(GuiTextures.BACKGROUND.copy().setColor(0xff69645f));
+     * 
+     * IGuiTexture slotTexture = GuiTextures.SLOT.copy().setColor(0xff69645f);
+     * 
+     * TextTexture titleText = new TextTexture(getBlockState().getBlock().getDescriptionId())
+     * .setColor(0xffffff)
+     * .setDropShadow(false)
+     * .setType(TextTexture.TextType.ROLL)
+     * .setWidth(105);
+     * titleText.setRollSpeed(0.7f);
+     * modularUI.widget(new WidgetGroup(9, -16, 160, 16)
+     * .addWidget(new ImageWidget(
+     * 16, 2, 105, 16, titleText))
+     * .setBackground(GuiTextures.TITLE_BAR_BACKGROUND.copy().setColor(0xff69645f)));
+     * modularUI.widget(new ImageWidget(4, 4, 168, 75, GuiTextures.EQUIPMENT_FOUNDRY_BACKGROUND));
+     * List<SlotWidget> slotWidgets = new ArrayList<>();
+     * modularUI.widget(new SlotWidget(equipmentSlot, 0, 14, 32)
+     * .setChangeListener(() -> this.onEquipmentSlotChanged(entityPlayer, slotWidgets))
+     * .setBackgroundTexture(null));
+     * 
+     * int x = 42;
+     * int y = 13;
+     * for (int i = 0; i < MAX_MODIFIER_SLOTS; i++) {
+     * final int finalI = i;
+     * SlotWidget slotWidget = new SlotWidget(moduleSlots, i, x, y)
+     * // .setIsBlocked(() -> isModifierSlotBlocked(finalI))
+     * .setBackgroundTexture(null);
+     * modularUI.widget(slotWidget);
+     * slotWidgets.add(slotWidget);
+     * x += 26;
+     * if (i == 4) {
+     * x = 42;
+     * y = 52;
+     * }
+     * }
+     * // modularUI.widget(UITemplate.bindPlayerInventory(entityPlayer.getInventory(), slotTexture, 7, 84, true));
+     * return modularUI;
+     * }
+     */
+
+    public boolean isModifierSlotBlocked(int slot) {
+        ItemStack equipment = equipmentSlot.getStackInSlot(0);
+        IModularItem modularItem = GTCapabilityHelper.getModularItem(equipment);
+        if (modularItem == null) return true;
+        AppliedItemModule module = modularItem.getModuleInSlot(slot);
+        if (module != null) return !(module.canRemove() && module.getModuleItem() != null);
+        return modularItem.getSlots().size() <= slot;
+    }
+
+    public void onEquipmentSlotChanged(@Nullable Player player, List<ItemSlot> slotWidgets) {
+        ItemStack stack = equipmentSlot.getStackInSlot(0);
+        if (stack.isEmpty()) {
+            for (int i = 0; i < moduleSlots.getSlots(); i++) {
+                ItemStack out = moduleSlots.extractItem(i, Integer.MAX_VALUE, true);
+                if (out.isEmpty()) {
+                    continue;
+                }
+                out = moduleSlots.extractItem(i, Integer.MAX_VALUE, false);
+                out.shrink(1);
+                if (player != null && !player.getInventory().add(out)) {
+                    player.drop(out, true);
+                } else if (!out.isEmpty() && getLevel() != null) {
+                    Block.popResource(getLevel(), getBlockPos(), out);
+                }
+            }
+            slotWidgets.forEach(Widget::background);
+        } else {
+            IModularItem modularItem = GTCapabilityHelper.getModularItem(stack);
+            if (modularItem == null) return;
+            for (AppliedItemModule module : modularItem.getAppliedModules()) {
+                if (module.getSlot() < MAX_MODIFIER_SLOTS && module.getModuleItem() != null) {
+                    moduleSlots.setStackInSlot(module.getSlot(), module.getModuleItem());
+                }
+            }
+            List<ItemModuleSlot> slots = modularItem.getSlots();
+            for (int i = 0; i < slots.size() && i < slotWidgets.size(); i++) {
+                ItemSlot slotWidget = slotWidgets.get(i);
+                if (slots.get(i) != null && slotWidget != null) {
+                    slotWidget.background(slots.get(i).getSlotTexture());
+                }
+            }
+        }
+    }
+
+    public void onModifierSlotChanged(int slot) {
+        if (getLevel() == null || getLevel().isClientSide) {
+            return;
+        }
+
+        ItemStack stack = equipmentSlot.getStackInSlot(0);
+        if (stack.isEmpty()) {
+            return;
+        }
+        IModularItem modularItem = GTCapabilityHelper.getModularItem(stack);
+        AppliedItemModule prevModule = modularItem == null ? null : modularItem.getModuleInSlot(slot);
+        if (prevModule != null) prevModule.detach();
+        ItemStack newModule = moduleSlots.getStackInSlot(slot);
+        if (newModule.isEmpty()) return;
+        RecipeWrapper recipeWrapper = new RecipeWrapper(new CombinedInvWrapper(
+                this.equipmentSlot,
+                new CustomItemStackHandler(newModule)));
+        Optional<EquipmentFoundryRecipe> recipe = getLevel().getRecipeManager().getRecipeFor(
+                GTRecipeTypes.EQUIPMENT_FOUNDRY_RECIPES.get(),
+                recipeWrapper,
+                this.getLevel());
+        if (recipe.isPresent()) {
+            ItemStack newStack = recipe.get().assemble(recipeWrapper, slot);
+            if (newStack.isEmpty()) return;
+            equipmentSlot.setStackInSlot(0, newStack);
+        }
+    }
+
+    @Override
+    public @NotNull <T> LazyOptional<T> getCapability(@NotNull Capability<T> cap, @Nullable Direction side) {
+        if (cap == ForgeCapabilities.ITEM_HANDLER && side != null) {
+            if (side.getAxis().isVertical())
+                return ForgeCapabilities.ITEM_HANDLER.orEmpty(cap, LazyOptional.of(() -> equipmentSlot));
+            if (side.getAxis().isHorizontal())
+                return ForgeCapabilities.ITEM_HANDLER.orEmpty(cap, LazyOptional.of(() -> moduleSlots));
+        }
+        return super.getCapability(cap, side);
+    }
+
+    @Override
+    public ModularScreen createScreen(PosGuiData posGuiData, ModularPanel<?> modularPanel) {
+        return new GTGuiScreen(modularPanel, GTGuiTheme.EQUIPMENT_FOUNDRY);
+    }
+
+    @Override
+    public void scheduleRenderUpdate() {}
+
+    @Override
+    public void markAsChanged() {}
+}
diff --git a/src/main/java/com/gregtechceu/gtceu/common/commands/GTCommands.java b/src/main/java/com/gregtechceu/gtceu/common/commands/GTCommands.java
index 49c7a7f71bb..9fecbaa91fd 100644
--- a/src/main/java/com/gregtechceu/gtceu/common/commands/GTCommands.java
+++ b/src/main/java/com/gregtechceu/gtceu/common/commands/GTCommands.java
@@ -8,7 +8,6 @@
 import com.gregtechceu.gtceu.api.data.worldgen.ores.GeneratedVeinMetadata;
 import com.gregtechceu.gtceu.api.data.worldgen.ores.OreGenerator;
 import com.gregtechceu.gtceu.api.data.worldgen.ores.OrePlacer;
-import com.gregtechceu.gtceu.api.gui.factory.GTUIEditorFactory;
 import com.gregtechceu.gtceu.api.registry.GTRegistries;
 import com.gregtechceu.gtceu.api.registry.GTRegistry;
 import com.gregtechceu.gtceu.common.commands.arguments.GTRegistryArgument;
@@ -72,12 +71,6 @@ public class GTCommands {
     public static void register(CommandDispatcher<CommandSourceStack> dispatcher, CommandBuildContext buildContext) {
         dispatcher.register(
                 literal("gtceu")
-                        .then(literal("ui_editor")
-                                .requires(ctx -> ctx.hasPermission(LEVEL_ADMINS))
-                                .executes(context -> {
-                                    GTUIEditorFactory.INSTANCE.openUI(GTUIEditorFactory.INSTANCE, context.getSource().getPlayerOrException());
-                                    return 1;
-                                }))
                         .then(literal("dump_data")
                                 .requires(ctx -> ctx.hasPermission(LEVEL_OWNERS))
                                 .then(literal("bedrock_fluid_veins")
diff --git a/src/main/java/com/gregtechceu/gtceu/common/cover/ComputerMonitorCover.java b/src/main/java/com/gregtechceu/gtceu/common/cover/ComputerMonitorCover.java
index 38db0276e52..874ca702c72 100644
--- a/src/main/java/com/gregtechceu/gtceu/common/cover/ComputerMonitorCover.java
+++ b/src/main/java/com/gregtechceu/gtceu/common/cover/ComputerMonitorCover.java
@@ -4,8 +4,6 @@
 import com.gregtechceu.gtceu.api.capability.ICoverable;
 import com.gregtechceu.gtceu.api.cover.CoverBehavior;
 import com.gregtechceu.gtceu.api.cover.CoverDefinition;
-import com.gregtechceu.gtceu.api.cover.IUICover;
-import com.gregtechceu.gtceu.api.gui.widget.IntInputWidget;
 import com.gregtechceu.gtceu.api.machine.TickableSubscription;
 import com.gregtechceu.gtceu.api.machine.feature.IDataStickInteractable;
 import com.gregtechceu.gtceu.api.placeholder.IPlaceholderInfoProviderCover;
@@ -17,14 +15,10 @@
 import com.gregtechceu.gtceu.api.transfer.item.CustomItemStackHandler;
 import com.gregtechceu.gtceu.client.renderer.cover.CoverTextRenderer;
 import com.gregtechceu.gtceu.client.renderer.cover.IDynamicCoverRenderer;
-import com.gregtechceu.gtceu.data.lang.LangHandler;
 import com.gregtechceu.gtceu.integration.create.GTCreateIntegration;
 import com.gregtechceu.gtceu.utils.GTStringUtils;
 import com.gregtechceu.gtceu.utils.GTUtil;
 
-import com.lowdragmc.lowdraglib.gui.texture.ResourceBorderTexture;
-import com.lowdragmc.lowdraglib.gui.widget.*;
-
 import net.minecraft.MethodsReturnNonnullByDefault;
 import net.minecraft.core.Direction;
 import net.minecraft.nbt.CompoundTag;
@@ -49,7 +43,7 @@
 @MethodsReturnNonnullByDefault
 @ParametersAreNonnullByDefault
 public class ComputerMonitorCover extends CoverBehavior
-                                  implements IUICover, IDataStickInteractable, IPlaceholderInfoProviderCover {
+                                  implements IDataStickInteractable, IPlaceholderInfoProviderCover {
 
     private TickableSubscription subscription;
     private final CoverTextRenderer renderer;
@@ -124,87 +118,6 @@ public Supplier<IDynamicCoverRenderer> getDynamicRenderer() {
         return () -> renderer;
     }
 
-    @Override
-    public Widget createUIWidget() {
-        int textFieldWidth = 160, horizontalPadding = 10, verticalPadding = 2;
-        final WidgetGroup group = new WidgetGroup(0, 0, 2 * textFieldWidth + 3 * horizontalPadding, 150);
-        final WidgetGroup mainPage = new WidgetGroup(0, 0, 2 * textFieldWidth + 3 * horizontalPadding, 150);
-        final WidgetGroup formatStringArgsPage = new WidgetGroup(0, 0, 2 * textFieldWidth + 3 * horizontalPadding, 150);
-        for (int i = 0; i < 8; i++) {
-            TextFieldWidget formatStringInput = new TextFieldWidget();
-            formatStringInput.setSize(textFieldWidth, 15);
-            formatStringInput.setSelfPosition(horizontalPadding + textFieldWidth / 2,
-                    10 + verticalPadding + i * (15 + verticalPadding));
-            formatStringInput.setHoverTooltips(GTStringUtils.toImmutable(
-                    LangHandler.getMultiLang("gtceu.gui.computer_monitor_cover.main_textbox_tooltip", i + 1)));
-            int finalI = i;
-            if (i >= formatStringLines.size()) formatStringLines.add("");
-            formatStringInput.setCurrentString(formatStringLines.get(i));
-            formatStringInput.setTextResponder((s) -> formatStringLines.set(finalI, s));
-            mainPage.addWidget(formatStringInput);
-            SlotWidget slot = new com.gregtechceu.gtceu.api.gui.widget.SlotWidget(
-                    itemStackHandler,
-                    i,
-                    horizontalPadding + 50,
-                    20 * i);
-            slot.setBackgroundTexture(SlotWidget.ITEM_SLOT_TEXTURE);
-            slot.setHoverTooltips(GTStringUtils
-                    .toImmutable(LangHandler.getMultiLang("gtceu.gui.computer_monitor_cover.slot_tooltip", i + 1)));
-            mainPage.addWidget(slot);
-        }
-        for (int i = 0; i < 8; i++) {
-            TextFieldWidget formatStringArgsInput = new TextFieldWidget();
-            formatStringArgsInput.setSize(textFieldWidth, 15);
-            formatStringArgsInput.setSelfPosition(textFieldWidth / 2 + horizontalPadding,
-                    10 + verticalPadding + i * (15 + verticalPadding));
-            formatStringArgsInput.setHoverTooltips(GTStringUtils.toImmutable(
-                    LangHandler.getMultiLang("gtceu.gui.computer_monitor_cover.second_page_textbox_tooltip",
-                            GTStringUtils.getIntOrderingSuffix(i + 1))));
-
-            int finalI = i;
-            if (i >= formatStringArgs.size()) formatStringArgs.add("");
-            formatStringArgsInput.setCurrentString(formatStringArgs.get(i));
-            formatStringArgsInput.setTextResponder((s) -> formatStringArgs.set(finalI, s));
-            formatStringArgsPage.addWidget(formatStringArgsInput);
-        }
-        ButtonWidget switchToFormatStringArgsPageButton = new ButtonWidget(
-                horizontalPadding + 50,
-                10 * (15 + verticalPadding) + verticalPadding,
-                20, 20,
-                new ResourceBorderTexture(),
-                clickData -> {
-                    group.clearAllWidgets();
-                    group.addWidget(formatStringArgsPage);
-                });
-        ButtonWidget switchBack = new ButtonWidget(
-                horizontalPadding + 50,
-                10 * (15 + verticalPadding) + verticalPadding,
-                20, 20,
-                new ResourceBorderTexture(),
-                clickData -> {
-                    group.clearAllWidgets();
-                    group.addWidget(mainPage);
-                });
-        mainPage.addWidget(PlaceholderHandler.getPlaceholderHandlerUI(""));
-        // TextFieldWidget searchBox = new TextFieldWidget(280, 0, 80, 15, null, onSearch);
-        // searchBox.setHoverTooltips("Search");
-        // mainPage.addWidget(searchBox);
-        IntInputWidget updateIntervalInput = new IntInputWidget(0, 0, 60, 20, this::getUpdateInterval,
-                this::setUpdateInterval);
-        updateIntervalInput.setMin(1);
-        updateIntervalInput.setMax(60 * 20);
-        updateIntervalInput
-                .setHoverTooltips(Component.translatable("gtceu.gui.computer_monitor_cover.update_interval"));
-        mainPage.addWidget(updateIntervalInput);
-        switchToFormatStringArgsPageButton
-                .setHoverTooltips(Component.translatable("gtceu.gui.computer_monitor_cover.edit_blank_placeholders"));
-        switchBack.setHoverTooltips(Component.translatable("gtceu.gui.computer_monitor_cover.edit_displayed_text"));
-        mainPage.addWidget(switchToFormatStringArgsPageButton);
-        formatStringArgsPage.addWidget(switchBack);
-        group.addWidget(mainPage);
-        return group;
-    }
-
     @Override
     public void onLoad() {
         super.onLoad();
diff --git a/src/main/java/com/gregtechceu/gtceu/common/cover/ConveyorCover.java b/src/main/java/com/gregtechceu/gtceu/common/cover/ConveyorCover.java
index bbe95ec05e9..4ad59a0bd57 100644
--- a/src/main/java/com/gregtechceu/gtceu/common/cover/ConveyorCover.java
+++ b/src/main/java/com/gregtechceu/gtceu/common/cover/ConveyorCover.java
@@ -4,16 +4,10 @@
 import com.gregtechceu.gtceu.api.capability.IControllable;
 import com.gregtechceu.gtceu.api.capability.ICoverable;
 import com.gregtechceu.gtceu.api.capability.recipe.IO;
-import com.gregtechceu.gtceu.api.cover.CoverBehavior;
-import com.gregtechceu.gtceu.api.cover.CoverDefinition;
-import com.gregtechceu.gtceu.api.cover.IIOCover;
-import com.gregtechceu.gtceu.api.cover.IUICover;
+import com.gregtechceu.gtceu.api.cover.*;
 import com.gregtechceu.gtceu.api.cover.filter.FilterHandler;
 import com.gregtechceu.gtceu.api.cover.filter.FilterHandlers;
 import com.gregtechceu.gtceu.api.cover.filter.ItemFilter;
-import com.gregtechceu.gtceu.api.gui.GuiTextures;
-import com.gregtechceu.gtceu.api.gui.widget.EnumSelectorWidget;
-import com.gregtechceu.gtceu.api.gui.widget.IntInputWidget;
 import com.gregtechceu.gtceu.api.machine.ConditionalSubscriptionHandler;
 import com.gregtechceu.gtceu.api.sync_system.annotations.RerenderOnChanged;
 import com.gregtechceu.gtceu.api.sync_system.annotations.SaveField;
@@ -22,17 +16,12 @@
 import com.gregtechceu.gtceu.common.blockentity.ItemPipeBlockEntity;
 import com.gregtechceu.gtceu.common.cover.data.DistributionMode;
 import com.gregtechceu.gtceu.common.cover.data.ManualIOMode;
+import com.gregtechceu.gtceu.common.mui.GTGuiTextures;
+import com.gregtechceu.gtceu.common.mui.GTMuiWidgets;
 import com.gregtechceu.gtceu.utils.GTTransferUtils;
 import com.gregtechceu.gtceu.utils.GTUtil;
 import com.gregtechceu.gtceu.utils.ItemStackHashStrategy;
 
-import com.lowdragmc.lowdraglib.gui.texture.GuiTextureGroup;
-import com.lowdragmc.lowdraglib.gui.widget.LabelWidget;
-import com.lowdragmc.lowdraglib.gui.widget.SwitchWidget;
-import com.lowdragmc.lowdraglib.gui.widget.Widget;
-import com.lowdragmc.lowdraglib.gui.widget.WidgetGroup;
-import com.lowdragmc.lowdraglib.utils.LocalizationUtils;
-
 import net.minecraft.MethodsReturnNonnullByDefault;
 import net.minecraft.core.BlockPos;
 import net.minecraft.core.Direction;
@@ -45,13 +34,17 @@
 import net.minecraftforge.items.IItemHandlerModifiable;
 import net.minecraftforge.items.ItemHandlerHelper;
 
+import brachy.modularui.api.drawable.IKey;
+import brachy.modularui.factory.SidedPosGuiData;
+import brachy.modularui.screen.UISettings;
+import brachy.modularui.value.sync.*;
+import brachy.modularui.widgets.layout.Flow;
 import it.unimi.dsi.fastutil.ints.Int2IntFunction;
 import it.unimi.dsi.fastutil.ints.IntArrayList;
 import it.unimi.dsi.fastutil.ints.IntList;
 import it.unimi.dsi.fastutil.objects.Object2ObjectOpenCustomHashMap;
 import lombok.AllArgsConstructor;
 import lombok.Getter;
-import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 
 import java.util.List;
@@ -61,7 +54,7 @@
 
 @ParametersAreNonnullByDefault
 @MethodsReturnNonnullByDefault
-public class ConveyorCover extends CoverBehavior implements IIOCover, IUICover, IControllable {
+public class ConveyorCover extends CoverBehavior implements IIOCover, IMuiCover, IControllable {
 
     // 8 32 128 512 1024
     public static final Int2IntFunction CONVEYOR_SCALING = tier -> 2 * (int) Math.pow(4, Math.min(tier, GTValues.LuV));
@@ -89,7 +82,6 @@ public class ConveyorCover extends CoverBehavior implements IIOCover, IUICover,
     @Getter
     protected boolean isWorkingEnabled = true;
     protected int itemsLeftToTransferLastSecond;
-    private Widget ioModeSwitch;
 
     @SaveField
     @SyncToClient
@@ -111,7 +103,7 @@ public ConveyorCover(CoverDefinition definition, ICoverable coverHolder, Directi
         filterHandler = FilterHandlers.item(this)
                 .onFilterLoaded(f -> configureFilter())
                 .onFilterUpdated(f -> configureFilter())
-                .onFilterRemoved(f -> configureFilter());
+                .onFilterRemoved(this::configureFilter);
     }
 
     public ConveyorCover(CoverDefinition definition, ICoverable coverHolder, Direction attachedSide, int tier) {
@@ -358,8 +350,7 @@ protected int moveInventoryItems(IItemHandler sourceInventory, IItemHandler targ
         return maxTransferAmount - itemsLeftToTransfer;
     }
 
-    @NotNull
-    protected Map<ItemStack, TypeItemInfo> countInventoryItemsByType(@NotNull IItemHandler inventory) {
+    protected Map<ItemStack, TypeItemInfo> countInventoryItemsByType(IItemHandler inventory) {
         ItemFilter filter = filterHandler.getFilter();
         Map<ItemStack, TypeItemInfo> result = new Object2ObjectOpenCustomHashMap<>(
                 ItemStackHashStrategy.comparingAllButCount());
@@ -379,8 +370,7 @@ protected Map<ItemStack, TypeItemInfo> countInventoryItemsByType(@NotNull IItemH
         return result;
     }
 
-    @NotNull
-    protected Map<ItemStack, GroupItemInfo> countInventoryItemsByMatchSlot(@NotNull IItemHandler inventory) {
+    protected Map<ItemStack, GroupItemInfo> countInventoryItemsByMatchSlot(IItemHandler inventory) {
         ItemFilter filter = filterHandler.getFilter();
         Map<ItemStack, GroupItemInfo> result = new Object2ObjectOpenCustomHashMap<>(
                 ItemStackHashStrategy.comparingAllButCount());
@@ -423,54 +413,69 @@ public boolean shouldRespectDistributionMode() {
     //////////////////////////////////////
     // *********** GUI ***********//
     //////////////////////////////////////
+
     @Override
-    public Widget createUIWidget() {
-        final var group = new WidgetGroup(0, 0, 176, 137);
-        group.addWidget(new LabelWidget(10, 5, Component.translatable(getUITitle(), GTValues.VN[tier]).getString()));
+    public void createCoverUIRows(Flow column, SidedPosGuiData data, PanelSyncManager syncManager,
+                                  UISettings settings) {
+        EnumSyncValue<ManualIOMode> manualMode = new EnumSyncValue<>(ManualIOMode.class,
+                this::getManualIOMode, this::setManualIOMode);
 
-        group.addWidget(new IntInputWidget(10, 20, 156, 20, () -> this.transferRate, this::setTransferRate)
-                .setMin(1).setMax(maxItemTransferRate));
+        EnumSyncValue<DistributionMode> distMode = new EnumSyncValue<>(DistributionMode.class,
+                this::getDistributionMode, this::setDistributionMode);
 
-        final EnumSelectorWidget<DistributionMode> distributionSelector = new EnumSelectorWidget<>(146, 67, 20, 20,
-                DistributionMode.values(), distributionMode, this::setDistributionMode);
+        IntSyncValue transferRate = new IntSyncValue(this::getTransferRate, this::setTransferRate);
+        EnumSyncValue<IO> ioSync = new EnumSyncValue<>(IO.class, this::getIo, this::setIo);
 
-        distributionSelector.setVisible(shouldRespectDistributionMode());
-        group.addWidget(distributionSelector);
+        syncManager.syncValue("io", ioSync);
+        syncManager.syncValue("manualMode", manualMode);
+        syncManager.syncValue("distribution", distMode);
+        syncManager.syncValue("throughput", transferRate);
 
-        ioModeSwitch = new SwitchWidget(10, 45, 20, 20,
-                (clickData, value) -> {
-                    setIo(value ? IO.IN : IO.OUT);
-                    distributionSelector.setVisible(shouldRespectDistributionMode());
-                    ioModeSwitch.setHoverTooltips(
-                            LocalizationUtils.format("cover.conveyor.mode", LocalizationUtils.format(io.tooltip)));
-                })
-                .setTexture(
-                        new GuiTextureGroup(GuiTextures.VANILLA_BUTTON, IO.OUT.icon),
-                        new GuiTextureGroup(GuiTextures.VANILLA_BUTTON, IO.IN.icon))
-                .setPressed(io == IO.IN)
-                .setHoverTooltips(
-                        LocalizationUtils.format("cover.conveyor.mode", LocalizationUtils.format(io.tooltip)));
-        group.addWidget(ioModeSwitch);
+        if (createThroughputRow()) {
+            column.child(GTMuiWidgets.createIntInputWithButtons(transferRate, () -> 1, () -> maxItemTransferRate));
+        }
 
-        group.addWidget(new EnumSelectorWidget<>(146, 107, 20, 20,
-                ManualIOMode.VALUES, manualIOMode, this::setManualIOMode)
-                .setHoverTooltips("cover.universal.manual_import_export.mode.description"));
+        if (createFilterRow()) {
+            column.child(GTMuiWidgets.createFilterRow(filterHandler, data, syncManager, settings)
+                    .child(0, GTMuiWidgets.createIOCycleButton(ioSync, false)));
+        }
 
-        group.addWidget(filterHandler.createFilterSlotUI(125, 108));
-        group.addWidget(filterHandler.createFilterConfigUI(10, 72, 156, 60));
+        if (createDistributionModeRow()) {
+            column.child(new GTMuiWidgets.EnumRowBuilder<>(DistributionMode.class)
+                    .value(distMode)
+                    .overlay(16, GTGuiTextures.DISTRIBUTION_MODE_OVERLAY)
+                    .lang(IKey.dynamic(() -> Component.translatable(distributionMode.localeName)))
+                    .build());
+        }
 
-        buildAdditionalUI(group);
+        if (createManualIOModeRow()) {
+            column.child(new GTMuiWidgets.EnumRowBuilder<>(ManualIOMode.class)
+                    .value(manualMode)
+                    .overlay(16, GTGuiTextures.MANUAL_IO_OVERLAY_IN)
+                    .lang(IKey.dynamic(() -> Component.translatable(manualIOMode.localeName)))
+                    .build());
 
-        return group;
+        }
     }
 
-    @NotNull
-    protected String getUITitle() {
-        return "cover.conveyor.title";
+    protected boolean createThroughputRow() {
+        return true;
     }
 
-    protected void buildAdditionalUI(WidgetGroup group) {
-        // Do nothing in the base implementation. This is intended to be overridden by subclasses.
+    protected boolean createFilterRow() {
+        return true;
+    }
+
+    protected boolean createConveyorIORow() {
+        return true;
+    }
+
+    protected boolean createDistributionModeRow() {
+        return true;
+    }
+
+    protected boolean createManualIOModeRow() {
+        return true;
     }
 
     protected void configureFilter() {
@@ -481,7 +486,7 @@ protected void configureFilter() {
     // *** CAPABILITY OVERRIDE ***//
     /////////////////////////////////////
 
-    private CoverableItemHandlerWrapper itemHandlerWrapper;
+    private @Nullable CoverableItemHandlerWrapper itemHandlerWrapper;
 
     @Nullable
     @Override
@@ -501,9 +506,8 @@ public CoverableItemHandlerWrapper(IItemHandlerModifiable delegate) {
             super(delegate);
         }
 
-        @NotNull
         @Override
-        public ItemStack insertItem(int slot, @NotNull ItemStack stack, boolean simulate) {
+        public ItemStack insertItem(int slot, ItemStack stack, boolean simulate) {
             if (io == IO.OUT) {
                 if (manualIOMode == ManualIOMode.DISABLED) {
                     return stack;
@@ -518,7 +522,6 @@ public ItemStack insertItem(int slot, @NotNull ItemStack stack, boolean simulate
             return super.insertItem(slot, stack, simulate);
         }
 
-        @NotNull
         @Override
         public ItemStack extractItem(int slot, int amount, boolean simulate) {
             if (io == IO.IN) {
diff --git a/src/main/java/com/gregtechceu/gtceu/common/cover/FluidFilterCover.java b/src/main/java/com/gregtechceu/gtceu/common/cover/FluidFilterCover.java
index 1c75ae521c8..6b0e87576ae 100644
--- a/src/main/java/com/gregtechceu/gtceu/common/cover/FluidFilterCover.java
+++ b/src/main/java/com/gregtechceu/gtceu/common/cover/FluidFilterCover.java
@@ -3,27 +3,34 @@
 import com.gregtechceu.gtceu.api.capability.ICoverable;
 import com.gregtechceu.gtceu.api.cover.CoverBehavior;
 import com.gregtechceu.gtceu.api.cover.CoverDefinition;
-import com.gregtechceu.gtceu.api.cover.IUICover;
+import com.gregtechceu.gtceu.api.cover.IMuiCover;
 import com.gregtechceu.gtceu.api.cover.filter.FluidFilter;
-import com.gregtechceu.gtceu.api.gui.widget.EnumSelectorWidget;
 import com.gregtechceu.gtceu.api.sync_system.annotations.SaveField;
 import com.gregtechceu.gtceu.api.sync_system.annotations.SyncToClient;
 import com.gregtechceu.gtceu.api.transfer.fluid.FluidHandlerDelegate;
 import com.gregtechceu.gtceu.api.transfer.fluid.IFluidHandlerModifiable;
 import com.gregtechceu.gtceu.common.cover.data.FilterMode;
 import com.gregtechceu.gtceu.common.cover.data.ManualIOMode;
-
-import com.lowdragmc.lowdraglib.gui.widget.LabelWidget;
-import com.lowdragmc.lowdraglib.gui.widget.Widget;
-import com.lowdragmc.lowdraglib.gui.widget.WidgetGroup;
+import com.gregtechceu.gtceu.common.mui.GTGuiTextures;
+import com.gregtechceu.gtceu.common.mui.GTMuiWidgets;
 
 import net.minecraft.MethodsReturnNonnullByDefault;
 import net.minecraft.core.Direction;
 import net.minecraft.nbt.CompoundTag;
+import net.minecraft.network.chat.Component;
 import net.minecraft.server.level.ServerPlayer;
 import net.minecraft.world.item.ItemStack;
 import net.minecraftforge.fluids.FluidStack;
 
+import brachy.modularui.api.drawable.IKey;
+import brachy.modularui.factory.SidedPosGuiData;
+import brachy.modularui.screen.UISettings;
+import brachy.modularui.value.sync.DynamicSyncHandler;
+import brachy.modularui.value.sync.EnumSyncValue;
+import brachy.modularui.value.sync.PanelSyncManager;
+import brachy.modularui.widgets.ButtonWidget;
+import brachy.modularui.widgets.DynamicSyncedWidget;
+import brachy.modularui.widgets.layout.Flow;
 import lombok.Getter;
 import lombok.Setter;
 import org.jetbrains.annotations.Nullable;
@@ -32,7 +39,7 @@
 
 @ParametersAreNonnullByDefault
 @MethodsReturnNonnullByDefault
-public class FluidFilterCover extends CoverBehavior implements IUICover {
+public class FluidFilterCover extends CoverBehavior implements IMuiCover {
 
     protected FluidFilter fluidFilter;
     @SaveField
@@ -80,14 +87,40 @@ public FluidFilter getFluidFilter() {
     }
 
     @Override
-    public Widget createUIWidget() {
-        final var group = new WidgetGroup(0, 0, 178, 85);
-        group.addWidget(new LabelWidget(60, 5, attachItem.getDescriptionId()));
-        group.addWidget(new EnumSelectorWidget<>(35, 25, 18, 18,
-                FilterMode.VALUES, filterMode, this::setFilterMode));
-        group.addWidget(new EnumSelectorWidget<>(35, 45, 18, 18, ManualIOMode.VALUES, allowFlow, this::setAllowFlow));
-        group.addWidget(getFluidFilter().openConfigurator(62, 25));
-        return group;
+    public void createCoverUIRows(Flow column, SidedPosGuiData data, PanelSyncManager syncManager,
+                                  UISettings settings) {
+        EnumSyncValue<FilterMode> filterMode = new EnumSyncValue<>(FilterMode.class,
+                this::getFilterMode, this::setFilterMode);
+
+        EnumSyncValue<ManualIOMode> ioMode = new EnumSyncValue<>(ManualIOMode.class,
+                this::getAllowFlow, this::setAllowFlow);
+
+        syncManager.syncValue("filterMode", filterMode);
+        syncManager.syncValue("ioMode", ioMode);
+
+        var panelHandler = syncManager.syncedPanel("filterPanel", true,
+                (sm, sh) -> fluidFilter.getPanel(data, sm, settings));
+
+        DynamicSyncHandler filterButton = new DynamicSyncHandler()
+                .widgetProvider((sm, buf) -> new ButtonWidget<>()
+                        .onMousePressed((x, y, b) -> {
+                            panelHandler.openPanel();
+                            return true;
+                        }));
+
+        column.child(coverUIRow().child(new DynamicSyncedWidget<>().syncHandler(filterButton)));
+
+        column.child(new GTMuiWidgets.EnumRowBuilder<>(FilterMode.class)
+                .value(filterMode)
+                .overlay(16, GTGuiTextures.FILTER_MODE_OVERLAY)
+                .lang(IKey.dynamic(() -> Component.translatable(getFilterMode().getTooltip())))
+                .build());
+
+        column.child(new GTMuiWidgets.EnumRowBuilder<>(ManualIOMode.class)
+                .value(ioMode)
+                .overlay(16, GTGuiTextures.MANUAL_IO_OVERLAY_IN)
+                .lang(IKey.dynamic(() -> Component.translatable(getAllowFlow().getTooltip())))
+                .build());
     }
 
     private class FilteredFluidHandlerWrapper extends FluidHandlerDelegate {
diff --git a/src/main/java/com/gregtechceu/gtceu/common/cover/FluidRegulatorCover.java b/src/main/java/com/gregtechceu/gtceu/common/cover/FluidRegulatorCover.java
index 98124ee6865..9c581e1ee58 100644
--- a/src/main/java/com/gregtechceu/gtceu/common/cover/FluidRegulatorCover.java
+++ b/src/main/java/com/gregtechceu/gtceu/common/cover/FluidRegulatorCover.java
@@ -4,27 +4,32 @@
 import com.gregtechceu.gtceu.api.cover.CoverDefinition;
 import com.gregtechceu.gtceu.api.cover.filter.FluidFilter;
 import com.gregtechceu.gtceu.api.cover.filter.SimpleFluidFilter;
-import com.gregtechceu.gtceu.api.gui.widget.EnumSelectorWidget;
-import com.gregtechceu.gtceu.api.gui.widget.IntInputWidget;
-import com.gregtechceu.gtceu.api.gui.widget.NumberInputWidget;
 import com.gregtechceu.gtceu.api.sync_system.annotations.SaveField;
 import com.gregtechceu.gtceu.api.sync_system.annotations.SyncToClient;
 import com.gregtechceu.gtceu.api.transfer.fluid.IFluidHandlerModifiable;
 import com.gregtechceu.gtceu.common.cover.data.BucketMode;
 import com.gregtechceu.gtceu.common.cover.data.TransferMode;
-
-import com.lowdragmc.lowdraglib.gui.widget.WidgetGroup;
+import com.gregtechceu.gtceu.common.mui.GTGuiTextures;
+import com.gregtechceu.gtceu.common.mui.GTMuiWidgets;
 
 import net.minecraft.MethodsReturnNonnullByDefault;
 import net.minecraft.core.Direction;
 import net.minecraft.nbt.CompoundTag;
+import net.minecraft.network.chat.Component;
 import net.minecraft.server.level.ServerPlayer;
 import net.minecraftforge.fluids.FluidStack;
 import net.minecraftforge.fluids.capability.IFluidHandler;
 import net.minecraftforge.fluids.capability.IFluidHandler.FluidAction;
 
+import brachy.modularui.api.drawable.IKey;
+import brachy.modularui.factory.SidedPosGuiData;
+import brachy.modularui.screen.UISettings;
+import brachy.modularui.value.sync.EnumSyncValue;
+import brachy.modularui.value.sync.IntSyncValue;
+import brachy.modularui.value.sync.PanelSyncManager;
+import brachy.modularui.widgets.layout.Flow;
 import lombok.Getter;
-import org.jetbrains.annotations.NotNull;
+import lombok.Setter;
 
 import javax.annotation.ParametersAreNonnullByDefault;
 
@@ -46,12 +51,10 @@ public class FluidRegulatorCover extends PumpCover {
     @SaveField
     @SyncToClient
     @Getter
+    @Setter
     protected int globalTransferLimit;
     protected int fluidTransferBuffered = 0;
 
-    private NumberInputWidget<Integer> transferSizeInput;
-    private EnumSelectorWidget<BucketMode> transferBucketModeInput;
-
     public FluidRegulatorCover(CoverDefinition definition, ICoverable coverHolder, Direction attachedSide, int tier,
                                int maxTransferRate) {
         super(definition, coverHolder, attachedSide, tier, maxTransferRate);
@@ -154,27 +157,13 @@ private int keepExact(IFluidHandlerModifiable source, IFluidHandlerModifiable de
     }
 
     private void setTransferBucketMode(BucketMode transferBucketMode) {
-        var oldMultiplier = this.transferBucketMode.multiplier;
-        var newMultiplier = transferBucketMode.multiplier;
-
         this.transferBucketMode = transferBucketMode;
         syncDataHolder.markClientSyncFieldDirty("transferBucketMode");
-        if (transferSizeInput == null) return;
-
-        if (oldMultiplier > newMultiplier) {
-            transferSizeInput.setValue(getCurrentBucketModeTransferSize());
-        }
-        this.transferSizeInput.setMax(MAX_STACK_SIZE / this.transferBucketMode.multiplier);
-        if (newMultiplier > oldMultiplier) {
-            transferSizeInput.setValue(getCurrentBucketModeTransferSize());
-        }
     }
 
     private void setTransferMode(TransferMode transferMode) {
         this.transferMode = transferMode;
 
-        configureTransferSizeInput();
-
         if (!this.isRemote()) {
             syncDataHolder.markClientSyncFieldDirty("transferMode");
             configureFilter();
@@ -186,8 +175,6 @@ protected void configureFilter() {
         if (filterHandler.getFilter() instanceof SimpleFluidFilter filter) {
             filter.setMaxStackSize(transferMode == TransferMode.TRANSFER_ANY ? 1 : MAX_STACK_SIZE);
         }
-
-        configureTransferSizeInput();
     }
 
     private int getFilteredFluidAmount(FluidStack fluidStack) {
@@ -200,45 +187,31 @@ private int getFilteredFluidAmount(FluidStack fluidStack) {
 
     ///////////////////////////
     // ***** GUI ******//
-    ///////////////////////////
 
     @Override
-    protected @NotNull String getUITitle() {
-        return "cover.fluid_regulator.title";
-    }
+    public void createCoverUIRows(Flow column, SidedPosGuiData data, PanelSyncManager syncManager,
+                                  UISettings settings) {
+        super.createCoverUIRows(column, data, syncManager, settings);
 
-    @Override
-    protected void buildAdditionalUI(WidgetGroup group) {
-        group.addWidget(
-                new EnumSelectorWidget<>(146, 45, 20, 20, TransferMode.values(), transferMode, this::setTransferMode));
-
-        this.transferSizeInput = new IntInputWidget(35, 45, 84, 20,
-                this::getCurrentBucketModeTransferSize, this::setCurrentBucketModeTransferSize).setMin(0)
-                .setMax(Integer.MAX_VALUE);
-        configureTransferSizeInput();
-        group.addWidget(this.transferSizeInput);
-
-        this.transferBucketModeInput = new EnumSelectorWidget<>(121, 45, 20, 20, BucketMode.values(),
-                transferBucketMode, this::setTransferBucketMode);
-        group.addWidget(this.transferBucketModeInput);
-    }
+        var transferMode = new EnumSyncValue<>(TransferMode.class, this::getTransferMode, this::setTransferMode);
+        var transferSize = new IntSyncValue(this::getGlobalTransferLimit, this::setGlobalTransferLimit);
+        var transferBucketMode = new EnumSyncValue<>(BucketMode.class, this::getTransferBucketMode,
+                this::setTransferBucketMode);
 
-    private int getCurrentBucketModeTransferSize() {
-        return this.globalTransferLimit / this.transferBucketMode.multiplier;
-    }
+        syncManager.syncValue("transferMode", transferMode);
+        syncManager.syncValue("transferSize", transferSize);
 
-    private void setCurrentBucketModeTransferSize(int transferSize) {
-        this.globalTransferLimit = Math.min(Math.max(transferSize * this.transferBucketMode.multiplier, 0),
-                MAX_STACK_SIZE);
-        syncDataHolder.markClientSyncFieldDirty("globalTransferLimit");
-    }
+        column.child(new GTMuiWidgets.EnumRowBuilder<>(TransferMode.class)
+                .value(transferMode)
+                .overlay(16, GTGuiTextures.TRANSFER_MODE_OVERLAY)
+                .lang(IKey.dynamic(() -> Component.translatable(getTransferMode().tooltip)))
+                .build());
 
-    private void configureTransferSizeInput() {
-        if (this.transferSizeInput == null || transferBucketModeInput == null)
-            return;
+        column.child(GTMuiWidgets.createIntInputWithBucketMode(transferSize, transferBucketMode,
+                () -> maxFluidTransferRate));
 
-        this.transferSizeInput.setVisible(shouldShowTransferSize());
-        this.transferBucketModeInput.setVisible(shouldShowTransferSize());
+        column.child(GTMuiWidgets.createIntInputWithButtons(transferSize, () -> 1, () -> MAX_STACK_SIZE)
+                .setEnabledIf($ -> shouldShowTransferSize()));
     }
 
     private boolean shouldShowTransferSize() {
diff --git a/src/main/java/com/gregtechceu/gtceu/common/cover/ItemFilterCover.java b/src/main/java/com/gregtechceu/gtceu/common/cover/ItemFilterCover.java
index 06e6e200e06..367a6d3e49b 100644
--- a/src/main/java/com/gregtechceu/gtceu/common/cover/ItemFilterCover.java
+++ b/src/main/java/com/gregtechceu/gtceu/common/cover/ItemFilterCover.java
@@ -3,10 +3,9 @@
 import com.gregtechceu.gtceu.api.capability.ICoverable;
 import com.gregtechceu.gtceu.api.cover.CoverBehavior;
 import com.gregtechceu.gtceu.api.cover.CoverDefinition;
-import com.gregtechceu.gtceu.api.cover.IUICover;
+import com.gregtechceu.gtceu.api.cover.IMuiCover;
 import com.gregtechceu.gtceu.api.cover.filter.ItemFilter;
 import com.gregtechceu.gtceu.api.cover.filter.SmartItemFilter;
-import com.gregtechceu.gtceu.api.gui.widget.EnumSelectorWidget;
 import com.gregtechceu.gtceu.api.machine.MachineCoverContainer;
 import com.gregtechceu.gtceu.api.machine.MetaMachine;
 import com.gregtechceu.gtceu.api.sync_system.annotations.SaveField;
@@ -14,18 +13,26 @@
 import com.gregtechceu.gtceu.api.transfer.item.ItemHandlerDelegate;
 import com.gregtechceu.gtceu.common.cover.data.FilterMode;
 import com.gregtechceu.gtceu.common.cover.data.ManualIOMode;
-
-import com.lowdragmc.lowdraglib.gui.widget.LabelWidget;
-import com.lowdragmc.lowdraglib.gui.widget.Widget;
-import com.lowdragmc.lowdraglib.gui.widget.WidgetGroup;
+import com.gregtechceu.gtceu.common.mui.GTGuiTextures;
+import com.gregtechceu.gtceu.common.mui.GTMuiWidgets;
 
 import net.minecraft.MethodsReturnNonnullByDefault;
 import net.minecraft.core.Direction;
 import net.minecraft.nbt.CompoundTag;
+import net.minecraft.network.chat.Component;
 import net.minecraft.server.level.ServerPlayer;
 import net.minecraft.world.item.ItemStack;
 import net.minecraftforge.items.IItemHandlerModifiable;
 
+import brachy.modularui.api.drawable.IKey;
+import brachy.modularui.factory.SidedPosGuiData;
+import brachy.modularui.screen.UISettings;
+import brachy.modularui.value.sync.DynamicSyncHandler;
+import brachy.modularui.value.sync.EnumSyncValue;
+import brachy.modularui.value.sync.PanelSyncManager;
+import brachy.modularui.widgets.ButtonWidget;
+import brachy.modularui.widgets.DynamicSyncedWidget;
+import brachy.modularui.widgets.layout.Flow;
 import lombok.Getter;
 import lombok.Setter;
 import org.jetbrains.annotations.NotNull;
@@ -35,7 +42,7 @@
 
 @ParametersAreNonnullByDefault
 @MethodsReturnNonnullByDefault
-public class ItemFilterCover extends CoverBehavior implements IUICover {
+public class ItemFilterCover extends CoverBehavior implements IMuiCover {
 
     protected ItemFilter itemFilter;
     @SaveField
@@ -90,14 +97,40 @@ public void onAttached(ItemStack itemStack, @Nullable ServerPlayer player) {
     }
 
     @Override
-    public Widget createUIWidget() {
-        final var group = new WidgetGroup(0, 0, 178, 85);
-        group.addWidget(new LabelWidget(60, 5, attachItem.getDescriptionId()));
-        group.addWidget(new EnumSelectorWidget<>(35, 25, 18, 18,
-                FilterMode.VALUES, filterMode, this::setFilterMode));
-        group.addWidget(new EnumSelectorWidget<>(35, 45, 18, 18, ManualIOMode.VALUES, allowFlow, this::setAllowFlow));
-        group.addWidget(getItemFilter().openConfigurator(62, 25));
-        return group;
+    public void createCoverUIRows(Flow column, SidedPosGuiData data, PanelSyncManager syncManager,
+                                  UISettings settings) {
+        EnumSyncValue<FilterMode> filterMode = new EnumSyncValue<>(FilterMode.class,
+                this::getFilterMode, this::setFilterMode);
+
+        EnumSyncValue<ManualIOMode> ioMode = new EnumSyncValue<>(ManualIOMode.class,
+                this::getAllowFlow, this::setAllowFlow);
+
+        syncManager.syncValue("filterMode", filterMode);
+        syncManager.syncValue("ioMode", ioMode);
+
+        var panelHandler = syncManager.syncedPanel("filterPanel", true,
+                (sm, sh) -> itemFilter.getPanel(data, sm, settings));
+
+        DynamicSyncHandler filterButton = new DynamicSyncHandler()
+                .widgetProvider((sm, buf) -> new ButtonWidget<>()
+                        .onMousePressed((x, y, b) -> {
+                            panelHandler.openPanel();
+                            return true;
+                        }));
+
+        column.child(coverUIRow().child(new DynamicSyncedWidget<>().syncHandler(filterButton)));
+
+        column.child(new GTMuiWidgets.EnumRowBuilder<>(FilterMode.class)
+                .value(filterMode)
+                .overlay(16, GTGuiTextures.FILTER_MODE_OVERLAY)
+                .lang(IKey.dynamic(() -> Component.translatable(getFilterMode().getTooltip())))
+                .build());
+
+        column.child(new GTMuiWidgets.EnumRowBuilder<>(ManualIOMode.class)
+                .value(ioMode)
+                .overlay(16, GTGuiTextures.MANUAL_IO_OVERLAY_IN)
+                .lang(IKey.dynamic(() -> Component.translatable(getAllowFlow().name())))
+                .build());
     }
 
     private class FilteredItemHandlerWrapper extends ItemHandlerDelegate {
diff --git a/src/main/java/com/gregtechceu/gtceu/common/cover/MachineControllerCover.java b/src/main/java/com/gregtechceu/gtceu/common/cover/MachineControllerCover.java
index 4fa3d4ea09d..ceef7cc9c4e 100644
--- a/src/main/java/com/gregtechceu/gtceu/common/cover/MachineControllerCover.java
+++ b/src/main/java/com/gregtechceu/gtceu/common/cover/MachineControllerCover.java
@@ -5,35 +5,39 @@
 import com.gregtechceu.gtceu.api.capability.ICoverable;
 import com.gregtechceu.gtceu.api.cover.CoverBehavior;
 import com.gregtechceu.gtceu.api.cover.CoverDefinition;
-import com.gregtechceu.gtceu.api.cover.IUICover;
-import com.gregtechceu.gtceu.api.gui.GuiTextures;
-import com.gregtechceu.gtceu.api.gui.widget.IntInputWidget;
-import com.gregtechceu.gtceu.api.gui.widget.PhantomSlotWidget;
-import com.gregtechceu.gtceu.api.gui.widget.ToggleButtonWidget;
+import com.gregtechceu.gtceu.api.cover.IMuiCover;
 import com.gregtechceu.gtceu.api.machine.MachineCoverContainer;
 import com.gregtechceu.gtceu.api.sync_system.annotations.SaveField;
 import com.gregtechceu.gtceu.api.sync_system.annotations.SyncToClient;
-import com.gregtechceu.gtceu.api.transfer.item.CustomItemStackHandler;
 import com.gregtechceu.gtceu.common.cover.data.ControllerMode;
-
-import com.lowdragmc.lowdraglib.gui.texture.GuiTextureGroup;
-import com.lowdragmc.lowdraglib.gui.texture.TextTexture;
-import com.lowdragmc.lowdraglib.gui.widget.ButtonWidget;
-import com.lowdragmc.lowdraglib.gui.widget.LabelWidget;
-import com.lowdragmc.lowdraglib.gui.widget.Widget;
-import com.lowdragmc.lowdraglib.gui.widget.WidgetGroup;
+import com.gregtechceu.gtceu.common.mui.GTGuiTextures;
+import com.gregtechceu.gtceu.common.mui.GTMuiWidgets;
 
 import net.minecraft.MethodsReturnNonnullByDefault;
 import net.minecraft.core.BlockPos;
 import net.minecraft.core.Direction;
 import net.minecraft.nbt.CompoundTag;
+import net.minecraft.network.chat.Component;
 import net.minecraft.server.level.ServerPlayer;
-import net.minecraft.world.inventory.ClickType;
-import net.minecraft.world.inventory.Slot;
 import net.minecraft.world.item.ItemStack;
 import net.minecraft.world.level.Level;
 import net.minecraft.world.level.block.Block;
 
+import brachy.modularui.api.drawable.IKey;
+import brachy.modularui.drawable.GuiTextures;
+import brachy.modularui.drawable.ItemDrawable;
+import brachy.modularui.drawable.Rectangle;
+import brachy.modularui.factory.SidedPosGuiData;
+import brachy.modularui.screen.ModularPanel;
+import brachy.modularui.screen.UISettings;
+import brachy.modularui.value.sync.BooleanSyncValue;
+import brachy.modularui.value.sync.DoubleSyncValue;
+import brachy.modularui.value.sync.EnumSyncValue;
+import brachy.modularui.value.sync.PanelSyncManager;
+import brachy.modularui.widget.Widget;
+import brachy.modularui.widgets.SliderWidget;
+import brachy.modularui.widgets.ToggleButton;
+import brachy.modularui.widgets.layout.Flow;
 import lombok.Getter;
 import lombok.experimental.Accessors;
 import org.jetbrains.annotations.Nullable;
@@ -46,10 +50,7 @@
 
 @ParametersAreNonnullByDefault
 @MethodsReturnNonnullByDefault
-public class MachineControllerCover extends CoverBehavior implements IUICover {
-
-    private CustomItemStackHandler sideCoverSlot;
-    private ButtonWidget modeButton;
+public class MachineControllerCover extends CoverBehavior implements IMuiCover {// IUICover {
 
     @SaveField
     @Getter
@@ -112,22 +113,17 @@ public void setControllerMode(@Nullable ControllerMode controllerMode) {
         this.controllerMode = controllerMode;
         syncDataHolder.markClientSyncFieldDirty("filterMode");
 
-        updateAll();
+        updateInput();
     }
 
     public void setMinRedstoneStrength(int minRedstoneStrength) {
         this.minRedstoneStrength = minRedstoneStrength;
-        updateAll();
+        updateInput();
     }
 
     public void setInverted(boolean inverted) {
         isInverted = inverted;
-        updateAll();
-    }
-
-    private void updateAll() {
         updateInput();
-        updateUI();
     }
 
     ///////////////////////////////////////////////////
@@ -200,97 +196,123 @@ private int getInputSignal() {
     //////////////////////////////////////
 
     @Override
-    public Widget createUIWidget() {
-        if (controllerMode != null && getControllable(controllerMode.side) == null) {
-            setControllerMode(null);
-        }
-        WidgetGroup group = new WidgetGroup(0, 0, 176, 95);
-
-        group.addWidget(new LabelWidget(10, 5, "cover.machine_controller.title"));
-        group.addWidget(new IntInputWidget(10, 20, 131, 20,
-                this::getMinRedstoneStrength, this::setMinRedstoneStrength).setMin(1).setMax(15));
-
-        modeButton = new ButtonWidget(10, 45, 131, 20,
-                new GuiTextureGroup(GuiTextures.VANILLA_BUTTON),
-                cd -> selectNextMode());
-        group.addWidget(modeButton);
-
-        // Inverted Mode Toggle:
-        group.addWidget(new ToggleButtonWidget(
-                146, 20, 20, 20,
-                GuiTextures.INVERT_REDSTONE_BUTTON, this::isInverted, this::setInverted)
-                .isMultiLang()
-                .setTooltipText("cover.machine_controller.invert"));
-
-        group.addWidget(new LabelWidget(10, 72, "cover.machine_controller.suspend_powerfail"));
-        group.addWidget(new ToggleButtonWidget(147, 68, 18, 18, GuiTextures.BUTTON_POWER,
-                this::preventPowerFail, (data) -> {
-                    preventPowerFail = data;
-                }));
-
-        sideCoverSlot = new CustomItemStackHandler(1);
-        group.addWidget(new PhantomSlotWidget(sideCoverSlot, 0, 147, 46) {
-
-            @Override
-            public ItemStack slotClickPhantom(Slot slot, int mouseButton, ClickType clickTypeIn, ItemStack stackHeld) {
-                return sideCoverSlot.getStackInSlot(0);
-            }
-        });
-
-        updateUI();
-
-        return group;
+    public ModularPanel<?> buildUI(SidedPosGuiData data, PanelSyncManager syncManager, UISettings settings) {
+        EnumSyncValue<ControllerMode> controllerModeValue = new EnumSyncValue<>(ControllerMode.class,
+                this::getControllerMode, this::setControllerMode);
+
+        syncManager.syncValue("controllerMode", controllerModeValue);
+
+        return ModularPanel.defaultPanel(coverDefinition.getId().getPath(), 176, 245)
+                .child(GTMuiWidgets.createTitleBar(this.self().getAttachItem(), 176, GTGuiTextures.BACKGROUND))
+                .child(Flow.col().top(7).margin(7, 0)
+                        .childPadding(2)
+                        .widthRel(1.0f)
+                        .coverChildrenHeight()
+
+                        .child(coverUIRow()
+                                .child(new ToggleButton()
+                                        .size(16).left(0)
+                                        .value(new BooleanSyncValue(this::isInverted, ($) -> this.setInverted(true)))
+                                        .overlay(GTGuiTextures.OVERLAY_REDSTONE_ON))
+                                .child(IKey.lang("cover.enable_with_redstone").asWidget()
+                                        .heightRel(1.0f).left(20)))
+                        .child(coverUIRow()
+                                .child(new ToggleButton()
+                                        .size(16).left(0)
+                                        .value(new BooleanSyncValue(() -> !this.isInverted(),
+                                                ($) -> this.setInverted(false)))
+                                        .overlay(GTGuiTextures.OVERLAY_REDSTONE_OFF))
+                                .child(IKey.lang("cover.disable_with_redstone").asWidget()
+                                        .heightRel(1.0f).left(20)))
+                        .child(coverUIRow()
+                                .child(new ToggleButton()
+                                        .size(16).left(0)
+                                        .value(new BooleanSyncValue(() -> preventPowerFail,
+                                                bool -> preventPowerFail = bool))
+                                        .overlay(GTGuiTextures.CIRCUIT_OVERLAY))
+                                .child(IKey.lang("cover.machine_controller.suspend_powerfail").asWidget()
+                                        .heightRel(1.0f).left(20)))
+                        .child(coverUIRow()
+                                .child(IKey
+                                        .dynamic(() -> Component.translatable("cover.machine_controller.redstone",
+                                                redstoneSignalOutput))
+                                        .asWidget()
+                                        .height(16).leftRel(0f)))
+                        .child(coverUIRow()
+                                .child(new SliderWidget()
+                                        .background(GTGuiTextures.FLUID_SLOT)
+                                        .widthRel(0.9f)
+                                        .height(16)
+                                        .leftRel(0.5f)
+                                        .bounds(0, 15)
+                                        .stopper(1.0)
+                                        .value(new DoubleSyncValue(() -> (double) redstoneSignalOutput,
+                                                v -> redstoneSignalOutput = (int) v))))
+                        // Separating line
+                        .child(coverUIRow().child(new Rectangle().color(UI_TEXT_COLOR).asWidget()
+                                .height(1).widthRel(0.9f).leftRel(0.5f)).margin(0, 2))
+
+                        .child(coverUIRow().child(IKey.lang("cover.machine_controller.control").asWidget()
+                                .height(16)))
+
+                        // Controlling selector
+                        .child(coverUIRow()
+                                .child(modeButton(controllerModeValue, ControllerMode.MACHINE).bottom(0))
+                                .child(modeColumn(controllerModeValue, ControllerMode.COVER_UP, IKey.str("U")))
+                                .child(modeColumn(controllerModeValue, ControllerMode.COVER_DOWN, IKey.str("D")))
+                                .child(modeColumn(controllerModeValue, ControllerMode.COVER_NORTH, IKey.str("N")))
+                                .child(modeColumn(controllerModeValue, ControllerMode.COVER_SOUTH, IKey.str("S")))
+                                .child(modeColumn(controllerModeValue, ControllerMode.COVER_EAST, IKey.str("E")))
+                                .child(modeColumn(controllerModeValue, ControllerMode.COVER_WEST, IKey.str("W")))))
+                .bindPlayerInventory();
     }
 
-    private void selectNextMode() {
-        var allowedModes = getAllowedModes();
-
-        setControllerMode(allowedModes.stream()
-                .dropWhile(mode -> this.controllerMode != null && mode != this.controllerMode)
-                .skip(1)
-                .findFirst()
-                .orElse(allowedModes.isEmpty() ? null : allowedModes.get(0)));
-
-        updateAll();
-    }
-
-    private void updateUI() {
-        updateModeButton();
-        updateCoverSlot();
+    private Flow modeColumn(EnumSyncValue<ControllerMode> syncValue, ControllerMode mode, IKey title) {
+        return Flow.column().width(18).height(28)
+                .child(title.asWidget().height(10).leftRel(0.5f))
+                .child(modeButton(syncValue, mode).bottom(0));
     }
 
-    private void updateModeButton() {
-        if (modeButton == null) {
-            return;
-        }
-
-        modeButton.setButtonTexture(new GuiTextureGroup(
-                GuiTextures.VANILLA_BUTTON,
-                new TextTexture(controllerMode != null ? controllerMode.localeName : ControllerMode.nullLocaleName)));
-    }
+    private Widget<?> modeButton(EnumSyncValue<ControllerMode> syncValue, ControllerMode mode) {
+        IControllable controllable = getControllable(mode.side);
+        if (controllable == null) {
+            // Nothing to control, put a placeholder widget
+            // 3 states possible here:
+            IKey detail;
+            if (mode.side == attachedSide) {
+                // our own side, we can't control ourselves
+                detail = IKey.lang("cover.machine_controller.this_cover");
+            } else if (mode.side != null) {
+                // some potential cover that either doesn't exist or isn't controllable
+                detail = IKey.lang("cover.machine_controller.cover_not_controllable");
+            } else {
+                // cover holder is not controllable
+                detail = IKey.lang("cover.machine_controller.machine_not_controllable");
+            }
 
-    private void updateCoverSlot() {
-        if (sideCoverSlot == null) {
-            return;
+            return GuiTextures.MC_BUTTON.asWidget().size(18)
+                    .overlay(GTGuiTextures.BUTTON_CROSS)
+                    .tooltip(t -> t.addLine(IKey.lang(mode.localeName)).addLine(detail));
         }
 
+        ItemStack stack;
         if (controllerMode == null) {
-            sideCoverSlot.setStackInSlot(0, ItemStack.EMPTY);
-            sideCoverSlot.onContentsChanged(0);
+            stack = ItemStack.EMPTY;
         } else {
-            var side = controllerMode.side;
-            if (side == null && coverHolder instanceof MachineCoverContainer coverContainer) {
-                sideCoverSlot.setStackInSlot(0, coverContainer.getMachine().getDefinition().asStack());
+            if (mode == ControllerMode.MACHINE && coverHolder instanceof MachineCoverContainer coverContainer) {
+                stack = coverContainer.getMachine().getDefinition().asStack();
             } else {
-                var cover = coverHolder.getCoverAtSide(side);
-                if (cover != null) {
-                    sideCoverSlot.setStackInSlot(0, cover.getAttachItem().copy());
-                } else {
-                    sideCoverSlot.setStackInSlot(0, ItemStack.EMPTY);
-                }
+                // this can't be null because we already checked IControllable, and it was not null
+                // noinspection ConstantConditions
+                stack = coverHolder.getCoverAtSide(mode.side).getAttachItem().copy();
             }
-            sideCoverSlot.onContentsChanged(0);
         }
+
+        return new ToggleButton().size(18)
+                .value(boolValueOf(syncValue, mode))
+                .overlay(new ItemDrawable(stack).asIcon().size(16))
+                .tooltip(t -> t.addLine(IKey.lang(mode.localeName))
+                        .addLine(IKey.lang(stack.getHoverName())));
     }
 
     @Override
diff --git a/src/main/java/com/gregtechceu/gtceu/common/cover/PumpCover.java b/src/main/java/com/gregtechceu/gtceu/common/cover/PumpCover.java
index 0ebbe5b88cb..cb6edf1f397 100644
--- a/src/main/java/com/gregtechceu/gtceu/common/cover/PumpCover.java
+++ b/src/main/java/com/gregtechceu/gtceu/common/cover/PumpCover.java
@@ -4,16 +4,10 @@
 import com.gregtechceu.gtceu.api.capability.IControllable;
 import com.gregtechceu.gtceu.api.capability.ICoverable;
 import com.gregtechceu.gtceu.api.capability.recipe.IO;
-import com.gregtechceu.gtceu.api.cover.CoverBehavior;
-import com.gregtechceu.gtceu.api.cover.CoverDefinition;
-import com.gregtechceu.gtceu.api.cover.IIOCover;
-import com.gregtechceu.gtceu.api.cover.IUICover;
+import com.gregtechceu.gtceu.api.cover.*;
 import com.gregtechceu.gtceu.api.cover.filter.FilterHandler;
 import com.gregtechceu.gtceu.api.cover.filter.FilterHandlers;
 import com.gregtechceu.gtceu.api.cover.filter.FluidFilter;
-import com.gregtechceu.gtceu.api.gui.widget.EnumSelectorWidget;
-import com.gregtechceu.gtceu.api.gui.widget.IntInputWidget;
-import com.gregtechceu.gtceu.api.gui.widget.NumberInputWidget;
 import com.gregtechceu.gtceu.api.machine.ConditionalSubscriptionHandler;
 import com.gregtechceu.gtceu.api.sync_system.annotations.RerenderOnChanged;
 import com.gregtechceu.gtceu.api.sync_system.annotations.SaveField;
@@ -23,12 +17,10 @@
 import com.gregtechceu.gtceu.api.transfer.fluid.ModifiableFluidHandlerWrapper;
 import com.gregtechceu.gtceu.common.cover.data.BucketMode;
 import com.gregtechceu.gtceu.common.cover.data.ManualIOMode;
+import com.gregtechceu.gtceu.common.mui.GTGuiTextures;
+import com.gregtechceu.gtceu.common.mui.GTMuiWidgets;
 import com.gregtechceu.gtceu.utils.GTTransferUtils;
 
-import com.lowdragmc.lowdraglib.gui.widget.LabelWidget;
-import com.lowdragmc.lowdraglib.gui.widget.Widget;
-import com.lowdragmc.lowdraglib.gui.widget.WidgetGroup;
-
 import net.minecraft.MethodsReturnNonnullByDefault;
 import net.minecraft.core.BlockPos;
 import net.minecraft.core.Direction;
@@ -40,21 +32,26 @@
 import net.minecraftforge.fluids.FluidStack;
 import net.minecraftforge.fluids.capability.IFluidHandler;
 
+import brachy.modularui.api.drawable.IKey;
+import brachy.modularui.factory.SidedPosGuiData;
+import brachy.modularui.screen.UISettings;
+import brachy.modularui.value.sync.EnumSyncValue;
+import brachy.modularui.value.sync.IntSyncValue;
+import brachy.modularui.value.sync.PanelSyncManager;
+import brachy.modularui.widgets.layout.Flow;
 import it.unimi.dsi.fastutil.ints.Int2IntFunction;
 import it.unimi.dsi.fastutil.objects.Object2LongMap;
 import it.unimi.dsi.fastutil.objects.Object2LongOpenHashMap;
 import lombok.Getter;
-import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 
-import java.util.Arrays;
 import java.util.List;
 
 import javax.annotation.ParametersAreNonnullByDefault;
 
 @ParametersAreNonnullByDefault
 @MethodsReturnNonnullByDefault
-public class PumpCover extends CoverBehavior implements IIOCover, IUICover, IControllable {
+public class PumpCover extends CoverBehavior implements IIOCover, IMuiCover, IControllable {
 
     // .5b 2b 8b
     public static final Int2IntFunction PUMP_SCALING = tier -> 64 * (int) Math.pow(4, Math.min(tier - 1, GTValues.IV));
@@ -89,7 +86,6 @@ public class PumpCover extends CoverBehavior implements IIOCover, IUICover, ICon
     @SyncToClient
     protected final FilterHandler<FluidStack, FluidFilter> filterHandler;
     protected final ConditionalSubscriptionHandler subscriptionHandler;
-    private NumberInputWidget<Integer> transferRateWidget;
 
     public PumpCover(CoverDefinition definition, ICoverable coverHolder, Direction attachedSide, int tier,
                      int maxTransferRate) {
@@ -104,7 +100,7 @@ public PumpCover(CoverDefinition definition, ICoverable coverHolder, Direction a
         filterHandler = FilterHandlers.fluid(this)
                 .onFilterLoaded(f -> configureFilter())
                 .onFilterUpdated(f -> configureFilter())
-                .onFilterRemoved(f -> configureFilter());
+                .onFilterRemoved(this::configureFilter);
     }
 
     public PumpCover(CoverDefinition definition, ICoverable coverHolder, Direction attachedSide, int tier) {
@@ -184,22 +180,8 @@ public void setTransferRate(int milliBucketsPerTick) {
     }
 
     public void setBucketMode(BucketMode bucketMode) {
-        var oldMultiplier = this.bucketMode.multiplier;
-        var newMultiplier = bucketMode.multiplier;
-
         this.bucketMode = bucketMode;
         syncDataHolder.markClientSyncFieldDirty("bucketMode");
-        if (transferRateWidget == null) return;
-
-        if (oldMultiplier > newMultiplier) {
-            transferRateWidget.setValue(getCurrentBucketModeTransferRate());
-        }
-
-        transferRateWidget.setMax(maxFluidTransferRate / bucketMode.multiplier);
-
-        if (newMultiplier > oldMultiplier) {
-            transferRateWidget.setValue(getCurrentBucketModeTransferRate());
-        }
     }
 
     protected void setManualIOMode(ManualIOMode manualIOMode) {
@@ -284,54 +266,30 @@ private static boolean canTransfer(IFluidHandlerModifiable fluidHandler, Transfe
     //////////////////////////////////////
 
     @Override
-    public Widget createUIWidget() {
-        final var group = new WidgetGroup(0, 0, 176, 137);
-        group.addWidget(new LabelWidget(10, 5, Component.translatable(getUITitle(), GTValues.VN[tier]).getString()));
-
-        transferRateWidget = new IntInputWidget(10, 20, 134, 20,
-                this::getCurrentBucketModeTransferRate, this::setCurrentBucketModeTransferRate).setMin(0);
-        setBucketMode(this.bucketMode); // initial input widget config happens here
-        group.addWidget(transferRateWidget);
-
-        group.addWidget(new EnumSelectorWidget<>(
-                146, 20, 20, 20,
-                Arrays.stream(BucketMode.values()).filter(m -> m.multiplier <= maxFluidTransferRate).toList(),
-                bucketMode, this::setBucketMode).setTooltipSupplier(this::getBucketModeTooltip));
+    public void createCoverUIRows(Flow column, SidedPosGuiData data, PanelSyncManager syncManager,
+                                  UISettings settings) {
+        IntSyncValue transferRateSync = new IntSyncValue(this::getTransferRate, this::setTransferRate);
+        EnumSyncValue<BucketMode> bucketModeSync = new EnumSyncValue<>(BucketMode.class, this::getBucketMode,
+                this::setBucketMode);
+        EnumSyncValue<ManualIOMode> manualIOModeSync = new EnumSyncValue<>(ManualIOMode.class, this::getManualIOMode,
+                this::setManualIOMode);
+        EnumSyncValue<IO> ioSync = new EnumSyncValue<>(IO.class, this::getIo, this::setIo);
 
-        group.addWidget(new EnumSelectorWidget<>(10, 45, 20, 20, List.of(IO.IN, IO.OUT), io, this::setIo));
+        syncManager.syncValue("io", ioSync);
+        syncManager.syncValue("transferRate", transferRateSync);
+        syncManager.syncValue("manualIO", manualIOModeSync);
 
-        group.addWidget(new EnumSelectorWidget<>(146, 107, 20, 20,
-                ManualIOMode.VALUES, manualIOMode, this::setManualIOMode)
-                .setHoverTooltips("cover.universal.manual_import_export.mode.description"));
+        column.child(GTMuiWidgets.createIntInputWithBucketMode(transferRateSync, bucketModeSync,
+                () -> maxFluidTransferRate));
 
-        group.addWidget(filterHandler.createFilterSlotUI(125, 108));
-        group.addWidget(filterHandler.createFilterConfigUI(10, 72, 156, 60));
+        column.child(GTMuiWidgets.createFilterRow(filterHandler, data, syncManager, settings)
+                .child(0, GTMuiWidgets.createIOCycleButton(ioSync, false)));
 
-        buildAdditionalUI(group);
-
-        return group;
-    }
-
-    private List<Component> getBucketModeTooltip(BucketMode mode, String langKey) {
-        return List.of(
-                Component.translatable(langKey).append(Component.translatable("gtceu.gui.content.units.per_tick")));
-    }
-
-    private int getCurrentBucketModeTransferRate() {
-        return this.transferRate / this.bucketMode.multiplier;
-    }
-
-    private void setCurrentBucketModeTransferRate(int transferRate) {
-        this.setTransferRate(transferRate * this.bucketMode.multiplier);
-    }
-
-    @NotNull
-    protected String getUITitle() {
-        return "cover.pump.title";
-    }
-
-    protected void buildAdditionalUI(WidgetGroup group) {
-        // Do nothing in the base implementation. This is intended to be overridden by subclasses.
+        column.child(new GTMuiWidgets.EnumRowBuilder<>(ManualIOMode.class)
+                .value(manualIOModeSync)
+                .overlay(16, GTGuiTextures.MANUAL_IO_OVERLAY_IN)
+                .lang(IKey.dynamic(() -> Component.translatable(manualIOMode.localeName)))
+                .build());
     }
 
     protected void configureFilter() {
@@ -342,7 +300,7 @@ protected void configureFilter() {
     // *** CAPABILITY OVERRIDE ***//
     /////////////////////////////////////
 
-    private CoverableFluidHandlerWrapper fluidHandlerWrapper;
+    private @Nullable CoverableFluidHandlerWrapper fluidHandlerWrapper;
 
     @Nullable
     @Override
diff --git a/src/main/java/com/gregtechceu/gtceu/common/cover/RobotArmCover.java b/src/main/java/com/gregtechceu/gtceu/common/cover/RobotArmCover.java
index 911438c8d0f..12cca37c4d1 100644
--- a/src/main/java/com/gregtechceu/gtceu/common/cover/RobotArmCover.java
+++ b/src/main/java/com/gregtechceu/gtceu/common/cover/RobotArmCover.java
@@ -5,25 +5,30 @@
 import com.gregtechceu.gtceu.api.cover.CoverDefinition;
 import com.gregtechceu.gtceu.api.cover.filter.ItemFilter;
 import com.gregtechceu.gtceu.api.cover.filter.SimpleItemFilter;
-import com.gregtechceu.gtceu.api.gui.widget.EnumSelectorWidget;
-import com.gregtechceu.gtceu.api.gui.widget.IntInputWidget;
 import com.gregtechceu.gtceu.api.sync_system.annotations.SaveField;
 import com.gregtechceu.gtceu.api.sync_system.annotations.SyncToClient;
 import com.gregtechceu.gtceu.common.cover.data.TransferMode;
+import com.gregtechceu.gtceu.common.mui.GTGuiTextures;
+import com.gregtechceu.gtceu.common.mui.GTMuiWidgets;
 import com.gregtechceu.gtceu.common.pipelike.item.ItemNetHandler;
 
-import com.lowdragmc.lowdraglib.gui.widget.WidgetGroup;
-
 import net.minecraft.MethodsReturnNonnullByDefault;
 import net.minecraft.core.Direction;
 import net.minecraft.nbt.CompoundTag;
+import net.minecraft.network.chat.Component;
 import net.minecraft.server.level.ServerPlayer;
 import net.minecraft.world.item.ItemStack;
 import net.minecraftforge.items.IItemHandler;
 
+import brachy.modularui.api.drawable.IKey;
+import brachy.modularui.factory.SidedPosGuiData;
+import brachy.modularui.screen.UISettings;
+import brachy.modularui.value.sync.EnumSyncValue;
+import brachy.modularui.value.sync.IntSyncValue;
+import brachy.modularui.value.sync.PanelSyncManager;
+import brachy.modularui.widgets.layout.Flow;
 import lombok.Getter;
 import lombok.Setter;
-import org.jetbrains.annotations.NotNull;
 
 import java.util.Iterator;
 import java.util.Map;
@@ -45,8 +50,6 @@ public class RobotArmCover extends ConveyorCover {
     protected int globalTransferLimit;
     protected int itemsTransferBuffered;
 
-    private IntInputWidget stackSizeInput;
-
     public RobotArmCover(CoverDefinition definition, ICoverable coverHolder, Direction attachedSide, int tier,
                          int maxTransferRate) {
         super(definition, coverHolder, attachedSide, tier, maxTransferRate);
@@ -157,31 +160,31 @@ public void clearBuffer() {
 
     //////////////////////////////////////
     // *********** GUI ***********//
-    //////////////////////////////////////
 
     @Override
-    @NotNull
-    protected String getUITitle() {
-        return "cover.robotic_arm.title";
-    }
+    public void createCoverUIRows(Flow column, SidedPosGuiData data, PanelSyncManager syncManager,
+                                  UISettings settings) {
+        super.createCoverUIRows(column, data, syncManager, settings);
 
-    @Override
-    protected void buildAdditionalUI(WidgetGroup group) {
-        group.addWidget(
-                new EnumSelectorWidget<>(146, 45, 20, 20, TransferMode.values(), transferMode, this::setTransferMode));
+        var transferMode = new EnumSyncValue<>(TransferMode.class, this::getTransferMode, this::setTransferMode);
+        var transferSize = new IntSyncValue(this::getGlobalTransferLimit, v -> this.globalTransferLimit = v);
+
+        syncManager.syncValue("transferMode", transferMode);
+        syncManager.syncValue("transferSize", transferSize);
 
-        this.stackSizeInput = new IntInputWidget(64, 45, 80, 20,
-                () -> globalTransferLimit, val -> globalTransferLimit = val);
-        configureStackSizeInput();
+        column.child(new GTMuiWidgets.EnumRowBuilder<>(TransferMode.class)
+                .value(transferMode)
+                .overlay(16, GTGuiTextures.TRANSFER_MODE_OVERLAY)
+                .lang(IKey.dynamic(() -> Component.translatable(getTransferMode().tooltip)))
+                .build());
 
-        group.addWidget(this.stackSizeInput);
+        column.child(GTMuiWidgets.createIntInputWithButtons(transferSize, () -> 1, () -> getTransferMode().maxStackSize)
+                .setEnabledIf($ -> shouldShowStackSize()));
     }
 
     public void setTransferMode(TransferMode transferMode) {
         this.transferMode = transferMode;
 
-        configureStackSizeInput();
-
         if (!this.isRemote()) {
             syncDataHolder.markClientSyncFieldDirty("transferMode");
             configureFilter();
@@ -193,17 +196,6 @@ protected void configureFilter() {
         if (filterHandler.getFilter() instanceof SimpleItemFilter filter) {
             filter.setMaxStackSize(filter.isBlackList() ? 1 : transferMode.maxStackSize);
         }
-
-        configureStackSizeInput();
-    }
-
-    private void configureStackSizeInput() {
-        if (this.stackSizeInput == null)
-            return;
-
-        this.stackSizeInput.setVisible(shouldShowStackSize());
-        this.stackSizeInput.setMin(1);
-        this.stackSizeInput.setMax(this.transferMode.maxStackSize);
     }
 
     private boolean shouldShowStackSize() {
diff --git a/src/main/java/com/gregtechceu/gtceu/common/cover/StorageCover.java b/src/main/java/com/gregtechceu/gtceu/common/cover/StorageCover.java
index 0341ad9c588..920d437b9b2 100644
--- a/src/main/java/com/gregtechceu/gtceu/common/cover/StorageCover.java
+++ b/src/main/java/com/gregtechceu/gtceu/common/cover/StorageCover.java
@@ -3,39 +3,34 @@
 import com.gregtechceu.gtceu.api.capability.ICoverable;
 import com.gregtechceu.gtceu.api.cover.CoverBehavior;
 import com.gregtechceu.gtceu.api.cover.CoverDefinition;
-import com.gregtechceu.gtceu.api.cover.IUICover;
-import com.gregtechceu.gtceu.api.gui.GuiTextures;
-import com.gregtechceu.gtceu.api.gui.fancy.IFancyConfigurator;
-import com.gregtechceu.gtceu.api.gui.widget.SlotWidget;
+import com.gregtechceu.gtceu.api.cover.IMuiCover;
 import com.gregtechceu.gtceu.api.machine.MachineCoverContainer;
 import com.gregtechceu.gtceu.api.sync_system.annotations.SaveField;
 import com.gregtechceu.gtceu.api.sync_system.annotations.SyncToClient;
 import com.gregtechceu.gtceu.api.transfer.item.CustomItemStackHandler;
 
-import com.lowdragmc.lowdraglib.gui.texture.IGuiTexture;
-import com.lowdragmc.lowdraglib.gui.widget.LabelWidget;
-import com.lowdragmc.lowdraglib.gui.widget.Widget;
-import com.lowdragmc.lowdraglib.gui.widget.WidgetGroup;
-import com.lowdragmc.lowdraglib.utils.LocalizationUtils;
-
 import net.minecraft.core.Direction;
-import net.minecraft.network.chat.Component;
 import net.minecraft.world.item.ItemStack;
 
-import org.jetbrains.annotations.NotNull;
-import org.jetbrains.annotations.Nullable;
+import brachy.modularui.factory.SidedPosGuiData;
+import brachy.modularui.screen.UISettings;
+import brachy.modularui.value.sync.PanelSyncManager;
+import brachy.modularui.value.sync.SyncHandlers;
+import brachy.modularui.widgets.SlotGroupWidget;
+import brachy.modularui.widgets.layout.Flow;
+import brachy.modularui.widgets.slot.ItemSlot;
 
 import java.util.List;
 
-public class StorageCover extends CoverBehavior implements IUICover {
+public class StorageCover extends CoverBehavior implements IMuiCover {
 
     @SaveField
     @SyncToClient
     public final CustomItemStackHandler inventory;
     private final int SIZE = 18;
 
-    public StorageCover(@NotNull CoverDefinition definition, @NotNull ICoverable coverableView,
-                        @NotNull Direction attachedSide) {
+    public StorageCover(CoverDefinition definition, ICoverable coverableView,
+                        Direction attachedSide) {
         super(definition, coverableView, attachedSide);
         inventory = new CustomItemStackHandler(SIZE) {
 
@@ -49,7 +44,6 @@ public int getSlotLimit(int slot) {
     }
 
     @Override
-    @NotNull
     public List<ItemStack> getAdditionalDrops() {
         var list = super.getAdditionalDrops();
         for (int slot = 0; slot < SIZE; slot++) {
@@ -69,48 +63,15 @@ public boolean canAttach() {
     }
 
     @Override
-    public Widget createUIWidget() {
-        final var group = new WidgetGroup(0, 0, 126, 87);
-
-        group.addWidget(new LabelWidget(10, 5, LocalizationUtils.format(getUITitle())));
-
-        for (int slot = 0; slot < SIZE; slot++) {
-            group.addWidget(new SlotWidget(inventory, slot, 7 + (slot % 6) * 18, 21 + (slot / 6) * 18));
-        }
-
-        return group;
-    }
-
-    private String getUITitle() {
-        return "cover.storage.title";
-    }
-
-    @Override
-    public @Nullable IFancyConfigurator getConfigurator() {
-        return new StorageCoverConfigurator();
-    }
-
-    private class StorageCoverConfigurator implements IFancyConfigurator {
-
-        @Override
-        public Component getTitle() {
-            return Component.translatable("cover.storage.title");
-        }
-
-        @Override
-        public IGuiTexture getIcon() {
-            return GuiTextures.STORAGE_ICON;
-        }
-
-        @Override
-        public Widget createConfigurator() {
-            final var group = new WidgetGroup(0, 0, 126, 87);
-
-            for (int slot = 0; slot < SIZE; slot++) {
-                group.addWidget(new SlotWidget(inventory, slot, 7 + (slot % 6) * 18, 21 + (slot / 6) * 18));
-            }
-
-            return group;
-        }
+    public void createCoverUIRows(Flow parent, SidedPosGuiData data, PanelSyncManager syncManager,
+                                  UISettings settings) {
+        parent.child(SlotGroupWidget.builder()
+                .matrix("IIIIII", "IIIIII", "IIIIII")
+                .key('I', i -> new ItemSlot()
+                        .slot(SyncHandlers.itemSlot(inventory, i).singletonSlotGroup(i)))
+                .build())
+                .rightRel(0.5F)
+                .margin(3)
+                .coverChildren();
     }
 }
diff --git a/src/main/java/com/gregtechceu/gtceu/common/cover/data/BucketMode.java b/src/main/java/com/gregtechceu/gtceu/common/cover/data/BucketMode.java
index 1768c4e28ff..9108d05b11d 100644
--- a/src/main/java/com/gregtechceu/gtceu/common/cover/data/BucketMode.java
+++ b/src/main/java/com/gregtechceu/gtceu/common/cover/data/BucketMode.java
@@ -1,27 +1,27 @@
 package com.gregtechceu.gtceu.common.cover.data;
 
-import com.gregtechceu.gtceu.api.gui.widget.EnumSelectorWidget;
+import com.gregtechceu.gtceu.GTCEu;
 
-import com.lowdragmc.lowdraglib.gui.texture.IGuiTexture;
-import com.lowdragmc.lowdraglib.gui.texture.ResourceTexture;
+import net.minecraft.resources.ResourceLocation;
 
+import brachy.modularui.drawable.UITexture;
 import lombok.Getter;
 
-public enum BucketMode implements EnumSelectorWidget.SelectableEnum {
+public enum BucketMode {
 
-    BUCKET("cover.bucket.mode.bucket", "minecraft:textures/item/water_bucket", 1000),
-    MILLI_BUCKET("cover.bucket.mode.milli_bucket", "gtceu:textures/gui/icon/bucket_mode/water_drop", 1);
+    BUCKET("cover.bucket.mode.bucket", new ResourceLocation("minecraft", "textures/item/water_bucket"), 1000),
+    MILLI_BUCKET("cover.bucket.mode.milli_bucket", GTCEu.id("textures/gui/icon/bucket_mode/water_drop"), 1);
 
     @Getter
     public final String tooltip;
     @Getter
-    public final IGuiTexture icon;
+    public final UITexture icon;
 
     public final int multiplier;
 
-    BucketMode(String tooltip, String textureName, int multiplier) {
+    BucketMode(String tooltip, ResourceLocation texture, int multiplier) {
         this.tooltip = tooltip;
-        this.icon = new ResourceTexture(textureName + ".png").scale(16F / 20F);
+        this.icon = UITexture.fullImage(texture);
         this.multiplier = multiplier;
     }
 }
diff --git a/src/main/java/com/gregtechceu/gtceu/common/cover/data/DistributionMode.java b/src/main/java/com/gregtechceu/gtceu/common/cover/data/DistributionMode.java
index 137f7c5d7d4..b5a6a216f12 100644
--- a/src/main/java/com/gregtechceu/gtceu/common/cover/data/DistributionMode.java
+++ b/src/main/java/com/gregtechceu/gtceu/common/cover/data/DistributionMode.java
@@ -1,11 +1,6 @@
 package com.gregtechceu.gtceu.common.cover.data;
 
-import com.gregtechceu.gtceu.api.gui.widget.EnumSelectorWidget;
-
-import com.lowdragmc.lowdraglib.gui.texture.IGuiTexture;
-import com.lowdragmc.lowdraglib.gui.texture.ResourceTexture;
-
-public enum DistributionMode implements EnumSelectorWidget.SelectableEnum {
+public enum DistributionMode {
 
     ROUND_ROBIN_GLOBAL("round_robin_global"),
     ROUND_ROBIN_PRIO("round_robin_prio"),
@@ -19,14 +14,4 @@ public enum DistributionMode implements EnumSelectorWidget.SelectableEnum {
     DistributionMode(String localeName) {
         this.localeName = localeName;
     }
-
-    @Override
-    public String getTooltip() {
-        return "cover.conveyor.distribution." + localeName;
-    }
-
-    @Override
-    public IGuiTexture getIcon() {
-        return new ResourceTexture("gtceu:textures/gui/icon/distribution_mode/" + localeName + ".png");
-    }
 }
diff --git a/src/main/java/com/gregtechceu/gtceu/common/cover/data/FilterMode.java b/src/main/java/com/gregtechceu/gtceu/common/cover/data/FilterMode.java
index c7ca25c8239..976176eb3c8 100644
--- a/src/main/java/com/gregtechceu/gtceu/common/cover/data/FilterMode.java
+++ b/src/main/java/com/gregtechceu/gtceu/common/cover/data/FilterMode.java
@@ -1,10 +1,6 @@
 package com.gregtechceu.gtceu.common.cover.data;
 
 import com.gregtechceu.gtceu.api.capability.recipe.IO;
-import com.gregtechceu.gtceu.api.gui.widget.EnumSelectorWidget;
-
-import com.lowdragmc.lowdraglib.gui.texture.IGuiTexture;
-import com.lowdragmc.lowdraglib.gui.texture.ResourceTexture;
 
 import net.minecraft.MethodsReturnNonnullByDefault;
 
@@ -12,7 +8,7 @@
 
 @MethodsReturnNonnullByDefault
 @ParametersAreNonnullByDefault
-public enum FilterMode implements EnumSelectorWidget.SelectableEnum {
+public enum FilterMode {
 
     FILTER_INSERT("filter_insert"),
     FILTER_EXTRACT("filter_extract"),
@@ -26,16 +22,10 @@ public enum FilterMode implements EnumSelectorWidget.SelectableEnum {
         this.localeName = localeName;
     }
 
-    @Override
     public String getTooltip() {
         return "cover.filter.mode." + this.localeName;
     }
 
-    @Override
-    public IGuiTexture getIcon() {
-        return new ResourceTexture("gtceu:textures/gui/icon/filter_mode/" + localeName + ".png");
-    }
-
     public boolean filters(IO io) {
         return (this == FILTER_INSERT && io.support(IO.IN)) || (this == FILTER_EXTRACT && io.support(IO.OUT)) ||
                 (this == FILTER_BOTH);
diff --git a/src/main/java/com/gregtechceu/gtceu/common/cover/data/ManualIOMode.java b/src/main/java/com/gregtechceu/gtceu/common/cover/data/ManualIOMode.java
index c03b48b0a28..227caa57d1b 100644
--- a/src/main/java/com/gregtechceu/gtceu/common/cover/data/ManualIOMode.java
+++ b/src/main/java/com/gregtechceu/gtceu/common/cover/data/ManualIOMode.java
@@ -1,11 +1,6 @@
 package com.gregtechceu.gtceu.common.cover.data;
 
-import com.gregtechceu.gtceu.api.gui.widget.EnumSelectorWidget;
-
-import com.lowdragmc.lowdraglib.gui.texture.IGuiTexture;
-import com.lowdragmc.lowdraglib.gui.texture.ResourceTexture;
-
-public enum ManualIOMode implements EnumSelectorWidget.SelectableEnum {
+public enum ManualIOMode {
 
     DISABLED("disabled"),
     FILTERED("filtered"),
@@ -19,13 +14,7 @@ public enum ManualIOMode implements EnumSelectorWidget.SelectableEnum {
         this.localeName = localeName;
     }
 
-    @Override
     public String getTooltip() {
         return "cover.universal.manual_import_export.mode." + localeName;
     }
-
-    @Override
-    public IGuiTexture getIcon() {
-        return new ResourceTexture("gtceu:textures/gui/icon/manual_io_mode/" + localeName + ".png");
-    }
 }
diff --git a/src/main/java/com/gregtechceu/gtceu/common/cover/data/TransferMode.java b/src/main/java/com/gregtechceu/gtceu/common/cover/data/TransferMode.java
index aefcf62a6f9..2253e08af62 100644
--- a/src/main/java/com/gregtechceu/gtceu/common/cover/data/TransferMode.java
+++ b/src/main/java/com/gregtechceu/gtceu/common/cover/data/TransferMode.java
@@ -1,13 +1,8 @@
 package com.gregtechceu.gtceu.common.cover.data;
 
-import com.gregtechceu.gtceu.api.gui.widget.EnumSelectorWidget;
-
-import com.lowdragmc.lowdraglib.gui.texture.IGuiTexture;
-import com.lowdragmc.lowdraglib.gui.texture.ResourceTexture;
-
 import lombok.Getter;
 
-public enum TransferMode implements EnumSelectorWidget.SelectableEnum {
+public enum TransferMode {
 
     TRANSFER_ANY("cover.robotic_arm.transfer_mode.transfer_any", "transfer_any", 1),
     TRANSFER_EXACT("cover.robotic_arm.transfer_mode.transfer_exact", "transfer_exact", 1024),
@@ -15,13 +10,10 @@ public enum TransferMode implements EnumSelectorWidget.SelectableEnum {
 
     @Getter
     public final String tooltip;
-    @Getter
-    public final IGuiTexture icon;
     public final int maxStackSize;
 
     TransferMode(String tooltip, String textureName, int maxStackSize) {
         this.tooltip = tooltip;
         this.maxStackSize = maxStackSize;
-        this.icon = new ResourceTexture("gtceu:textures/gui/icon/transfer_mode/" + textureName + ".png");
     }
 }
diff --git a/src/main/java/com/gregtechceu/gtceu/common/cover/data/VoidingMode.java b/src/main/java/com/gregtechceu/gtceu/common/cover/data/VoidingMode.java
index bed98901158..efe46810aba 100644
--- a/src/main/java/com/gregtechceu/gtceu/common/cover/data/VoidingMode.java
+++ b/src/main/java/com/gregtechceu/gtceu/common/cover/data/VoidingMode.java
@@ -1,26 +1,18 @@
 package com.gregtechceu.gtceu.common.cover.data;
 
-import com.gregtechceu.gtceu.api.gui.widget.EnumSelectorWidget;
-
-import com.lowdragmc.lowdraglib.gui.texture.IGuiTexture;
-import com.lowdragmc.lowdraglib.gui.texture.ResourceTexture;
-
 import lombok.Getter;
 
-public enum VoidingMode implements EnumSelectorWidget.SelectableEnum {
+public enum VoidingMode {
 
     VOID_ANY("cover.voiding.voiding_mode.void_any", "void_any", 1),
     VOID_OVERFLOW("cover.voiding.voiding_mode.void_overflow", "void_overflow", 1024);
 
     @Getter
     public final String tooltip;
-    @Getter
-    public final IGuiTexture icon;
     public final int maxStackSize;
 
     VoidingMode(String tooltip, String textureName, int maxStackSize) {
         this.tooltip = tooltip;
         this.maxStackSize = maxStackSize;
-        this.icon = new ResourceTexture("gtceu:textures/gui/icon/voiding_mode/" + textureName + ".png");
     }
 }
diff --git a/src/main/java/com/gregtechceu/gtceu/common/cover/detector/AdvancedEnergyDetectorCover.java b/src/main/java/com/gregtechceu/gtceu/common/cover/detector/AdvancedEnergyDetectorCover.java
index 20fca500a38..2864be3bde2 100644
--- a/src/main/java/com/gregtechceu/gtceu/common/cover/detector/AdvancedEnergyDetectorCover.java
+++ b/src/main/java/com/gregtechceu/gtceu/common/cover/detector/AdvancedEnergyDetectorCover.java
@@ -4,29 +4,29 @@
 import com.gregtechceu.gtceu.api.capability.ICoverable;
 import com.gregtechceu.gtceu.api.capability.IEnergyInfoProvider;
 import com.gregtechceu.gtceu.api.cover.CoverDefinition;
-import com.gregtechceu.gtceu.api.cover.IUICover;
-import com.gregtechceu.gtceu.api.gui.GuiTextures;
-import com.gregtechceu.gtceu.api.gui.widget.LongInputWidget;
-import com.gregtechceu.gtceu.api.gui.widget.ToggleButtonWidget;
+import com.gregtechceu.gtceu.api.cover.IMuiCover;
 import com.gregtechceu.gtceu.api.sync_system.annotations.SaveField;
+import com.gregtechceu.gtceu.common.mui.GTGuiTextures;
+import com.gregtechceu.gtceu.common.mui.GTMuiWidgets;
 import com.gregtechceu.gtceu.utils.GTMath;
 
-import com.lowdragmc.lowdraglib.gui.widget.LabelWidget;
-import com.lowdragmc.lowdraglib.gui.widget.TextBoxWidget;
-import com.lowdragmc.lowdraglib.gui.widget.Widget;
-import com.lowdragmc.lowdraglib.gui.widget.WidgetGroup;
-import com.lowdragmc.lowdraglib.utils.LocalizationUtils;
-
 import net.minecraft.MethodsReturnNonnullByDefault;
 import net.minecraft.core.Direction;
 import net.minecraft.nbt.CompoundTag;
 import net.minecraft.server.level.ServerPlayer;
 
+import brachy.modularui.api.drawable.IKey;
+import brachy.modularui.factory.SidedPosGuiData;
+import brachy.modularui.screen.UISettings;
+import brachy.modularui.theme.ThemeAPI;
+import brachy.modularui.value.sync.BooleanSyncValue;
+import brachy.modularui.value.sync.LongSyncValue;
+import brachy.modularui.value.sync.PanelSyncManager;
+import brachy.modularui.widgets.ToggleButton;
+import brachy.modularui.widgets.layout.Flow;
 import lombok.Getter;
-import lombok.Setter;
 
 import java.math.BigInteger;
-import java.util.List;
 
 import javax.annotation.ParametersAreNonnullByDefault;
 
@@ -34,23 +34,19 @@
 
 @ParametersAreNonnullByDefault
 @MethodsReturnNonnullByDefault
-public class AdvancedEnergyDetectorCover extends EnergyDetectorCover implements IUICover {
+public class AdvancedEnergyDetectorCover extends EnergyDetectorCover implements IMuiCover {
 
     private static final int DEFAULT_MIN_PERCENT = 33;
     private static final int DEFAULT_MAX_PERCENT = 66;
 
     @SaveField
     @Getter
-    @Setter
     public long minValue, maxValue;
 
     @SaveField
     @Getter
     private boolean usePercent;
 
-    private LongInputWidget minValueInput;
-    private LongInputWidget maxValueInput;
-
     public AdvancedEnergyDetectorCover(CoverDefinition definition, ICoverable coverHolder, Direction attachedSide) {
         super(definition, coverHolder, attachedSide);
         this.minValue = DEFAULT_MIN_PERCENT;
@@ -99,11 +95,30 @@ protected void update() {
         }
     }
 
+    public long getEnergyCapacity() {
+        try {
+            return getEnergyInfoProvider().getEnergyInfo().capacity().longValueExact();
+        } catch (ArithmeticException e) {
+            return Long.MAX_VALUE;
+        }
+    }
+
+    public void setMinValue(long value) {
+        this.minValue = GTMath.clamp(value, 0, maxValue - 1);
+        if (this.minValue < 0) this.minValue = 0;
+    }
+
+    public void setMaxValue(long value) {
+        if (usePercent) maxValue = GTMath.clamp(value, 0, 100);
+        else maxValue = GTMath.clamp(value, 0, getEnergyCapacity());
+        setMinValue(this.getMinValue());
+    }
+
     public void setUsePercent(boolean usePercent) {
         var wasPercent = this.usePercent;
         this.usePercent = usePercent;
 
-        initializeMinMaxInputs(wasPercent);
+        updateEUValues(wasPercent);
     }
 
     //////////////////////////////////////
@@ -111,74 +126,49 @@ public void setUsePercent(boolean usePercent) {
     //////////////////////////////////////
 
     @Override
-    public Widget createUIWidget() {
-        WidgetGroup group = new WidgetGroup(0, 0, 176, 105);
-        group.addWidget(new LabelWidget(10, 5, "cover.advanced_energy_detector.label"));
-
-        group.addWidget(new TextBoxWidget(10, 55, 25,
-                List.of(LocalizationUtils.format("cover.advanced_energy_detector.min"))));
-
-        group.addWidget(new TextBoxWidget(10, 80, 25,
-                List.of(LocalizationUtils.format("cover.advanced_energy_detector.max"))));
-
-        minValueInput = new LongInputWidget(40, 50, 176 - 40 - 10, 20, this::getMinValue, this::setMinValue);
-        maxValueInput = new LongInputWidget(40, 75, 176 - 40 - 10, 20, this::getMaxValue, this::setMaxValue);
-        initializeMinMaxInputs(usePercent);
-        group.addWidget(minValueInput);
-        group.addWidget(maxValueInput);
-
-        // Invert Redstone Output Toggle:
-        group.addWidget(new ToggleButtonWidget(
-                9, 20, 20, 20,
-                GuiTextures.INVERT_REDSTONE_BUTTON, this::isInverted, this::setInverted)
-                .isMultiLang()
-                .setTooltipText("cover.advanced_energy_detector.invert"));
-
-        // Mode (EU / Percent) Toggle:
-        group.addWidget(new ToggleButtonWidget(
-                176 - 29, 20, 20, 20,
-                GuiTextures.ENERGY_DETECTOR_COVER_MODE_BUTTON, this::isUsePercent, this::setUsePercent)
-                .isMultiLang()
-                .setTooltipText("cover.advanced_energy_detector.use_percent"));
-
-        return group;
+    public void createCoverUIRows(Flow column, SidedPosGuiData data, PanelSyncManager syncManager,
+                                  UISettings settings) {
+        syncManager.syncValue("usePercent", new BooleanSyncValue(this::isUsePercent, this::setUsePercent));
+        var minValueSync = new LongSyncValue(this::getMinValue, this::setMinValue);
+        var maxValueSync = new LongSyncValue(this::getMaxValue, this::setMaxValue);
+
+        syncManager.syncValue("minValue", minValueSync);
+        syncManager.syncValue("maxValue", maxValueSync);
+
+        column.child(coverUIRow().child(IKey.lang("cover.advanced_energy_detector.min").asWidget().width(20))
+                .child(GTMuiWidgets.createLongInputWithButtons(minValueSync, () -> 0, this::getMaxValue).width(142)))
+                .child(coverUIRow().child(IKey.lang("cover.advanced_energy_detector.max").asWidget().width(20))
+                        .child(GTMuiWidgets.createLongInputWithButtons(maxValueSync, () -> 0,
+                                () -> usePercent ? 100 : getEnergyCapacity()).width(142)))
+                .child(coverUIRow()
+                        .child(new ToggleButton().value(new BooleanSyncValue(this::isInverted, this::setInverted))
+                                .overlay(false, GTGuiTextures.OVERLAY_REDSTONE_OFF)
+                                .overlay(true, GTGuiTextures.OVERLAY_REDSTONE_ON)
+                                .tooltip(false, t -> t.add("cover.advanced_energy_detector.invert.disabled"))
+                                .tooltip(true, t -> t.add("cover.advanced_energy_detector.invert.enabled")))
+                        .child(new ToggleButton().value(new BooleanSyncValue(this::isUsePercent, this::setUsePercent))
+                                .selectedBackground(ThemeAPI.INSTANCE.getTheme(settings.getTheme())
+                                        .getToggleButtonTheme().theme().getBackground())
+                                .overlay(false, GTGuiTextures.BUTTON_EU)
+                                .overlay(true, GTGuiTextures.BUTTON_PERCENT)
+                                .tooltip(false,
+                                        t -> t.add("cover.advanced_energy_detector.use_percent.disabled"))
+                                .tooltip(true,
+                                        t -> t.add("cover.advanced_energy_detector.use_percent.enabled"))));
     }
 
-    private void initializeMinMaxInputs(boolean wasPercent) {
-        if (GTCEu.isClientThread() || minValueInput == null || maxValueInput == null)
-            return;
+    private void updateEUValues(boolean wasPercent) {
+        if (GTCEu.isClientThread()) return;
 
-        long energyCapacity;
-        try {
-            energyCapacity = getEnergyInfoProvider().getEnergyInfo().capacity().longValueExact();
-        } catch (ArithmeticException e) {
-            energyCapacity = Long.MAX_VALUE;
-        }
+        long energyCapacity = getEnergyCapacity();
 
-        minValueInput.setMin(0L);
-        maxValueInput.setMin(0L);
-
-        if (usePercent) {
-            // This needs to be before setting the maximum, because otherwise the value would be limited to 100 EU
-            // before converting to percent.
-            if (!wasPercent) {
-                minValueInput.setValue(GTMath.clamp((long) (((double) minValue / energyCapacity) * 100), 0, 100));
-                maxValueInput.setValue(GTMath.clamp((long) (((double) maxValue / energyCapacity) * 100), 0, 100));
-            }
-
-            minValueInput.setMax(100L);
-            maxValueInput.setMax(100L);
+        if (usePercent && !wasPercent) {
+            minValue = GTMath.clamp((long) (((double) minValue / energyCapacity) * 100), 0, 100);
+            maxValue = GTMath.clamp((long) (((double) maxValue / energyCapacity) * 100), 0, 100);
         } else {
-            minValueInput.setMax(energyCapacity);
-            maxValueInput.setMax(energyCapacity);
-
-            // This needs to be after setting the maximum, because otherwise the converted value would be
-            // limited to 100.
             if (wasPercent) {
-                minValueInput.setValue(
-                        GTMath.clamp((long) Math.ceil((minValue / 100.0) * energyCapacity), 0, energyCapacity));
-                maxValueInput.setValue(
-                        GTMath.clamp((long) Math.ceil((maxValue / 100.0) * energyCapacity), 0, energyCapacity));
+                minValue = GTMath.clamp((long) Math.ceil((minValue / 100.0) * energyCapacity), 0, energyCapacity);
+                maxValue = GTMath.clamp((long) Math.ceil((maxValue / 100.0) * energyCapacity), 0, energyCapacity);
             }
         }
     }
diff --git a/src/main/java/com/gregtechceu/gtceu/common/cover/detector/AdvancedFluidDetectorCover.java b/src/main/java/com/gregtechceu/gtceu/common/cover/detector/AdvancedFluidDetectorCover.java
index 86ef201e8f2..cd50bf39090 100644
--- a/src/main/java/com/gregtechceu/gtceu/common/cover/detector/AdvancedFluidDetectorCover.java
+++ b/src/main/java/com/gregtechceu/gtceu/common/cover/detector/AdvancedFluidDetectorCover.java
@@ -2,21 +2,14 @@
 
 import com.gregtechceu.gtceu.api.capability.ICoverable;
 import com.gregtechceu.gtceu.api.cover.CoverDefinition;
-import com.gregtechceu.gtceu.api.cover.IUICover;
+import com.gregtechceu.gtceu.api.cover.IMuiCover;
 import com.gregtechceu.gtceu.api.cover.filter.FilterHandler;
 import com.gregtechceu.gtceu.api.cover.filter.FilterHandlers;
 import com.gregtechceu.gtceu.api.cover.filter.FluidFilter;
-import com.gregtechceu.gtceu.api.gui.GuiTextures;
-import com.gregtechceu.gtceu.api.gui.widget.IntInputWidget;
-import com.gregtechceu.gtceu.api.gui.widget.ToggleButtonWidget;
 import com.gregtechceu.gtceu.api.sync_system.annotations.SaveField;
 import com.gregtechceu.gtceu.api.sync_system.annotations.SyncToClient;
-
-import com.lowdragmc.lowdraglib.gui.widget.LabelWidget;
-import com.lowdragmc.lowdraglib.gui.widget.TextBoxWidget;
-import com.lowdragmc.lowdraglib.gui.widget.Widget;
-import com.lowdragmc.lowdraglib.gui.widget.WidgetGroup;
-import com.lowdragmc.lowdraglib.utils.LocalizationUtils;
+import com.gregtechceu.gtceu.common.mui.GTGuiTextures;
+import com.gregtechceu.gtceu.common.mui.GTMuiWidgets;
 
 import net.minecraft.MethodsReturnNonnullByDefault;
 import net.minecraft.core.Direction;
@@ -27,6 +20,14 @@
 import net.minecraftforge.fluids.FluidStack;
 import net.minecraftforge.fluids.capability.IFluidHandler;
 
+import brachy.modularui.api.drawable.IKey;
+import brachy.modularui.factory.SidedPosGuiData;
+import brachy.modularui.screen.UISettings;
+import brachy.modularui.value.sync.BooleanSyncValue;
+import brachy.modularui.value.sync.IntSyncValue;
+import brachy.modularui.value.sync.PanelSyncManager;
+import brachy.modularui.widgets.ToggleButton;
+import brachy.modularui.widgets.layout.Flow;
 import lombok.Getter;
 
 import java.util.List;
@@ -38,7 +39,7 @@
 
 @ParametersAreNonnullByDefault
 @MethodsReturnNonnullByDefault
-public class AdvancedFluidDetectorCover extends FluidDetectorCover implements IUICover {
+public class AdvancedFluidDetectorCover extends FluidDetectorCover implements IMuiCover {
 
     private static final int DEFAULT_MIN = 64;
     private static final int DEFAULT_MAX = 512;
@@ -107,47 +108,47 @@ protected void update() {
 
     public void setMinValue(int minValue) {
         this.minValue = Mth.clamp(minValue, 0, maxValue - 1);
+        if (this.minValue < 0) this.minValue = 0;
     }
 
     public void setMaxValue(int maxValue) {
         this.maxValue = Math.max(maxValue, 0);
+        setMinValue(this.getMinValue());
     }
 
     //////////////////////////////////////
     // *********** GUI ***********//
     //////////////////////////////////////
-
+    ///
     @Override
-    public Widget createUIWidget() {
-        WidgetGroup group = new WidgetGroup(0, 0, 176, 170);
-        group.addWidget(new LabelWidget(10, 5, "cover.advanced_fluid_detector.label"));
-
-        group.addWidget(new TextBoxWidget(10, 55, 65,
-                List.of(LocalizationUtils.format("cover.advanced_fluid_detector.min"))));
-
-        group.addWidget(new TextBoxWidget(10, 80, 65,
-                List.of(LocalizationUtils.format("cover.advanced_fluid_detector.max"))));
-
-        group.addWidget(new IntInputWidget(80, 50, 176 - 80 - 10, 20, this::getMinValue, this::setMinValue));
-        group.addWidget(new IntInputWidget(80, 75, 176 - 80 - 10, 20, this::getMaxValue, this::setMaxValue));
-
-        // Invert Redstone Output Toggle:
-        group.addWidget(new ToggleButtonWidget(
-                9, 20, 20, 20,
-                GuiTextures.INVERT_REDSTONE_BUTTON, this::isInverted, this::setInverted)
-                .isMultiLang()
-                .setTooltipText("cover.advanced_fluid_detector.invert"));
-
-        group.addWidget(
-                new ToggleButtonWidget(31, 21, 18, 18, GuiTextures.BUTTON_LOCK, this::isLatched, this::setLatched)
-                        .setShouldUseBaseBackground()
-                        .isMultiLang()
-                        .setTooltipText("cover.advanced_detector.latch"));
-
-        group.addWidget(filterHandler.createFilterSlotUI(148, 100));
-        group.addWidget(filterHandler.createFilterConfigUI(10, 100, 156, 60));
-
-        return group;
+    public void createCoverUIRows(Flow column, SidedPosGuiData data, PanelSyncManager syncManager,
+                                  UISettings settings) {
+        var minValueSync = new IntSyncValue(this::getMinValue, this::setMinValue);
+        var maxValueSync = new IntSyncValue(this::getMaxValue, this::setMaxValue);
+
+        syncManager.syncValue("minValue", minValueSync);
+        syncManager.syncValue("maxValue", maxValueSync);
+
+        var buttonRow = coverUIRow()
+                .child(new ToggleButton().value(new BooleanSyncValue(this::isInverted, this::setInverted))
+                        .overlay(false, GTGuiTextures.OVERLAY_REDSTONE_OFF)
+                        .overlay(true, GTGuiTextures.OVERLAY_REDSTONE_ON)
+                        .tooltip(false, t -> t.add("cover.advanced_fluid_detector.invert.disabled"))
+                        .tooltip(true, t -> t.add("cover.advanced_fluid_detector.invert.enabled")))
+                .child(new ToggleButton().value(new BooleanSyncValue(this::isLatched, this::setLatched))
+                        .overlay(false, GTGuiTextures.BUTTON_LOCK)
+                        .overlay(true, GTGuiTextures.BUTTON_LOCK)
+                        .tooltip(false, t -> t.add("cover.advanced_detector.latch.disabled"))
+                        .tooltip(true, t -> t.add("cover.advanced_detector.latch.enabled")));
+
+        GTMuiWidgets.createFilterRow(buttonRow, filterHandler, data, syncManager, settings);
+
+        column.child(coverUIRow().child(IKey.lang("cover.advanced_fluid_detector.min").asWidget().width(50))
+                .child(GTMuiWidgets.createIntInputWithButtons(minValueSync, () -> 0, this::getMaxValue).width(110)))
+                .child(coverUIRow().child(IKey.lang("cover.advanced_fluid_detector.max").asWidget().width(50))
+                        .child(GTMuiWidgets.createIntInputWithButtons(maxValueSync, () -> 0, () -> Integer.MAX_VALUE)
+                                .width(110)))
+                .child(buttonRow);
     }
 
     @Override
diff --git a/src/main/java/com/gregtechceu/gtceu/common/cover/detector/AdvancedItemDetectorCover.java b/src/main/java/com/gregtechceu/gtceu/common/cover/detector/AdvancedItemDetectorCover.java
index bf6cde4d7f3..9d66b094191 100644
--- a/src/main/java/com/gregtechceu/gtceu/common/cover/detector/AdvancedItemDetectorCover.java
+++ b/src/main/java/com/gregtechceu/gtceu/common/cover/detector/AdvancedItemDetectorCover.java
@@ -2,23 +2,16 @@
 
 import com.gregtechceu.gtceu.api.capability.ICoverable;
 import com.gregtechceu.gtceu.api.cover.CoverDefinition;
-import com.gregtechceu.gtceu.api.cover.IUICover;
+import com.gregtechceu.gtceu.api.cover.IMuiCover;
 import com.gregtechceu.gtceu.api.cover.filter.FilterHandler;
 import com.gregtechceu.gtceu.api.cover.filter.FilterHandlers;
 import com.gregtechceu.gtceu.api.cover.filter.ItemFilter;
-import com.gregtechceu.gtceu.api.gui.GuiTextures;
-import com.gregtechceu.gtceu.api.gui.widget.IntInputWidget;
-import com.gregtechceu.gtceu.api.gui.widget.ToggleButtonWidget;
 import com.gregtechceu.gtceu.api.sync_system.annotations.SaveField;
 import com.gregtechceu.gtceu.api.sync_system.annotations.SyncToClient;
+import com.gregtechceu.gtceu.common.mui.GTGuiTextures;
+import com.gregtechceu.gtceu.common.mui.GTMuiWidgets;
 import com.gregtechceu.gtceu.utils.RedstoneUtil;
 
-import com.lowdragmc.lowdraglib.gui.widget.LabelWidget;
-import com.lowdragmc.lowdraglib.gui.widget.TextBoxWidget;
-import com.lowdragmc.lowdraglib.gui.widget.Widget;
-import com.lowdragmc.lowdraglib.gui.widget.WidgetGroup;
-import com.lowdragmc.lowdraglib.utils.LocalizationUtils;
-
 import net.minecraft.MethodsReturnNonnullByDefault;
 import net.minecraft.core.Direction;
 import net.minecraft.nbt.CompoundTag;
@@ -27,6 +20,14 @@
 import net.minecraft.world.item.ItemStack;
 import net.minecraftforge.items.IItemHandler;
 
+import brachy.modularui.api.drawable.IKey;
+import brachy.modularui.factory.SidedPosGuiData;
+import brachy.modularui.screen.UISettings;
+import brachy.modularui.value.sync.BooleanSyncValue;
+import brachy.modularui.value.sync.IntSyncValue;
+import brachy.modularui.value.sync.PanelSyncManager;
+import brachy.modularui.widgets.ToggleButton;
+import brachy.modularui.widgets.layout.Flow;
 import lombok.Getter;
 
 import java.util.List;
@@ -35,7 +36,7 @@
 
 @ParametersAreNonnullByDefault
 @MethodsReturnNonnullByDefault
-public class AdvancedItemDetectorCover extends ItemDetectorCover implements IUICover {
+public class AdvancedItemDetectorCover extends ItemDetectorCover implements IMuiCover {
 
     private static final int DEFAULT_MIN = 64;
     private static final int DEFAULT_MAX = 512;
@@ -98,10 +99,12 @@ protected void update() {
 
     public void setMinValue(int minValue) {
         this.minValue = Mth.clamp(minValue, 0, maxValue - 1);
+        if (this.minValue < 0) this.minValue = 0;
     }
 
     public void setMaxValue(int maxValue) {
         this.maxValue = Math.max(maxValue, 0);
+        setMinValue(this.getMinValue());
     }
 
     public void setLatched(boolean latched) {
@@ -114,37 +117,34 @@ public void setLatched(boolean latched) {
     //////////////////////////////////////
 
     @Override
-    public Widget createUIWidget() {
-        WidgetGroup group = new WidgetGroup(0, 0, 176, 170);
-        group.addWidget(new LabelWidget(10, 5, "cover.advanced_item_detector.label"));
-
-        group.addWidget(new TextBoxWidget(10, 55, 65,
-                List.of(LocalizationUtils.format("cover.advanced_item_detector.min"))));
-
-        group.addWidget(new TextBoxWidget(10, 80, 65,
-                List.of(LocalizationUtils.format("cover.advanced_item_detector.max"))));
-
-        group.addWidget(new IntInputWidget(80, 50, 176 - 80 - 10, 20, this::getMinValue, this::setMinValue));
-        group.addWidget(new IntInputWidget(80, 75, 176 - 80 - 10, 20, this::getMaxValue, this::setMaxValue));
-
-        // Invert Redstone Output Toggle:
-        group.addWidget(new ToggleButtonWidget(
-                9, 20, 20, 20,
-                GuiTextures.INVERT_REDSTONE_BUTTON, this::isInverted, this::setInverted)
-                .isMultiLang()
-                .setTooltipText("cover.advanced_item_detector.invert"));
-
-        group.addWidget(new ToggleButtonWidget(31, 21, 18, 18,
-                GuiTextures.BUTTON_LOCK, this::isLatched, this::setLatched)
-                .setShouldUseBaseBackground()
-                .isMultiLang()
-                .setTooltipText("cover.advanced_detector.latch"));
-
-        // Item Filter UI:
-        group.addWidget(filterHandler.createFilterSlotUI(148, 100));
-        group.addWidget(filterHandler.createFilterConfigUI(10, 100, 156, 60));
-
-        return group;
+    public void createCoverUIRows(Flow column, SidedPosGuiData data, PanelSyncManager syncManager,
+                                  UISettings settings) {
+        var minValueSync = new IntSyncValue(this::getMinValue, this::setMinValue);
+        var maxValueSync = new IntSyncValue(this::getMaxValue, this::setMaxValue);
+
+        syncManager.syncValue("minValue", minValueSync);
+        syncManager.syncValue("maxValue", maxValueSync);
+
+        var buttonRow = coverUIRow()
+                .child(new ToggleButton().value(new BooleanSyncValue(this::isInverted, this::setInverted))
+                        .overlay(false, GTGuiTextures.OVERLAY_REDSTONE_OFF)
+                        .overlay(true, GTGuiTextures.OVERLAY_REDSTONE_ON)
+                        .tooltip(false, t -> t.add("cover.advanced_item_detector.invert.disabled"))
+                        .tooltip(true, t -> t.add("cover.advanced_item_detector.invert.disabled")))
+                .child(new ToggleButton().value(new BooleanSyncValue(this::isLatched, this::setLatched))
+                        .overlay(false, GTGuiTextures.BUTTON_LOCK)
+                        .overlay(true, GTGuiTextures.BUTTON_LOCK)
+                        .tooltip(false, t -> t.add("cover.advanced_detector.latch.disabled"))
+                        .tooltip(true, t -> t.add("cover.advanced_detector.latch.enabled")));
+
+        GTMuiWidgets.createFilterRow(buttonRow, filterHandler, data, syncManager, settings);
+
+        column.child(coverUIRow().child(IKey.lang("cover.advanced_item_detector.min").asWidget().width(50))
+                .child(GTMuiWidgets.createIntInputWithButtons(minValueSync, () -> 0, this::getMaxValue).width(110)))
+                .child(coverUIRow().child(IKey.lang("cover.advanced_item_detector.max").asWidget().width(50))
+                        .child(GTMuiWidgets.createIntInputWithButtons(maxValueSync, () -> 0, () -> Integer.MAX_VALUE)
+                                .width(110)))
+                .child(buttonRow);
     }
 
     @Override
diff --git a/src/main/java/com/gregtechceu/gtceu/common/cover/ender/AbstractEnderLinkCover.java b/src/main/java/com/gregtechceu/gtceu/common/cover/ender/AbstractEnderLinkCover.java
index 2366d75bd07..9df754f5d50 100644
--- a/src/main/java/com/gregtechceu/gtceu/common/cover/ender/AbstractEnderLinkCover.java
+++ b/src/main/java/com/gregtechceu/gtceu/common/cover/ender/AbstractEnderLinkCover.java
@@ -5,56 +5,65 @@
 import com.gregtechceu.gtceu.api.capability.recipe.IO;
 import com.gregtechceu.gtceu.api.cover.CoverBehavior;
 import com.gregtechceu.gtceu.api.cover.CoverDefinition;
-import com.gregtechceu.gtceu.api.cover.IUICover;
+import com.gregtechceu.gtceu.api.cover.IMuiCover;
 import com.gregtechceu.gtceu.api.cover.filter.FilterHandler;
-import com.gregtechceu.gtceu.api.gui.GuiTextures;
-import com.gregtechceu.gtceu.api.gui.widget.ColorBlockWidget;
-import com.gregtechceu.gtceu.api.gui.widget.ConfirmTextInputWidget;
-import com.gregtechceu.gtceu.api.gui.widget.EnumSelectorWidget;
-import com.gregtechceu.gtceu.api.gui.widget.ToggleButtonWidget;
 import com.gregtechceu.gtceu.api.machine.ConditionalSubscriptionHandler;
 import com.gregtechceu.gtceu.api.machine.MachineCoverContainer;
 import com.gregtechceu.gtceu.api.misc.virtualregistry.EntryTypes;
 import com.gregtechceu.gtceu.api.misc.virtualregistry.VirtualEnderRegistry;
 import com.gregtechceu.gtceu.api.misc.virtualregistry.VirtualEntry;
-import com.gregtechceu.gtceu.api.misc.virtualregistry.entries.VirtualTank;
 import com.gregtechceu.gtceu.api.sync_system.annotations.RerenderOnChanged;
 import com.gregtechceu.gtceu.api.sync_system.annotations.SaveField;
 import com.gregtechceu.gtceu.api.sync_system.annotations.SyncToClient;
-import com.gregtechceu.gtceu.common.cover.data.ManualIOMode;
+import com.gregtechceu.gtceu.common.mui.GTGuiTextures;
+import com.gregtechceu.gtceu.common.mui.GTMuiWidgets;
 
-import com.lowdragmc.lowdraglib.gui.editor.ColorPattern;
-import com.lowdragmc.lowdraglib.gui.texture.GuiTextureGroup;
-import com.lowdragmc.lowdraglib.gui.texture.IGuiTexture;
-import com.lowdragmc.lowdraglib.gui.texture.TextTexture;
-import com.lowdragmc.lowdraglib.gui.widget.*;
-
-import net.minecraft.ChatFormatting;
 import net.minecraft.core.Direction;
 import net.minecraft.nbt.CompoundTag;
 import net.minecraft.network.FriendlyByteBuf;
+import net.minecraft.network.chat.Component;
+import net.minecraft.server.level.ServerLevel;
 import net.minecraft.server.level.ServerPlayer;
-import net.minecraft.world.item.ItemStack;
 
+import brachy.modularui.api.drawable.IDrawable;
+import brachy.modularui.api.drawable.IKey;
+import brachy.modularui.api.widget.IWidget;
+import brachy.modularui.drawable.Rectangle;
+import brachy.modularui.factory.GuiData;
+import brachy.modularui.factory.SidedPosGuiData;
+import brachy.modularui.screen.ModularPanel;
+import brachy.modularui.screen.RichTooltip;
+import brachy.modularui.screen.UISettings;
+import brachy.modularui.utils.Alignment;
+import brachy.modularui.utils.Color;
+import brachy.modularui.utils.MouseData;
+import brachy.modularui.utils.serialization.network.IByteBufAdapter;
+import brachy.modularui.value.sync.*;
+import brachy.modularui.widget.EmptyWidget;
+import brachy.modularui.widget.ParentWidget;
+import brachy.modularui.widgets.*;
+import brachy.modularui.widgets.layout.Flow;
+import brachy.modularui.widgets.textfield.TextFieldWidget;
+import lombok.AccessLevel;
 import lombok.Getter;
-import org.apache.commons.lang3.mutable.MutableBoolean;
-import org.jetbrains.annotations.Contract;
-import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 
+import java.nio.charset.StandardCharsets;
 import java.util.*;
+import java.util.function.IntSupplier;
 import java.util.regex.Pattern;
 
 @SuppressWarnings("SameParameterValue")
 public abstract class AbstractEnderLinkCover<T extends VirtualEntry> extends CoverBehavior
-                                            implements IUICover, IControllable {
+                                            implements IMuiCover, IControllable {
 
-    public static final Pattern COLOR_INPUT_PATTERN = Pattern.compile("^[0-9a-fA-F]{0,8}$");
+    public static final Pattern COLOR_INPUT_PATTERN = Pattern.compile("([^0-9a-fA-F])");
 
     protected final ConditionalSubscriptionHandler subscriptionHandler;
 
     @SaveField
     @SyncToClient
+    @Getter(value = AccessLevel.PROTECTED)
     protected String colorStr = VirtualEntry.DEFAULT_COLOR;
     @Getter
     @SaveField
@@ -66,19 +75,12 @@ public abstract class AbstractEnderLinkCover<T extends VirtualEntry> extends Cov
     @Getter
     @SaveField
     @SyncToClient
-    protected ManualIOMode manualIOMode = ManualIOMode.DISABLED;
-    @Getter
-    @SaveField
-    @SyncToClient
     @RerenderOnChanged
     protected IO io = IO.OUT;
-    protected VirtualEntryWidget virtualEntryWidget;
-    @SyncToClient
-    boolean isAnyChanged = false;
 
     public AbstractEnderLinkCover(CoverDefinition definition, ICoverable coverHolder, Direction attachedSide) {
         super(definition, coverHolder, attachedSide);
-        subscriptionHandler = new ConditionalSubscriptionHandler(coverHolder, this::update, this::isSubscriptionActive);
+        subscriptionHandler = new ConditionalSubscriptionHandler(coverHolder, this::update, this::isWorkingEnabled);
     }
 
     @Override
@@ -90,36 +92,16 @@ public void onLoad() {
     @Override
     public abstract boolean canAttach();
 
-    @Override
-    public void onAttached(@NotNull ItemStack itemStack, @Nullable ServerPlayer player) {
-        super.onAttached(itemStack, player);
-    }
-
-    @Override
-    public void onRemoved() {
-        super.onRemoved();
-        subscriptionHandler.unsubscribe();
-        if (!isRemote()) {
-            VirtualEnderRegistry.getInstance()
-                    .deleteEntryIf(getOwner(), getEntryType(), getChannelName(), VirtualEntry::canRemove);
-        }
-    }
-
     @Override
     public void onUnload() {
         super.onUnload();
         subscriptionHandler.unsubscribe();
         if (!isRemote()) {
-            VirtualEnderRegistry.getInstance()
-                    .deleteEntryIf(getOwner(), getEntryType(), getChannelName(), VirtualEntry::canRemove);
+            VirtualEnderRegistry.get((ServerLevel) coverHolder.getLevel())
+                    .tryDeleteEntry(getOwner(), getEntryType(), getColorStr());
         }
     }
 
-    @Override
-    public void onUIClosed() {
-        virtualEntryWidget = null;
-    }
-
     @Override
     public void setWorkingEnabled(boolean isWorkingAllowed) {
         if (this.isWorkingEnabled != isWorkingAllowed) {
@@ -128,12 +110,6 @@ public void setWorkingEnabled(boolean isWorkingAllowed) {
         }
     }
 
-    @Override
-    public Widget createUIWidget() {
-        virtualEntryWidget = new VirtualEntryWidget(this);
-        return virtualEntryWidget;
-    }
-
     public void setIo(IO io) {
         if (io == IO.IN || io == IO.OUT) {
             this.io = io;
@@ -142,104 +118,95 @@ public void setIo(IO io) {
         }
     }
 
-    public UUID getOwner() {
+    public @Nullable UUID getOwner() {
         if (permission == Permissions.PRIVATE && coverHolder instanceof MachineCoverContainer mcc) {
             var owner = mcc.getMachine().getOwner();
             return owner != null ? owner.getPlayerUUID() : null;
         }
+        if (permission == Permissions.PROTECTED && coverHolder instanceof MachineCoverContainer mcc) {
+            var owner = mcc.getMachine().getOwner();
+            return owner != null ? owner.getUUID() : null;
+        }
         return null;
     }
 
-    protected boolean isSubscriptionActive() {
-        return isWorkingEnabled();
-    }
+    protected @Nullable abstract VirtualEntry getEntry();
 
-    protected abstract String identifier();
+    protected abstract void setEntry(VirtualEntry entry);
 
-    protected abstract VirtualEntry getEntry();
+    protected abstract EntryTypes<T> getEntryType();
 
-    protected abstract void setEntry(VirtualEntry entry);
+    protected abstract void transfer();
 
-    protected final String getChannelName() {
-        return identifier() + this.colorStr;
+    /**
+     * All syncers registered through this method MUST use the {@link PanelSyncManager#getOrCreateSyncHandler} method
+     * for applying a syncer to a widget because it gets placed into a {@link DynamicSyncedWidget}.
+     *
+     * @return A widget to represent the entry type for this cover
+     */
+    protected abstract IWidget createVirtualEntryWidget(PanelSyncManager manager, VirtualEntry entry, int w, int h,
+                                                        int idx);
+
+    @Nullable
+    protected FilterHandler<?, ?> getFilterHandler() {
+        return null;
     }
 
-    protected void setChannelName(String name) {
+    protected void setColorStr(String str) {
         if (isRemote()) return;
-        VirtualEnderRegistry.getInstance().deleteEntryIf(getOwner(), getEntryType(), getChannelName(),
-                VirtualEntry::canRemove);
-        this.colorStr = name;
+        if (str.length() != 8) str = str.concat("F".repeat(8 - str.length()));
+        VirtualEnderRegistry.get((ServerLevel) coverHolder.getLevel()).tryDeleteEntry(getOwner(), getEntryType(),
+                getColorStr());
+        this.colorStr = str;
         syncDataHolder.markClientSyncFieldDirty("colorStr");
         setVirtualEntry();
     }
 
-    protected final String getChannelName(VirtualEntry entry) {
-        return identifier() + entry.getColorStr();
-    }
-
     protected void setPermission(Permissions permission) {
         if (isRemote()) return;
-        VirtualEnderRegistry.getInstance().deleteEntryIf(getOwner(), getEntryType(), getChannelName(),
-                VirtualEntry::canRemove);
+        VirtualEnderRegistry.get((ServerLevel) coverHolder.getLevel()).tryDeleteEntry(getOwner(), getEntryType(),
+                getColorStr());
         this.permission = permission;
         syncDataHolder.markClientSyncFieldDirty("permission");
-
         setVirtualEntry();
     }
 
     protected void setVirtualEntry() {
-        setEntry(VirtualEnderRegistry.getInstance().getOrCreateEntry(getOwner(), getEntryType(), getChannelName()));
-        getEntry().setColor(this.colorStr);
-        syncDataHolder.markClientSyncFieldDirty("isAnyChanged");
-        this.isAnyChanged = true;
+        setEntry(VirtualEnderRegistry.get((ServerLevel) coverHolder.getLevel()).getOrCreateEntry(getOwner(),
+                getEntryType(), getColorStr()));
+        Objects.requireNonNull(getEntry()).setColor(this.colorStr);
         subscriptionHandler.updateSubscription();
     }
 
-    protected abstract EntryTypes<T> getEntryType();
-
     protected void update() {
         long timer = coverHolder.getOffsetTimer();
         if (timer % 5 != 0) return;
 
         if (isWorkingEnabled() && !isRemote()) {
-            var entry = VirtualEnderRegistry.getInstance().getOrCreateEntry(getOwner(), getEntryType(),
-                    getChannelName());
+            var entry = VirtualEnderRegistry.get((ServerLevel) coverHolder.getLevel()).getOrCreateEntry(getOwner(),
+                    getEntryType(), getColorStr());
             if (!entry.getColorStr().equals(this.colorStr)) {
                 entry.setColor(this.colorStr);
             }
-            if (!getEntry().equals(entry)) {
+            if (!Objects.equals(getEntry(), entry)) {
                 setEntry(entry);
             }
             transfer();
         }
 
-        if (isAnyChanged) {
-            if (virtualEntryWidget != null) virtualEntryWidget.update();
-            isAnyChanged = false;
-        }
         subscriptionHandler.updateSubscription();
     }
 
-    protected abstract void transfer();
-
-    protected void setManualIOMode(ManualIOMode manualIOMode) {
-        this.manualIOMode = manualIOMode;
-        syncDataHolder.markClientSyncFieldDirty("manualIOMode");
-        subscriptionHandler.updateSubscription();
+    protected int getColor() {
+        return VirtualEntry.parseColor(this.colorStr);
     }
 
-    @Nullable
-    protected FilterHandler<?, ?> getFilterHandler() {
-        return null;
+    private String getDescription() {
+        return getEntry() == null ? "null" : getEntry().getDescription();
     }
 
-    protected abstract Widget addVirtualEntryWidget(VirtualEntry entry, int x, int y, int width, int height,
-                                                    boolean canClick);
-
-    protected abstract String getUITitle();
-
-    protected int getColor() {
-        return VirtualEntry.parseColor(this.colorStr);
+    private void setDescription(String description) {
+        if (getEntry() != null) getEntry().setDescription(description);
     }
 
     @Override
@@ -247,285 +214,196 @@ public CompoundTag copyConfig(CompoundTag tag) {
         tag.putString("colorStr", colorStr);
         tag.putInt("permission", getPermission().ordinal());
         tag.putInt("io", getIo().ordinal());
-        tag.putInt("manualIO", getManualIOMode().ordinal());
         return super.copyConfig(tag);
     }
 
     @Override
     public void pasteConfig(ServerPlayer player, CompoundTag tag) {
-        setChannelName(tag.getString("colorStr"));
+        setColorStr(tag.getString("colorStr"));
         setPermission(Permissions.values()[tag.getInt("permission")]);
         setIo(IO.values()[tag.getInt("io")]);
-        setManualIOMode(ManualIOMode.values()[tag.getInt("manualIO")]);
         super.pasteConfig(player, tag);
     }
 
-    protected enum Permissions implements EnumSelectorWidget.SelectableEnum {
+    private List<VirtualEntry> getVirtualEntries() {
+        return VirtualEnderRegistry.get((ServerLevel) coverHolder.getLevel()).getEntries(getOwner(), getEntryType())
+                .values().stream().toList();
+    }
 
-        PUBLIC("cover.ender_fluid_link.private.tooltip.disabled",
-                GuiTextures.BUTTON_PUBLIC_PRIVATE.getSubTexture(0, 0, 1, 0.5)),
+    protected enum Permissions {
 
-        PRIVATE("cover.ender_fluid_link.private.tooltip.enabled",
-                GuiTextures.BUTTON_PUBLIC_PRIVATE.getSubTexture(0, 0.5, 1, 0.5));
+        PUBLIC("cover.ender_link.public.tooltip"),
+        PROTECTED("cover.ender_link.protected.tooltip"),
+        PRIVATE("cover.ender_link.private.tooltip");
 
         @Getter
         private final String tooltip;
-        @Getter
-        private final IGuiTexture icon;
 
-        Permissions(String tooltip, IGuiTexture icon) {
+        Permissions(String tooltip) {
             this.tooltip = tooltip;
-            this.icon = icon;
         }
     }
 
-    protected static class VirtualEntryWidget extends WidgetGroup {
-
-        private static final int WIDGET_BOARD = 20;
-        private static final int GROUP_WIDTH = 176;
-        private static final int TOTAL_WIDTH = 156;
-        private static final int BUTTON_SIZE = 16;
-        private final AbstractEnderLinkCover<?> cover;
-        private final MutableBoolean showChannels;
-        private final WidgetGroup mainGroup;
-        private final WidgetGroup mainChannelGroup;
-        private final DraggableScrollableWidgetGroup channelsGroup; // client only
-
-        VirtualEntryWidget(AbstractEnderLinkCover<?> cover) {
-            super(0, 0, GROUP_WIDTH, 137);
-            this.cover = cover;
-            this.showChannels = new MutableBoolean(false);
-            mainGroup = new WidgetGroup(0, 0, GROUP_WIDTH, 137);
-            channelsGroup = new DraggableScrollableWidgetGroup(0, 20, 170, 110)
-                    .setYScrollBarWidth(2).setYBarStyle(null, ColorPattern.T_WHITE.rectTexture().setRadius(1));
-            mainChannelGroup = new WidgetGroup(10, 20, 156, 20);
-            initWidgets();
-        }
-
-        public void update() {
-            if (isRemote()) return;
-            widgets.clear();
-            mainGroup.widgets.clear();
-            channelsGroup.widgets.clear();
-            mainChannelGroup.widgets.clear();
-            initWidgets();
-            this.detectAndSendChanges();
-        }
-
-        private void initWidgets() {
-            int currentX = 0;
-            final var titleGroup = new WidgetGroup(10, 5, GROUP_WIDTH, 20);
-
-            this.addWidget(titleGroup);
-            this.addWidget(mainGroup);
-            this.addWidget(channelsGroup.setVisible(false));
-
-            titleGroup.addWidget(createToggleButton());
-            titleGroup.addWidget(new LabelWidget(15, 3, cover.getUITitle()));
-
-            var toggleButtonWidget = createToggleButtonForPrivacy(currentX);
-            mainChannelGroup.addWidget(toggleButtonWidget);
-            currentX += WIDGET_BOARD + 2;
-            mainChannelGroup.addWidget(createColorBlockWidget(currentX));
-            currentX += WIDGET_BOARD + 2;
-            mainChannelGroup.addWidget(createConfirmTextInputWidget(currentX));
-
-            mainChannelGroup.addWidget(new ConfirmTextInputWidget(0, WIDGET_BOARD + 2, GROUP_WIDTH - WIDGET_BOARD,
-                    WIDGET_BOARD, cover.getEntry().getDescription(), cover.getEntry()::setDescription,
-                    t -> t == null ? "" : t, null).setTooltip("cover.ender_fluid_link.tooltip.channel_description"));
-
-            mainGroup.addWidget(mainChannelGroup);
-            mainGroup.addWidget(createWorkingEnabledButton());
-            addEnumSelectorWidgets();
-            mainGroup.addWidget(
-                    cover.addVirtualEntryWidget(cover.getEntry(), 146, WIDGET_BOARD, WIDGET_BOARD, WIDGET_BOARD, true));
-
-            if (cover.getFilterHandler() != null) {
-                mainGroup.addWidget(cover.getFilterHandler().createFilterSlotUI(117, 108));
-                mainGroup.addWidget(cover.getFilterHandler().createFilterConfigUI(10, 72, 156, 60));
-            }
-        }
-
-        @Contract(" -> new")
-        private @NotNull ToggleButtonWidget createToggleButton() {
-            return (ToggleButtonWidget) new ToggleButtonWidget(0, 0, 12, 12, showChannels::getValue, cd -> {
-                showChannels.setValue(!showChannels.getValue());
-                mainGroup.setVisible(showChannels.isFalse());
-                channelsGroup.setVisible(showChannels.isTrue());
-                requestUpdate();
-            }).setTexture(
-                    new GuiTextureGroup(GuiTextures.TOGGLE_BUTTON_BACK.getSubTexture(0, 0, 1, 0.5),
-                            GuiTextures.BUTTON_LIST),
-                    new GuiTextureGroup(GuiTextures.TOGGLE_BUTTON_BACK.getSubTexture(0, 0.5, 1, 0.5),
-                            GuiTextures.BUTTON_LIST))
-                    .setHoverTooltips("cover.ender_fluid_link.tooltip.list_button");
-        }
-
-        @Contract("_ -> new")
-        private @NotNull Widget createToggleButtonForPrivacy(int currentX) {
-            return new EnumSelectorWidget<>(currentX, 0,
-                    WIDGET_BOARD, WIDGET_BOARD, Permissions.values(), cover.permission, cover::setPermission);
-        }
-
-        private ColorBlockWidget createColorBlockWidget(int currentX) {
-            return new ColorBlockWidget(currentX, 0, WIDGET_BOARD, WIDGET_BOARD).setColorSupplier(cover::getColor);
-        }
+    @Override
+    public void createCoverUIRows(Flow column, SidedPosGuiData data, PanelSyncManager syncManager,
+                                  UISettings settings) {
+        var channelManager = syncManager.syncedPanel("channelManager", true,
+                (sm, sh) -> createChannelManagerPanel(data, sm, settings));
+
+        var colorSyncer = new IntSyncValue(this::getColor);
+        EnumSyncValue<IO> ioSync = new EnumSyncValue<>(IO.class, this::getIo, this::setIo);
+
+        syncManager.syncValue("io", ioSync);
+        syncManager.syncValue("color", colorSyncer);
+
+        var currentEntry = GenericSyncValue.builder(VirtualEntry.class)
+                .getter(this::getEntry)
+                .adapter(new VirtualEntryAdapter()).build();
+        syncManager.syncValue("currentEntry", currentEntry);
+
+        DynamicLinkedSyncHandler<GenericSyncValue<VirtualEntry>> dynamicLinkedSyncHandler = new DynamicLinkedSyncHandler<>(
+                currentEntry)
+                .widgetProvider((manager, entriesListSyncer) -> createVirtualEntryWidget(manager,
+                        entriesListSyncer.getValue(), 18, 18, 0));
+
+        column.child(coverUIRow()
+                .child(createColorBlock(colorSyncer::getIntValue, 18).asWidget().size(18))
+                .child(new CycleButtonWidget()
+                        .stateCount(3)
+                        .stateOverlay(Permissions.PUBLIC, GTGuiTextures.PRIVATE_MODE_BUTTON[0])
+                        .stateOverlay(Permissions.PROTECTED, GTGuiTextures.PRIVATE_MODE_BUTTON[0])
+                        .stateOverlay(Permissions.PRIVATE, GTGuiTextures.PRIVATE_MODE_BUTTON[1])
+                        .tooltip(0, t -> t.addLine(IKey.lang(Permissions.PUBLIC.tooltip)))
+                        .tooltip(1, t -> t.addLine(IKey.lang(Permissions.PROTECTED.tooltip)))
+                        .tooltip(2, t -> t.addLine(IKey.lang(Permissions.PRIVATE.tooltip)))
+                        .value(new EnumSyncValue<>(Permissions.class, this::getPermission,
+                                this::setPermission)))
+                .child(new TextFieldWidget()
+                        .value(new StringSyncValue(this::getColorStr, this::setColorStr))
+                        .setMaxLength(8)
+                        .setValidator(str -> COLOR_INPUT_PATTERN.matcher(str).replaceAll(""))
+                        .addTooltipLine(IKey.lang(Component.translatable("cover.ender_link.tooltip.channel_name"))))
+                .child(new DynamicSyncedWidget<>().syncHandler(dynamicLinkedSyncHandler))
+                .child(new ButtonWidget<>().onMousePressed((x, y, b) -> {
+                    channelManager.openPanel();
+                    return true;
+                }).posRel(Alignment.CenterRight).tooltip(new RichTooltip()
+                        .addLine(IKey.lang(Component.translatable("cover.ender_link.tooltip.list_button"))))));
+
+        column.child(coverUIRow().child(new TextFieldWidget()
+                .setMaxLength(32)
+                .widthRel(1f)
+                .addTooltipLine(IKey.lang(Component.translatable("cover.ender_link.tooltip.channel_description")))
+                .value(new StringSyncValue(this::getDescription, this::setDescription))));
+
+        Flow bottomRow = coverUIRow();
+        bottomRow.child(GTMuiWidgets.createPowerButton(this));
+        bottomRow.child(GTMuiWidgets.createIOCycleButton(ioSync, false));
+        if (getFilterHandler() != null)
+            GTMuiWidgets.createFilterRow(bottomRow, getFilterHandler(), data, syncManager, settings);
+        column.child(bottomRow);
+    }
 
-        private ConfirmTextInputWidget createConfirmTextInputWidget(int currentX) {
-            int GROUP_X = 10;
-            int textInputWidth = (GROUP_WIDTH - GROUP_X * 2) - currentX - WIDGET_BOARD - 2;
-            return new ConfirmTextInputWidget(currentX, 0, textInputWidth, WIDGET_BOARD, cover.colorStr,
-                    cover::setChannelName, text -> {
-                        if (text == null || !COLOR_INPUT_PATTERN.matcher(text).matches()) {
-                            return VirtualTank.DEFAULT_COLOR;
-                        }
-                        return text;
-                    }, text -> {
-                        if (text.length() < 8) {
-                            text += "F".repeat(8 - text.length());
-                        }
-                        return text;
-                    }).setTooltip("cover.ender_fluid_link.tooltip.channel_name");
+    protected ParentWidget<?> getChannelStatusRowShort(PanelSyncManager syncManager, VirtualEntry entry, int idx) {
+        TextWidget<?> str;
+        if (entry.getDescription().isBlank()) {
+            str = IKey.lang(Component.translatable("cover.ender_link.description_empty")).asWidget().size(98, 12)
+                    .color(Color.GREY.darker(1));
+        } else {
+            str = IKey.str(entry.getDescription()).asWidget().size(98, 12);
         }
+        return coverUIRow()
+                .child(createColorBlock(entry::getColor, 18).asWidget()
+                        .tooltip(t -> t.addLine(entry.getColorStr()))
+                        .size(18, 18))
+                .child(str)
+                .child(createVirtualEntryWidget(syncManager, entry, 18, 18, idx))
+                .child(new ButtonWidget<>().overlay(GTGuiTextures.BUTTON_CROSS).onMousePressed((x, y, button) -> {
+                    MouseData mouseData = MouseData.create(button);
+                    if (mouseData.mouseButton() == 1) {
+                        syncManager.callSyncedAction("deleteEntry",
+                                buffer -> buffer.writeCharSequence(entry.getColorStr(), StandardCharsets.UTF_8));
+                        return true;
+                    }
+                    return false;
+                }).posRel(Alignment.CenterRight));
+    }
 
-        @Contract(" -> new")
-        private @NotNull ToggleButtonWidget createWorkingEnabledButton() {
-            return new ToggleButtonWidget(116, 82, WIDGET_BOARD, WIDGET_BOARD, GuiTextures.BUTTON_POWER,
-                    cover::isWorkingEnabled, cover::setWorkingEnabled);
-        }
+    public IDrawable createColorBlock(IntSupplier colorSupplier, int size) {
+        return IDrawable.of(
+                // Border
+                (context, x, y, w, h, widgetTheme) -> new Rectangle().color(Color.BLACK.main)
+                        .draw(context, x, y, size, size, widgetTheme),
+                // Colored block
+                (context, x, y, w, h, widgetTheme) -> new Rectangle().color(colorSupplier.getAsInt())
+                        .draw(context, x + 1, y + 1, size - 2, size - 2, widgetTheme));
+    }
 
-        private void addEnumSelectorWidgets() {
-            mainGroup.addWidget(new EnumSelectorWidget<>(146, 82, WIDGET_BOARD, WIDGET_BOARD, List.of(IO.IN, IO.OUT),
-                    cover.io, cover::setIo));
-            mainGroup.addWidget(new EnumSelectorWidget<>(146, 107, WIDGET_BOARD, WIDGET_BOARD, ManualIOMode.VALUES,
-                    cover.manualIOMode, cover::setManualIOMode)
-                    .setHoverTooltips("cover.universal.manual_import_export.mode.description"));
-        }
+    protected ModularPanel<?> createChannelManagerPanel(GuiData data, PanelSyncManager syncManager,
+                                                        UISettings settings) {
+        var panel = new Dialog<>("channel_manager")
+                .disablePanelsBelow(false)
+                .draggable(true)
+                .closeOnOutOfBoundsClick(true)
+                .child(GTMuiWidgets.createTitleBar(getAttachItem(), 176, GTGuiTextures.BACKGROUND));
+
+        var entries = new GenericListSyncHandler.Builder<VirtualEntry>()
+                .getter(this::getVirtualEntries)
+                .adapter(new VirtualEntryAdapter())
+                .build();
+        syncManager.syncValue("entries", entries);
+
+        DynamicLinkedSyncHandler<GenericListSyncHandler<VirtualEntry>> dynamicLinkedSyncHandler = new DynamicLinkedSyncHandler<>(
+                entries)
+                .widgetProvider((manager, entriesListSyncer) -> {
+                    if (entriesListSyncer == null || entriesListSyncer.getValue() == null) return new EmptyWidget();
+                    ListWidget<IWidget, ?> list = new ListWidget<>();
+                    List<VirtualEntry> entryList = entriesListSyncer.getValue();
+                    for (int i = 0; i < entryList.size(); i++) {
+                        list.child(getChannelStatusRowShort(manager, entryList.get(i), i));
+                    }
+                    return list.childSeparator(GTGuiTextures.SEPERATOR_SIMPLE.asIcon().size(116, 5).margin(12, 0))
+                            .size(162, 154);
+                });
 
-        private void addChannelWidgets(List<? extends VirtualEntry> entries) {
-            channelsGroup.clearAllWidgets();
-            int y = 1;
-            SelectableWidgetGroup selectedWidget = null;
-            for (var entry : entries.stream().sorted(Comparator.comparing(VirtualEntry::getColorStr)).toList()) {
-                SelectableWidgetGroup channelWidget = createChannelWidget(entry, 10, y);
-                if (cover.getChannelName(entry).equals(cover.getChannelName())) {
-                    selectedWidget = channelWidget;
-                }
-                channelsGroup.addWidget(channelWidget);
-                y += 22;
+        syncManager.registerServerSyncedAction("deleteEntry", (packet) -> {
+            var colorString = packet.readCharSequence(8, StandardCharsets.UTF_8).toString();
+            VirtualEntry entry = VirtualEnderRegistry.get((ServerLevel) coverHolder.getLevel()).getEntry(getOwner(),
+                    getEntryType(), colorString);
+            if (entry != null) {
+                entry.setDescription("");
+                VirtualEnderRegistry.get((ServerLevel) coverHolder.getLevel()).tryDeleteEntry(getOwner(),
+                        getEntryType(), colorString);
             }
-            channelsGroup.setSelected(selectedWidget);
-            if (selectedWidget != null) selectedWidget.onSelected();
-            channelsGroup.setClientSideWidget();
-        }
+        });
 
-        private @NotNull SelectableWidgetGroup createChannelWidget(@NotNull VirtualEntry entry, int x, int y) {
-            int currentX = 0;
-            int MARGIN = 2;
-            int availableWidth = TOTAL_WIDTH - (BUTTON_SIZE + MARGIN) * 3;
-
-            final MutableBoolean canSelect = new MutableBoolean(false);
-            var des = entry.getDescription();
-            TextBoxWidget textBoxWidget = new TextBoxWidget(BUTTON_SIZE + MARGIN,
-                    !des.isEmpty() ? 0 : 4, availableWidth, List.of(entry.getColorStr())).setCenter(true);
-            SelectableWidgetGroup channelGroup = new SelectableWidgetGroup(x, y, TOTAL_WIDTH, BUTTON_SIZE) {
-
-                @Override
-                public boolean allowSelected(double mouseX, double mouseY, int button) {
-                    return canSelect.getValue() && super.allowSelected(mouseX, mouseY, button);
-                }
-            };
-            channelGroup.setOnSelected(group -> {
-                if (cover.getChannelName().equals(cover.getChannelName(entry))) return;
-                writeClientAction(0, buffer -> {
-                    // send new channel name to server
-                    String newChannelColorStr = entry.getColorStr();
-                    buffer.writeUtf(newChannelColorStr);
-                });
-                playButtonClickSound();
-            }).setSelectedTexture(1, -1);
-
-            // Color block
-            ColorBlockWidget colorBlockWidget = new ColorBlockWidget(currentX, 0, BUTTON_SIZE, BUTTON_SIZE)
-                    .setCurrentColor(VirtualEntry.parseColor(entry.getColorStr()));
-            channelGroup.addWidget(colorBlockWidget);
-            currentX += BUTTON_SIZE + MARGIN;
-
-            // Text box
-            channelGroup.addWidget(textBoxWidget);
-            currentX += availableWidth + MARGIN;
-            if (!des.isEmpty()) {
-                var desText = new TextTexture(ChatFormatting.DARK_GRAY + des).setDropShadow(false);
-                desText.setType(TextTexture.TextType.ROLL).setRollSpeed(0.7f);
-                channelGroup.addWidget(new ImageWidget(BUTTON_SIZE + MARGIN, 10, availableWidth, 8, desText));
-            }
+        panel.child(new DynamicSyncedWidget<>()
+                .syncHandler(dynamicLinkedSyncHandler)
+                .top(7).margin(7, 0)
+                .widthRel(1.0f).coverChildrenHeight());
 
-            // Slot
-            Widget slotWidget = cover.addVirtualEntryWidget(entry, currentX, 0, BUTTON_SIZE, BUTTON_SIZE, false);
-            channelGroup.addWidget(slotWidget);
-            currentX += BUTTON_SIZE + MARGIN;
-
-            // Clear Description button
-            channelGroup.addWidget(
-                    new ButtonWidget(currentX, 0, BUTTON_SIZE, BUTTON_SIZE, GuiTextures.BUTTON_CLEAR_GRID, press -> {
-                        writeClientAction(200, buffer -> buffer.writeUtf(cover.getChannelName(entry)));
-                        requestUpdate();
-                    }) {
-
-                        @Override
-                        public boolean isMouseOverElement(double mouseX, double mouseY) {
-                            var isOver = super.isMouseOverElement(mouseX, mouseY);
-                            if (canSelect.getValue() == isOver) canSelect.setValue(!isOver);
-                            return isOver;
-                        }
-                    }.appendHoverTooltips("cover.ender_fluid_link.tooltip.clear_button"));
-
-            return channelGroup;
-        }
+        return panel;
+    }
+
+    private class VirtualEntryAdapter implements IByteBufAdapter<VirtualEntry> {
 
-        private void requestUpdate() {
-            writeClientAction(100, buffer -> buffer.writeBoolean(showChannels.isTrue()));
+        @Override
+        public VirtualEntry deserialize(FriendlyByteBuf buffer) {
+            VirtualEntry entry = getEntryType().createInstance();
+            var nbt = buffer.readNbt();
+            if (nbt == null) return entry;
+            entry.deserializeNBT(nbt);
+            return entry;
         }
 
         @Override
-        public void handleClientAction(int id, FriendlyByteBuf buffer) {
-            super.handleClientAction(id, buffer);
-            if (id == 0) {
-                String newChannelColorStr = buffer.readUtf();
-                cover.setChannelName(newChannelColorStr);
-            } else if (id == 100) {
-                if (!buffer.readBoolean()) return;
-                var entries = VirtualEnderRegistry.getInstance().getEntryNames(cover.getOwner(), cover.getEntryType())
-                        .stream().map(name -> VirtualEnderRegistry.getInstance().getEntry(cover.getOwner(),
-                                cover.getEntryType(), name))
-                        .sorted(Comparator.comparing(VirtualEntry::getColorStr));
-                writeUpdateInfo(101, buf -> {
-                    var list = entries.toList();
-                    buf.writeVarInt(list.size());
-                    for (var entry : list) {
-                        buf.writeNbt(entry.serializeNBT());
-                    }
-                });
-            } else if (id == 200) {
-                String channelName = buffer.readUtf();
-                VirtualEnderRegistry.getInstance().getEntry(cover.getOwner(), cover.getEntryType(), channelName)
-                        .setDescription("");
-            }
+        public void serialize(FriendlyByteBuf buffer, VirtualEntry entry) {
+            buffer.writeNbt(entry.serializeNBT());
         }
 
         @Override
-        public void readUpdateInfo(int id, FriendlyByteBuf buffer) {
-            super.readUpdateInfo(id, buffer);
-            if (id == 101) {
-                int size = buffer.readVarInt();
-                List<VirtualEntry> entries = new ArrayList<>();
-                for (int i = 0; i < size; i++) {
-                    VirtualEntry entry = cover.getEntryType().createInstance();
-                    entry.deserializeNBT(Objects.requireNonNull(buffer.readNbt()));
-                    entries.add(entry);
-                }
-                addChannelWidgets(entries);
-            }
+        public boolean areEqual(VirtualEntry t1, VirtualEntry t2) {
+            return t1.getColor() == t2.getColor() && t1.getDescription().equals(t2.getDescription());
         }
     }
 }
diff --git a/src/main/java/com/gregtechceu/gtceu/common/cover/ender/EnderFluidLinkCover.java b/src/main/java/com/gregtechceu/gtceu/common/cover/ender/EnderFluidLinkCover.java
index 06a37824d13..3c90e558dec 100644
--- a/src/main/java/com/gregtechceu/gtceu/common/cover/ender/EnderFluidLinkCover.java
+++ b/src/main/java/com/gregtechceu/gtceu/common/cover/ender/EnderFluidLinkCover.java
@@ -5,10 +5,7 @@
 import com.gregtechceu.gtceu.api.cover.filter.FilterHandler;
 import com.gregtechceu.gtceu.api.cover.filter.FilterHandlers;
 import com.gregtechceu.gtceu.api.cover.filter.FluidFilter;
-import com.gregtechceu.gtceu.api.gui.GuiTextures;
-import com.gregtechceu.gtceu.api.gui.widget.TankWidget;
 import com.gregtechceu.gtceu.api.misc.virtualregistry.EntryTypes;
-import com.gregtechceu.gtceu.api.misc.virtualregistry.VirtualEnderRegistry;
 import com.gregtechceu.gtceu.api.misc.virtualregistry.VirtualEntry;
 import com.gregtechceu.gtceu.api.misc.virtualregistry.entries.VirtualTank;
 import com.gregtechceu.gtceu.api.sync_system.annotations.SaveField;
@@ -16,8 +13,6 @@
 import com.gregtechceu.gtceu.api.transfer.fluid.IFluidHandlerModifiable;
 import com.gregtechceu.gtceu.utils.GTTransferUtils;
 
-import com.lowdragmc.lowdraglib.gui.widget.*;
-
 import net.minecraft.core.Direction;
 import net.minecraft.nbt.CompoundTag;
 import net.minecraft.server.level.ServerPlayer;
@@ -25,8 +20,13 @@
 import net.minecraftforge.fluids.FluidStack;
 import net.minecraftforge.fluids.FluidUtil;
 
+import brachy.modularui.api.widget.IWidget;
+import brachy.modularui.value.sync.FluidSlotSyncHandler;
+import brachy.modularui.value.sync.PanelSyncManager;
+import brachy.modularui.value.sync.SyncHandlers;
+import brachy.modularui.widget.ParentWidget;
+import brachy.modularui.widgets.slot.FluidSlot;
 import lombok.Getter;
-import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 
 import java.util.List;
@@ -38,9 +38,7 @@ public class EnderFluidLinkCover extends AbstractEnderLinkCover<VirtualTank> {
 
     public static final int TRANSFER_RATE = 8000; // mB/t
 
-    @SaveField
-    @SyncToClient
-    protected VirtualTank visualTank;
+    protected VirtualTank visualTank = new VirtualTank();
 
     @Getter
     @SaveField
@@ -52,8 +50,6 @@ public EnderFluidLinkCover(CoverDefinition definition, ICoverable coverHolder, D
         super(definition, coverHolder, attachedSide);
         this.mBLeftToTransferLastSecond = TRANSFER_RATE * 20;
         filterHandler = FilterHandlers.fluid(this);
-        if (!isRemote()) setEntry(VirtualEnderRegistry.getInstance()
-                .getOrCreateEntry(getOwner(), EntryTypes.ENDER_FLUID, getChannelName()));
     }
 
     @Override
@@ -77,11 +73,6 @@ protected EntryTypes<VirtualTank> getEntryType() {
         return EntryTypes.ENDER_FLUID;
     }
 
-    @Override
-    protected String identifier() {
-        return "EFLink#";
-    }
-
     @Override
     protected void transfer() {
         long timer = coverHolder.getOffsetTimer();
@@ -99,6 +90,19 @@ protected void transfer() {
         return coverHolder.getFluidHandlerCap(attachedSide, false);
     }
 
+    @Override
+    protected IWidget createVirtualEntryWidget(PanelSyncManager manager, VirtualEntry entry, int w, int h, int index) {
+        if (!(entry instanceof VirtualTank tank)) return new ParentWidget<>().size(w, h);
+
+        manager.getOrCreateSyncHandler("ender_link_cover_fluid_slot", index, FluidSlotSyncHandler.class,
+                () -> SyncHandlers.fluidSlot(tank.getFluidTank()));
+
+        return new FluidSlot()
+                .syncHandler("ender_link_cover_fluid_slot", index)
+                .marginLeft(3)
+                .size(w, h);
+    }
+
     private int doTransferFluids(int platformTransferLimit) {
         var ownFluidHandler = getOwnFluidHandler();
 
@@ -128,27 +132,11 @@ public void pasteConfig(ServerPlayer player, CompoundTag tag) {
     }
 
     @Override
-    public @NotNull List<ItemStack> getAdditionalDrops() {
+    public List<ItemStack> getAdditionalDrops() {
         var list = super.getAdditionalDrops();
         if (!filterHandler.getFilterItem().isEmpty()) {
             list.add(filterHandler.getFilterItem());
         }
         return list;
     }
-
-    //////////////////////////////////////
-    // ************ GUI ************ //
-    //////////////////////////////////////
-
-    @Override
-    protected Widget addVirtualEntryWidget(VirtualEntry entry, int x, int y, int width, int height, boolean canClick) {
-        return new TankWidget(((VirtualTank) entry).getFluidTank(), 0, x, y, width, height, canClick, canClick)
-                .setBackground(GuiTextures.FLUID_SLOT);
-    }
-
-    @NotNull
-    @Override
-    protected String getUITitle() {
-        return "cover.ender_fluid_link.title";
-    }
 }
diff --git a/src/main/java/com/gregtechceu/gtceu/common/cover/ender/EnderItemLinkCover.java b/src/main/java/com/gregtechceu/gtceu/common/cover/ender/EnderItemLinkCover.java
index 98f1175a0b1..59ae4d8381a 100644
--- a/src/main/java/com/gregtechceu/gtceu/common/cover/ender/EnderItemLinkCover.java
+++ b/src/main/java/com/gregtechceu/gtceu/common/cover/ender/EnderItemLinkCover.java
@@ -5,9 +5,7 @@
 import com.gregtechceu.gtceu.api.cover.filter.FilterHandler;
 import com.gregtechceu.gtceu.api.cover.filter.FilterHandlers;
 import com.gregtechceu.gtceu.api.cover.filter.ItemFilter;
-import com.gregtechceu.gtceu.api.gui.widget.SlotWidget;
 import com.gregtechceu.gtceu.api.misc.virtualregistry.EntryTypes;
-import com.gregtechceu.gtceu.api.misc.virtualregistry.VirtualEnderRegistry;
 import com.gregtechceu.gtceu.api.misc.virtualregistry.VirtualEntry;
 import com.gregtechceu.gtceu.api.misc.virtualregistry.entries.VirtualItemStorage;
 import com.gregtechceu.gtceu.api.sync_system.SyncDataHolder;
@@ -15,17 +13,18 @@
 import com.gregtechceu.gtceu.api.sync_system.annotations.SyncToClient;
 import com.gregtechceu.gtceu.utils.GTTransferUtils;
 
-import com.lowdragmc.lowdraglib.gui.widget.Widget;
-import com.lowdragmc.lowdraglib.gui.widget.WidgetGroup;
-
 import net.minecraft.core.Direction;
 import net.minecraft.nbt.CompoundTag;
 import net.minecraft.server.level.ServerPlayer;
 import net.minecraft.world.item.ItemStack;
 import net.minecraftforge.items.IItemHandler;
 
+import brachy.modularui.api.widget.IWidget;
+import brachy.modularui.value.sync.PanelSyncManager;
+import brachy.modularui.widget.ParentWidget;
+import brachy.modularui.widgets.slot.ItemSlot;
+import brachy.modularui.widgets.slot.ModularSlot;
 import lombok.Getter;
-import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 
 import java.util.List;
@@ -37,9 +36,7 @@ public class EnderItemLinkCover extends AbstractEnderLinkCover<VirtualItemStorag
 
     protected static final int TRANSFER_RATE = 8;
 
-    @SaveField
-    @SyncToClient
-    protected VirtualItemStorage storage;
+    protected VirtualItemStorage storage = new VirtualItemStorage();
     protected int itemsLeftToTransferLastSecond;
     @Getter
     @SaveField
@@ -50,8 +47,6 @@ public EnderItemLinkCover(CoverDefinition definition, ICoverable coverHolder, Di
         super(definition, coverHolder, attachedSide);
         itemsLeftToTransferLastSecond = TRANSFER_RATE * 20;
         filterHandler = FilterHandlers.item(this);
-        if (!isRemote()) setEntry(VirtualEnderRegistry.getInstance().getOrCreateEntry(getOwner(), EntryTypes.ENDER_ITEM,
-                getChannelName()));
     }
 
     @Override
@@ -59,11 +54,6 @@ public boolean canAttach() {
         return true;
     }
 
-    @Override
-    protected String identifier() {
-        return "EILink#";
-    }
-
     @Override
     protected VirtualItemStorage getEntry() {
         return storage;
@@ -101,6 +91,17 @@ private int doTransferItems(int max) {
         };
     }
 
+    @Override
+    protected IWidget createVirtualEntryWidget(PanelSyncManager manager, VirtualEntry entry, int w, int h, int index) {
+        if (!(entry instanceof VirtualItemStorage itemStorage)) return new ParentWidget<>().size(w, h);
+        manager.getOrCreateSlot("ender_item_link_cover_" + index, 0,
+                () -> new ModularSlot(itemStorage.getHandler(), 0));
+        return new ItemSlot()
+                .syncHandler("ender_item_link_cover_" + index)
+                .marginLeft(3)
+                .size(w, h);
+    }
+
     public @Nullable IItemHandler getOwnItemHandler() {
         return coverHolder.getItemHandlerCap(attachedSide, false);
     }
@@ -118,25 +119,11 @@ public void pasteConfig(ServerPlayer player, CompoundTag tag) {
     }
 
     @Override
-    public @NotNull List<ItemStack> getAdditionalDrops() {
+    public List<ItemStack> getAdditionalDrops() {
         var list = super.getAdditionalDrops();
         if (!filterHandler.getFilterItem().isEmpty()) {
             list.add(filterHandler.getFilterItem());
         }
         return list;
     }
-
-    @Override
-    protected Widget addVirtualEntryWidget(VirtualEntry entry, int x, int y, int width, int height, boolean canClick) {
-        WidgetGroup group = new WidgetGroup(x, y, width, height);
-        for (int i = 0; i < ((VirtualItemStorage) entry).getHandler().getSlots(); i++) {
-            group.addWidget(new SlotWidget(((VirtualItemStorage) entry).getHandler(), i, 8 * i, 0, canClick, canClick));
-        }
-        return group;
-    }
-
-    @Override
-    protected String getUITitle() {
-        return "cover.ender_item_link.title";
-    }
 }
diff --git a/src/main/java/com/gregtechceu/gtceu/common/cover/ender/EnderRedstoneLinkCover.java b/src/main/java/com/gregtechceu/gtceu/common/cover/ender/EnderRedstoneLinkCover.java
index d2f3d2c3d6e..126c406f7d4 100644
--- a/src/main/java/com/gregtechceu/gtceu/common/cover/ender/EnderRedstoneLinkCover.java
+++ b/src/main/java/com/gregtechceu/gtceu/common/cover/ender/EnderRedstoneLinkCover.java
@@ -6,36 +6,26 @@
 import com.gregtechceu.gtceu.api.misc.virtualregistry.VirtualEntry;
 import com.gregtechceu.gtceu.api.misc.virtualregistry.entries.VirtualRedstone;
 import com.gregtechceu.gtceu.api.sync_system.SyncDataHolder;
-import com.gregtechceu.gtceu.api.sync_system.annotations.SaveField;
-import com.gregtechceu.gtceu.api.sync_system.annotations.SyncToClient;
-
-import com.lowdragmc.lowdraglib.gui.widget.Widget;
-import com.lowdragmc.lowdraglib.gui.widget.WidgetGroup;
 
 import net.minecraft.core.Direction;
 
+import brachy.modularui.api.widget.IWidget;
+import brachy.modularui.value.sync.PanelSyncManager;
+import brachy.modularui.widget.ParentWidget;
 import lombok.Getter;
+import org.jetbrains.annotations.Nullable;
 
-import java.util.UUID;
+import java.util.Objects;
 
 public class EnderRedstoneLinkCover extends AbstractEnderLinkCover<VirtualRedstone> {
 
     @Getter
     protected final SyncDataHolder syncDataHolder = new SyncDataHolder(this);
 
-    @SaveField
-    @SyncToClient
-    private VirtualRedstone storage;
-    @SaveField
-    @SyncToClient
-    private UUID uuid;
+    private @Nullable VirtualRedstone storage = new VirtualRedstone();
 
     public EnderRedstoneLinkCover(CoverDefinition definition, ICoverable coverHolder, Direction attachedSide) {
         super(definition, coverHolder, attachedSide);
-        if (!isRemote()) {
-            uuid = UUID.randomUUID();
-            setVirtualEntry();
-        } else uuid = null;
     }
 
     @Override
@@ -44,20 +34,15 @@ public boolean canAttach() {
     }
 
     @Override
-    protected String identifier() {
-        return "ERLink#";
-    }
-
-    @Override
-    protected VirtualRedstone getEntry() {
+    protected @Nullable VirtualRedstone getEntry() {
         return storage;
     }
 
     @Override
     protected void setEntry(VirtualEntry entry) {
-        if (storage != null) storage.removeMember(uuid);
+        if (storage != null) storage.removeMember(this);
         storage = (VirtualRedstone) entry;
-        storage.addMember(uuid);
+        storage.addMember(this);
         syncDataHolder.markClientSyncFieldDirty("storage");
     }
 
@@ -69,29 +54,23 @@ protected EntryTypes<VirtualRedstone> getEntryType() {
     @Override
     protected void transfer() {
         switch (io) {
-            case IN -> storage.setSignal(uuid, getSignalInput());
-            case OUT -> setRedstoneSignalOutput(storage.getSignal());
+            case IN -> Objects.requireNonNull(storage).setSignal(this, getSignalInput());
+            case OUT -> setRedstoneSignalOutput(Objects.requireNonNull(storage).getSignal());
         }
     }
 
-    @Override
-    protected Widget addVirtualEntryWidget(VirtualEntry entry, int x, int y, int width, int height, boolean canClick) {
-        return new WidgetGroup(x, y, width, height);
-    }
-
-    @Override
-    protected String getUITitle() {
-        return "cover.ender_redstone_link.title";
-    }
-
     @Override
     public boolean canConnectRedstone() {
         return true;
     }
 
+    protected IWidget createVirtualEntryWidget(PanelSyncManager manager, VirtualEntry entry, int w, int h, int index) {
+        return new ParentWidget<>().size(w, h);
+    }
+
     @Override
     public void onRemoved() {
-        storage.removeMember(uuid);
+        if (storage != null) storage.removeMember(this);
         super.onRemoved();
     }
 
diff --git a/src/main/java/com/gregtechceu/gtceu/common/cover/ender/package-info.java b/src/main/java/com/gregtechceu/gtceu/common/cover/ender/package-info.java
new file mode 100644
index 00000000000..afd9b5bb2a4
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/common/cover/ender/package-info.java
@@ -0,0 +1,4 @@
+@NotNullByDefault
+package com.gregtechceu.gtceu.common.cover.ender;
+
+import org.jetbrains.annotations.NotNullByDefault;
diff --git a/src/main/java/com/gregtechceu/gtceu/common/cover/voiding/AdvancedFluidVoidingCover.java b/src/main/java/com/gregtechceu/gtceu/common/cover/voiding/AdvancedFluidVoidingCover.java
index ffbf5b60de0..2f68ae7ea1b 100644
--- a/src/main/java/com/gregtechceu/gtceu/common/cover/voiding/AdvancedFluidVoidingCover.java
+++ b/src/main/java/com/gregtechceu/gtceu/common/cover/voiding/AdvancedFluidVoidingCover.java
@@ -4,28 +4,33 @@
 import com.gregtechceu.gtceu.api.cover.CoverDefinition;
 import com.gregtechceu.gtceu.api.cover.filter.FluidFilter;
 import com.gregtechceu.gtceu.api.cover.filter.SimpleFluidFilter;
-import com.gregtechceu.gtceu.api.gui.widget.EnumSelectorWidget;
-import com.gregtechceu.gtceu.api.gui.widget.IntInputWidget;
-import com.gregtechceu.gtceu.api.gui.widget.NumberInputWidget;
 import com.gregtechceu.gtceu.api.sync_system.annotations.SaveField;
 import com.gregtechceu.gtceu.api.sync_system.annotations.SyncToClient;
 import com.gregtechceu.gtceu.api.transfer.fluid.IFluidHandlerModifiable;
 import com.gregtechceu.gtceu.common.cover.data.BucketMode;
 import com.gregtechceu.gtceu.common.cover.data.VoidingMode;
+import com.gregtechceu.gtceu.common.mui.GTGuiTextures;
+import com.gregtechceu.gtceu.common.mui.GTMuiWidgets;
 import com.gregtechceu.gtceu.utils.GTMath;
 
-import com.lowdragmc.lowdraglib.gui.widget.WidgetGroup;
-
 import net.minecraft.MethodsReturnNonnullByDefault;
 import net.minecraft.core.Direction;
 import net.minecraft.nbt.CompoundTag;
+import net.minecraft.network.chat.Component;
 import net.minecraft.server.level.ServerPlayer;
 import net.minecraftforge.fluids.FluidStack;
 import net.minecraftforge.fluids.capability.IFluidHandler;
 
+import brachy.modularui.api.drawable.IKey;
+import brachy.modularui.factory.SidedPosGuiData;
+import brachy.modularui.screen.UISettings;
+import brachy.modularui.value.sync.EnumSyncValue;
+import brachy.modularui.value.sync.IntSyncValue;
+import brachy.modularui.value.sync.PanelSyncManager;
+import brachy.modularui.widgets.layout.Flow;
 import it.unimi.dsi.fastutil.objects.Object2LongMaps;
 import lombok.Getter;
-import org.jetbrains.annotations.NotNull;
+import lombok.Setter;
 
 import javax.annotation.ParametersAreNonnullByDefault;
 
@@ -41,15 +46,13 @@ public class AdvancedFluidVoidingCover extends FluidVoidingCover {
     @SaveField
     @SyncToClient
     @Getter
+    @Setter
     protected int globalTransferSizeMillibuckets = 1;
     @SaveField
     @SyncToClient
     @Getter
     private BucketMode transferBucketMode = BucketMode.MILLI_BUCKET;
 
-    private NumberInputWidget<Integer> stackSizeInput;
-    private EnumSelectorWidget<BucketMode> stackSizeBucketModeInput;
-
     public AdvancedFluidVoidingCover(CoverDefinition definition, ICoverable coverHolder, Direction attachedSide) {
         super(definition, coverHolder, attachedSide);
     }
@@ -99,7 +102,6 @@ private int getFilteredFluidAmount(FluidStack fluidStack) {
     public void setVoidingMode(VoidingMode voidingMode) {
         this.voidingMode = voidingMode;
         syncDataHolder.markClientSyncFieldDirty("voidingMode");
-        configureStackSizeInput();
 
         if (!this.isRemote()) {
             configureFilter();
@@ -109,34 +111,37 @@ public void setVoidingMode(VoidingMode voidingMode) {
     private void setTransferBucketMode(BucketMode transferBucketMode) {
         this.transferBucketMode = transferBucketMode;
         syncDataHolder.markClientSyncFieldDirty("transferBucketMode");
-
-        if (stackSizeInput == null) return;
-        stackSizeInput.setValue(getCurrentBucketModeTransferSize());
     }
 
     //////////////////////////////////////
     // *********** GUI ***********//
-    //////////////////////////////////////
-
-    @Override
-    protected @NotNull String getUITitle() {
-        return "cover.fluid.voiding.advanced.title";
-    }
 
     @Override
-    protected void buildAdditionalUI(WidgetGroup group) {
-        group.addWidget(
-                new EnumSelectorWidget<>(146, 20, 20, 20, VoidingMode.values(), voidingMode, this::setVoidingMode));
-
-        this.stackSizeInput = new IntInputWidget(35, 20, 84, 20,
-                this::getCurrentBucketModeTransferSize, this::setCurrentBucketModeTransferSize).setMin(1)
-                .setMax(Integer.MAX_VALUE);
-        configureStackSizeInput();
-        group.addWidget(this.stackSizeInput);
-
-        this.stackSizeBucketModeInput = new EnumSelectorWidget<>(121, 20, 20, 20, BucketMode.values(),
-                transferBucketMode, this::setTransferBucketMode);
-        group.addWidget(this.stackSizeBucketModeInput);
+    public void createCoverUIRows(Flow column, SidedPosGuiData data, PanelSyncManager syncManager,
+                                  UISettings settings) {
+        super.createCoverUIRows(column, data, syncManager, settings);
+
+        EnumSyncValue<VoidingMode> voidingMode = new EnumSyncValue<>(VoidingMode.class,
+                this::getVoidingMode, this::setVoidingMode);
+        IntSyncValue voidingLimit = new IntSyncValue(this::getGlobalTransferSizeMillibuckets,
+                this::setGlobalTransferSizeMillibuckets);
+        EnumSyncValue<BucketMode> bucketModeSync = new EnumSyncValue<>(BucketMode.class, this::getBucketMode,
+                this::setBucketMode);
+
+        syncManager.syncValue("voidingMode", voidingMode);
+        syncManager.syncValue("voidingLimit", voidingLimit);
+
+        column.child(new GTMuiWidgets.EnumRowBuilder<>(VoidingMode.class)
+                .value(voidingMode)
+                .overlay(16, GTGuiTextures.VOIDING_MODES)
+                .lang(IKey.dynamic(() -> Component.translatable(getVoidingMode().tooltip)))
+                .build()
+                .marginTop(2));
+
+        column.child(
+                GTMuiWidgets
+                        .createIntInputWithBucketMode(voidingLimit, bucketModeSync, () -> getVoidingMode().maxStackSize)
+                        .setEnabledIf($ -> shouldShowStackSize()));
     }
 
     private int getCurrentBucketModeTransferSize() {
@@ -153,16 +158,6 @@ protected void configureFilter() {
         if (filterHandler.getFilter() instanceof SimpleFluidFilter filter) {
             filter.setMaxStackSize(voidingMode == VoidingMode.VOID_ANY ? 1 : Integer.MAX_VALUE);
         }
-
-        configureStackSizeInput();
-    }
-
-    private void configureStackSizeInput() {
-        if (this.stackSizeInput == null || stackSizeBucketModeInput == null)
-            return;
-
-        this.stackSizeInput.setVisible(shouldShowStackSize());
-        this.stackSizeBucketModeInput.setVisible(shouldShowStackSize());
     }
 
     private boolean shouldShowStackSize() {
diff --git a/src/main/java/com/gregtechceu/gtceu/common/cover/voiding/AdvancedItemVoidingCover.java b/src/main/java/com/gregtechceu/gtceu/common/cover/voiding/AdvancedItemVoidingCover.java
index a8ae17034bf..2f5ad86ecbb 100644
--- a/src/main/java/com/gregtechceu/gtceu/common/cover/voiding/AdvancedItemVoidingCover.java
+++ b/src/main/java/com/gregtechceu/gtceu/common/cover/voiding/AdvancedItemVoidingCover.java
@@ -4,24 +4,30 @@
 import com.gregtechceu.gtceu.api.cover.CoverDefinition;
 import com.gregtechceu.gtceu.api.cover.filter.ItemFilter;
 import com.gregtechceu.gtceu.api.cover.filter.SimpleItemFilter;
-import com.gregtechceu.gtceu.api.gui.widget.EnumSelectorWidget;
-import com.gregtechceu.gtceu.api.gui.widget.IntInputWidget;
 import com.gregtechceu.gtceu.api.sync_system.annotations.SaveField;
 import com.gregtechceu.gtceu.api.sync_system.annotations.SyncToClient;
 import com.gregtechceu.gtceu.common.cover.data.VoidingMode;
+import com.gregtechceu.gtceu.common.mui.GTGuiTextures;
+import com.gregtechceu.gtceu.common.mui.GTMuiWidgets;
 import com.gregtechceu.gtceu.utils.GTUtil;
 
-import com.lowdragmc.lowdraglib.gui.widget.WidgetGroup;
-
 import net.minecraft.MethodsReturnNonnullByDefault;
 import net.minecraft.core.Direction;
 import net.minecraft.nbt.CompoundTag;
+import net.minecraft.network.chat.Component;
 import net.minecraft.server.level.ServerPlayer;
 import net.minecraft.world.item.ItemStack;
 import net.minecraftforge.items.IItemHandler;
 
+import brachy.modularui.api.drawable.IKey;
+import brachy.modularui.factory.SidedPosGuiData;
+import brachy.modularui.screen.UISettings;
+import brachy.modularui.value.sync.EnumSyncValue;
+import brachy.modularui.value.sync.IntSyncValue;
+import brachy.modularui.value.sync.PanelSyncManager;
+import brachy.modularui.widgets.layout.Flow;
 import lombok.Getter;
-import org.jetbrains.annotations.NotNull;
+import lombok.Setter;
 
 import java.util.Map;
 
@@ -38,10 +44,9 @@ public class AdvancedItemVoidingCover extends ItemVoidingCover {
 
     @SaveField
     @Getter
+    @Setter
     protected int globalVoidingLimit = 1;
 
-    private IntInputWidget stackSizeInput;
-
     public AdvancedItemVoidingCover(CoverDefinition definition, ICoverable coverHolder, Direction attachedSide) {
         super(definition, coverHolder, attachedSide);
     }
@@ -100,8 +105,6 @@ private int getFilteredItemAmount(ItemStack itemStack) {
     public void setVoidingMode(VoidingMode voidingMode) {
         this.voidingMode = voidingMode;
 
-        configureStackSizeInput();
-
         if (!this.isRemote()) {
             syncDataHolder.markClientSyncFieldDirty("voidingMode");
             configureFilter();
@@ -113,20 +116,26 @@ public void setVoidingMode(VoidingMode voidingMode) {
     //////////////////////////////////////
 
     @Override
-    protected @NotNull String getUITitle() {
-        return "cover.item.voiding.advanced.title";
-    }
-
-    @Override
-    protected void buildAdditionalUI(WidgetGroup group) {
-        group.addWidget(
-                new EnumSelectorWidget<>(146, 20, 20, 20, VoidingMode.values(), voidingMode, this::setVoidingMode));
-
-        this.stackSizeInput = new IntInputWidget(64, 20, 80, 20,
-                () -> globalVoidingLimit, val -> globalVoidingLimit = val);
-        configureStackSizeInput();
-
-        group.addWidget(this.stackSizeInput);
+    public void createCoverUIRows(Flow column, SidedPosGuiData data, PanelSyncManager syncManager,
+                                  UISettings settings) {
+        super.createCoverUIRows(column, data, syncManager, settings);
+
+        EnumSyncValue<VoidingMode> voidingMode = new EnumSyncValue<>(VoidingMode.class,
+                this::getVoidingMode, this::setVoidingMode);
+        IntSyncValue voidingLimit = new IntSyncValue(this::getGlobalVoidingLimit, this::setGlobalVoidingLimit);
+
+        syncManager.syncValue("voidingMode", voidingMode);
+        syncManager.syncValue("voidingLimit", voidingLimit);
+
+        column.child(new GTMuiWidgets.EnumRowBuilder<>(VoidingMode.class)
+                .value(voidingMode)
+                .overlay(16, GTGuiTextures.VOIDING_MODES)
+                .lang(IKey.dynamic(() -> Component.translatable(getVoidingMode().tooltip)))
+                .build()
+                .marginTop(2));
+
+        column.child(GTMuiWidgets.createIntInputWithButtons(voidingLimit, () -> 1, () -> getVoidingMode().maxStackSize)
+                .setEnabledIf($ -> shouldShowStackSize()));
     }
 
     @Override
@@ -134,17 +143,6 @@ protected void configureFilter() {
         if (filterHandler.getFilter() instanceof SimpleItemFilter filter) {
             filter.setMaxStackSize(this.voidingMode.maxStackSize);
         }
-
-        configureStackSizeInput();
-    }
-
-    private void configureStackSizeInput() {
-        if (this.stackSizeInput == null)
-            return;
-
-        this.stackSizeInput.setVisible(shouldShowStackSize());
-        this.stackSizeInput.setMin(1);
-        this.stackSizeInput.setMax(this.voidingMode.maxStackSize);
     }
 
     private boolean shouldShowStackSize() {
diff --git a/src/main/java/com/gregtechceu/gtceu/common/cover/voiding/FluidVoidingCover.java b/src/main/java/com/gregtechceu/gtceu/common/cover/voiding/FluidVoidingCover.java
index 4eec280e777..19dd9756999 100644
--- a/src/main/java/com/gregtechceu/gtceu/common/cover/voiding/FluidVoidingCover.java
+++ b/src/main/java/com/gregtechceu/gtceu/common/cover/voiding/FluidVoidingCover.java
@@ -2,19 +2,14 @@
 
 import com.gregtechceu.gtceu.api.capability.ICoverable;
 import com.gregtechceu.gtceu.api.cover.CoverDefinition;
-import com.gregtechceu.gtceu.api.gui.GuiTextures;
-import com.gregtechceu.gtceu.api.gui.widget.ToggleButtonWidget;
 import com.gregtechceu.gtceu.api.item.tool.GTToolType;
 import com.gregtechceu.gtceu.api.transfer.fluid.IFluidHandlerModifiable;
 import com.gregtechceu.gtceu.common.cover.PumpCover;
+import com.gregtechceu.gtceu.common.mui.GTGuiTextures;
+import com.gregtechceu.gtceu.common.mui.GTMuiWidgets;
 import com.gregtechceu.gtceu.utils.ExtendedUseOnContext;
 import com.gregtechceu.gtceu.utils.GTMath;
 
-import com.lowdragmc.lowdraglib.gui.texture.ResourceTexture;
-import com.lowdragmc.lowdraglib.gui.widget.LabelWidget;
-import com.lowdragmc.lowdraglib.gui.widget.Widget;
-import com.lowdragmc.lowdraglib.gui.widget.WidgetGroup;
-
 import net.minecraft.MethodsReturnNonnullByDefault;
 import net.minecraft.core.BlockPos;
 import net.minecraft.core.Direction;
@@ -25,9 +20,13 @@
 import net.minecraftforge.fluids.FluidStack;
 import net.minecraftforge.fluids.capability.IFluidHandler;
 
+import brachy.modularui.drawable.UITexture;
+import brachy.modularui.factory.SidedPosGuiData;
+import brachy.modularui.screen.UISettings;
+import brachy.modularui.value.sync.PanelSyncManager;
+import brachy.modularui.widgets.layout.Flow;
 import it.unimi.dsi.fastutil.objects.Object2LongMap;
 import it.unimi.dsi.fastutil.objects.Object2LongMaps;
-import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 
 import java.util.Set;
@@ -83,30 +82,14 @@ void voidAny(IFluidHandlerModifiable fluidHandler) {
         }
     }
 
-    //////////////////////////////////////
-    // *********** GUI ***********//
-    //////////////////////////////////////
-
     @Override
-    public Widget createUIWidget() {
-        final var group = new WidgetGroup(0, 0, 176, 120);
-        group.addWidget(new LabelWidget(10, 5, getUITitle()));
-
-        group.addWidget(new ToggleButtonWidget(10, 20, 20, 20,
-                GuiTextures.BUTTON_POWER, this::isWorkingEnabled, this::setWorkingEnabled));
-
-        // group.addWidget(filterHandler.createFilterSlotUI(36, 21));
-        group.addWidget(filterHandler.createFilterSlotUI(148, 91));
-        group.addWidget(filterHandler.createFilterConfigUI(10, 50, 126, 60));
-
-        buildAdditionalUI(group);
-
-        return group;
-    }
+    public void createCoverUIRows(Flow column, SidedPosGuiData data, PanelSyncManager syncManager,
+                                  UISettings settings) {
+        var row = coverUIRow()
+                .child(GTMuiWidgets.createPowerButton(this));
+        GTMuiWidgets.createFilterRow(row, filterHandler, data, syncManager, settings);
 
-    @NotNull
-    protected String getUITitle() {
-        return "cover.fluid.voiding.title";
+        column.child(row);
     }
 
     @Override
@@ -120,10 +103,10 @@ public InteractionResult onSoftMalletClick(ExtendedUseOnContext context) {
     }
 
     @Override
-    public @Nullable ResourceTexture sideTips(Player player, BlockPos pos, BlockState state, Set<GTToolType> toolTypes,
-                                              Direction side) {
+    public @Nullable UITexture sideTips(Player player, BlockPos pos, BlockState state, Set<GTToolType> toolTypes,
+                                        Direction side) {
         if (toolTypes.contains(GTToolType.SOFT_MALLET)) {
-            return isWorkingEnabled() ? GuiTextures.TOOL_START : GuiTextures.TOOL_PAUSE;
+            return isWorkingEnabled() ? GTGuiTextures.TOOL_START : GTGuiTextures.TOOL_PAUSE;
         }
         return super.sideTips(player, pos, state, toolTypes, side);
     }
diff --git a/src/main/java/com/gregtechceu/gtceu/common/cover/voiding/ItemVoidingCover.java b/src/main/java/com/gregtechceu/gtceu/common/cover/voiding/ItemVoidingCover.java
index 2c2a672d5ca..ec4ff903959 100644
--- a/src/main/java/com/gregtechceu/gtceu/common/cover/voiding/ItemVoidingCover.java
+++ b/src/main/java/com/gregtechceu/gtceu/common/cover/voiding/ItemVoidingCover.java
@@ -3,19 +3,13 @@
 import com.gregtechceu.gtceu.api.capability.IControllable;
 import com.gregtechceu.gtceu.api.capability.ICoverable;
 import com.gregtechceu.gtceu.api.cover.CoverDefinition;
-import com.gregtechceu.gtceu.api.cover.IUICover;
 import com.gregtechceu.gtceu.api.cover.filter.ItemFilter;
-import com.gregtechceu.gtceu.api.gui.GuiTextures;
-import com.gregtechceu.gtceu.api.gui.widget.ToggleButtonWidget;
 import com.gregtechceu.gtceu.api.item.tool.GTToolType;
 import com.gregtechceu.gtceu.common.cover.ConveyorCover;
+import com.gregtechceu.gtceu.common.mui.GTGuiTextures;
+import com.gregtechceu.gtceu.common.mui.GTMuiWidgets;
 import com.gregtechceu.gtceu.utils.ExtendedUseOnContext;
 
-import com.lowdragmc.lowdraglib.gui.texture.ResourceTexture;
-import com.lowdragmc.lowdraglib.gui.widget.LabelWidget;
-import com.lowdragmc.lowdraglib.gui.widget.Widget;
-import com.lowdragmc.lowdraglib.gui.widget.WidgetGroup;
-
 import net.minecraft.MethodsReturnNonnullByDefault;
 import net.minecraft.core.BlockPos;
 import net.minecraft.core.Direction;
@@ -26,7 +20,11 @@
 import net.minecraft.world.level.block.state.BlockState;
 import net.minecraftforge.items.IItemHandler;
 
-import org.jetbrains.annotations.NotNull;
+import brachy.modularui.drawable.UITexture;
+import brachy.modularui.factory.SidedPosGuiData;
+import brachy.modularui.screen.UISettings;
+import brachy.modularui.value.sync.PanelSyncManager;
+import brachy.modularui.widgets.layout.Flow;
 import org.jetbrains.annotations.Nullable;
 
 import java.util.Set;
@@ -35,7 +33,7 @@
 
 @ParametersAreNonnullByDefault
 @MethodsReturnNonnullByDefault
-public class ItemVoidingCover extends ConveyorCover implements IUICover, IControllable {
+public class ItemVoidingCover extends ConveyorCover implements IControllable {
 
     public ItemVoidingCover(CoverDefinition definition, ICoverable coverHolder, Direction attachedSide) {
         super(definition, coverHolder, attachedSide, 0);
@@ -85,25 +83,13 @@ void voidAny(IItemHandler handler) {
     //////////////////////////////////////
 
     @Override
-    public Widget createUIWidget() {
-        final var group = new WidgetGroup(0, 0, 176, 120);
-        group.addWidget(new LabelWidget(10, 5, getUITitle()));
-
-        group.addWidget(new ToggleButtonWidget(10, 20, 20, 20,
-                GuiTextures.BUTTON_POWER, this::isWorkingEnabled, this::setWorkingEnabled));
-
-        // group.addWidget(filterHandler.createFilterSlotUI(36, 21));
-        group.addWidget(filterHandler.createFilterSlotUI(148, 91));
-        group.addWidget(filterHandler.createFilterConfigUI(10, 50, 126, 60));
-
-        buildAdditionalUI(group);
-
-        return group;
-    }
-
-    @NotNull
-    protected String getUITitle() {
-        return "cover.item.voiding.title";
+    public void createCoverUIRows(Flow column, SidedPosGuiData data, PanelSyncManager syncManager,
+                                  UISettings settings) {
+        column.child(GTMuiWidgets.createFilterRow(
+                coverUIRow().child(
+                        GTMuiWidgets.createPowerButton(this)),
+                filterHandler, data, syncManager,
+                settings));
     }
 
     @Override
@@ -117,12 +103,12 @@ public InteractionResult onSoftMalletClick(ExtendedUseOnContext context) {
     }
 
     @Override
-    public @Nullable ResourceTexture sideTips(Player player, BlockPos pos, BlockState state, Set<GTToolType> toolTypes,
-                                              Direction side) {
+    public @Nullable UITexture sideTips(Player player, BlockPos pos, BlockState state, Set<GTToolType> toolTypes,
+                                        Direction side) {
         var superTips = super.sideTips(player, pos, state, toolTypes, side);
         if (superTips != null) return superTips;
         if (toolTypes.contains(GTToolType.SOFT_MALLET)) {
-            return isWorkingEnabled() ? GuiTextures.TOOL_START : GuiTextures.TOOL_PAUSE;
+            return isWorkingEnabled() ? GTGuiTextures.TOOL_START : GTGuiTextures.TOOL_PAUSE;
         }
         return null;
     }
diff --git a/src/main/java/com/gregtechceu/gtceu/common/data/GCYMRecipeTypes.java b/src/main/java/com/gregtechceu/gtceu/common/data/GCYMRecipeTypes.java
index 36189576669..0e4c49b1226 100644
--- a/src/main/java/com/gregtechceu/gtceu/common/data/GCYMRecipeTypes.java
+++ b/src/main/java/com/gregtechceu/gtceu/common/data/GCYMRecipeTypes.java
@@ -6,7 +6,7 @@
 import com.gregtechceu.gtceu.api.gui.GuiTextures;
 import com.gregtechceu.gtceu.api.gui.widget.SlotWidget;
 import com.gregtechceu.gtceu.api.recipe.GTRecipeType;
-import com.gregtechceu.gtceu.integration.xei.handlers.item.CycleItemEntryHandler;
+import com.gregtechceu.gtceu.integration.recipeviewer.handlers.item.CycleItemEntryHandler;
 import com.gregtechceu.gtceu.utils.FormattingUtil;
 
 import com.lowdragmc.lowdraglib.utils.LocalizationUtils;
diff --git a/src/main/java/com/gregtechceu/gtceu/common/data/GTBlockEntities.java b/src/main/java/com/gregtechceu/gtceu/common/data/GTBlockEntities.java
index c4330ecb17b..4757ed7b3ab 100644
--- a/src/main/java/com/gregtechceu/gtceu/common/data/GTBlockEntities.java
+++ b/src/main/java/com/gregtechceu/gtceu/common/data/GTBlockEntities.java
@@ -11,6 +11,11 @@
 
 public class GTBlockEntities {
 
+    public static final BlockEntityEntry<EquipmentFoundryBlockEntity> EQUIPMENT_FOUNDRY = REGISTRATE
+            .blockEntity("equipment_foundry", EquipmentFoundryBlockEntity::new)
+            .validBlock(GTBlocks.EQUIPMENT_FOUNDRY)
+            .register();
+
     @SuppressWarnings("unchecked")
     public static final BlockEntityEntry<CableBlockEntity> CABLE = REGISTRATE
             .blockEntity("cable", CableBlockEntity::new)
diff --git a/src/main/java/com/gregtechceu/gtceu/common/data/GTBlocks.java b/src/main/java/com/gregtechceu/gtceu/common/data/GTBlocks.java
index b2a8f0e4f87..3c4e0fbdb4f 100644
--- a/src/main/java/com/gregtechceu/gtceu/common/data/GTBlocks.java
+++ b/src/main/java/com/gregtechceu/gtceu/common/data/GTBlocks.java
@@ -187,6 +187,12 @@ private static void registerDuctPipeBlock(int index) {
         DUCT_PIPES[index] = entry;
     }
 
+    public static final BlockEntry<EquipmentFoundryBlock> EQUIPMENT_FOUNDRY = REGISTRATE
+            .block("equipment_foundry", EquipmentFoundryBlock::new)
+            .initialProperties(() -> Blocks.SMITHING_TABLE)
+            .simpleItem()
+            .register();
+
     // Long Distance Item Pipe Blocks
     public static final BlockEntry<LongDistancePipeBlock> LD_ITEM_PIPE = REGISTRATE
             .block("long_distance_item_pipeline",
diff --git a/src/main/java/com/gregtechceu/gtceu/common/data/GTItemModules.java b/src/main/java/com/gregtechceu/gtceu/common/data/GTItemModules.java
new file mode 100644
index 00000000000..464a9bba163
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/common/data/GTItemModules.java
@@ -0,0 +1,46 @@
+package com.gregtechceu.gtceu.common.data;
+
+import com.gregtechceu.gtceu.GTCEu;
+import com.gregtechceu.gtceu.api.item.module.*;
+import com.gregtechceu.gtceu.common.module.*;
+
+public class GTItemModules {
+
+    public static final ItemModuleSlot UNIVERSAL_SLOT = new UniversalItemModuleSlot(GTCEu.id("universal"));
+    public static final TieredItemModuleSlot[] TIERED_SLOTS = TieredItemModuleSlot.create(GTCEu.id("tiered"),
+            TieredItemModuleSlot::new);
+
+    public static final ItemModule[] SPEED = TieredItemModule.create(GTCEu.id("speed"), SpeedItemModule::new);
+    public static final ItemModule[] DAMAGE_BLOCK = TieredItemModule.create(GTCEu.id("damage_block"),
+            EnergyShieldItemModule::new);
+    public static final ItemModule[] ATTACK_SPEED = TieredItemModule.create(GTCEu.id("attack_speed"),
+            AttackSpeedItemModule::new);
+    public static final ItemModule[] ATTACK_DAMAGE = TieredItemModule.create(GTCEu.id("attack_damage"),
+            AttackDamageItemModule::new);
+    public static final ItemModule[] BLOCK_REACH = TieredItemModule.create(GTCEu.id("block_reach"),
+            BlockReachItemModule::new);
+    public static final ItemModule[] MOVEMENT_SPEED_ATTR = TieredItemModule.create(GTCEu.id("movement_speed"),
+            MovementSpeedItemModule::new);
+    public static final ItemModule[] SNEAK_SPEED = TieredItemModule.create(GTCEu.id("sneak_speed"),
+            SneakSpeedItemModule::new);
+    public static final ItemModule[] SWIM_SPEED = TieredItemModule.create(GTCEu.id("swim_speed"), SwimSpeedModule::new);
+    public static final ItemModule[] STEP_HEIGHT = TieredItemModule.create(GTCEu.id("step_height"),
+            StepHeightModule::new);
+    public static final ItemModule[] JUMP_BOOST = TieredItemModule.create(GTCEu.id("jump_boost"),
+            JumpBoostItemModule::new);
+    public static final ItemModule[] SENSOR = TieredItemModule.create(GTCEu.id("sensor"), SensorItemModule::new);
+    public static final ItemModule[] WIRELESS_CHARGER = TieredItemModule.create(GTCEu.id("wireless_charger"),
+            AutoChargeItemModule::new);
+    public static final ItemModule AUTO_EAT = new AutoEatModule(GTCEu.id("auto_eat"));
+    public static final ItemModule AIR_SUPPLIER = new AirSupplierModule(GTCEu.id("air_supplier"));
+    public static final ItemModule BATTERY = new BatteryItemModule(GTCEu.id("battery"));
+    public static final ItemModule NIGHT_VISION = new NightVisionModule(GTCEu.id("night_vision"));
+    public static final ItemModule PPE = new PPEModule(GTCEu.id("ppe"));
+    public static final ItemModule LIQUID_FUEL_JETPACK = new LiquidFuelJetpackModule(GTCEu.id("liquid_fuel_jetpack"));
+    public static final ItemModule JETPACK = new JetpackModule(GTCEu.id("jetpack"));
+    public static final ItemModule ADVANCED_JETPACK = new AdvancedJetpackModule(GTCEu.id("advanced_jetpack"));
+    public static final ItemModule CREATIVE_FLIGHT = new CreativeFlightModule(GTCEu.id("creative_flight"));
+    public static final ItemModule FLUID_STORAGE = new FluidStorageModule(GTCEu.id("fluid_storage"));
+
+    public static void init() {}
+}
diff --git a/src/main/java/com/gregtechceu/gtceu/common/data/GTItems.java b/src/main/java/com/gregtechceu/gtceu/common/data/GTItems.java
index 7cef69333c5..49dd4666c86 100644
--- a/src/main/java/com/gregtechceu/gtceu/common/data/GTItems.java
+++ b/src/main/java/com/gregtechceu/gtceu/common/data/GTItems.java
@@ -20,6 +20,7 @@
 import com.gregtechceu.gtceu.api.item.IComponentItem;
 import com.gregtechceu.gtceu.api.item.TagPrefixItem;
 import com.gregtechceu.gtceu.api.item.armor.ArmorComponentItem;
+import com.gregtechceu.gtceu.api.item.armor.ModularArmorItem;
 import com.gregtechceu.gtceu.api.item.component.*;
 import com.gregtechceu.gtceu.api.item.tool.MaterialToolTier;
 import com.gregtechceu.gtceu.common.data.materials.GTFoods;
@@ -29,6 +30,7 @@
 import com.gregtechceu.gtceu.common.item.behavior.*;
 import com.gregtechceu.gtceu.common.item.behavior.LighterBehavior;
 import com.gregtechceu.gtceu.common.item.behavior.MachineConfigCopyBehaviour;
+import com.gregtechceu.gtceu.common.item.modules.GuiModuleBehaviour;
 import com.gregtechceu.gtceu.common.item.modules.ImageModuleBehaviour;
 import com.gregtechceu.gtceu.common.item.modules.TextModuleBehaviour;
 import com.gregtechceu.gtceu.config.ConfigHolder;
@@ -88,10 +90,12 @@ public class GTItems {
 
     //////////////////////////////////////
     // ******* Misc Items ********//
+
     //////////////////////////////////////
     static {
         REGISTRATE.creativeModeTab(() -> ITEM);
     }
+
     public static ItemEntry<Item> COMPRESSED_CLAY = REGISTRATE.item("compressed_clay", Item::new)
             .lang("Compressed Clay")
             .onRegister(materialInfo(new ItemMaterialInfo(new MaterialStack(GTMaterials.Clay, GTValues.M)))).register();
@@ -313,6 +317,7 @@ public class GTItems {
                 .onRegister(materialInfo(new ItemMaterialInfo(new MaterialStack(GTMaterials.Steel, GTValues.M * 4))))
                 .register();
     }
+
     public static ItemEntry<Item> SPRAY_EMPTY = REGISTRATE.item("empty_spray_can", Item::new)
             .lang("Spray Can (Empty)").register();
     public static ItemEntry<ComponentItem> SPRAY_SOLVENT = REGISTRATE.item("solvent_spray_can", ComponentItem::create)
@@ -410,6 +415,7 @@ public static ItemEntry<ComponentItem> createFluidCell(Material mat, int capacit
                 .onRegister(attach(cellName(),
                         ThermalFluidStats.create(FluidType.BUCKET_VOLUME * capacity, prop, true),
                         new ItemFluidContainer()))
+                .tag(CustomTags.FLUID_CONTAINERS)
                 .onRegister(materialInfo(new ItemMaterialInfo(new MaterialStack(mat, GTValues.M * matSize))))
                 .register();
     }
@@ -669,61 +675,83 @@ public static ItemEntry<ComponentItem> createFluidCell(Material mat, int capacit
             .onRegister(attach(ElectricStats.createRechargeableBattery(Long.MAX_VALUE, GTValues.UHV)))
             .tag(CustomTags.UHV_BATTERIES).register();
 
-    public static ItemEntry<Item> ELECTRIC_MOTOR_LV = REGISTRATE.item("lv_electric_motor", Item::new)
+    public static ItemEntry<ComponentItem> ELECTRIC_MOTOR_LV = REGISTRATE
+            .item("lv_electric_motor", ComponentItem::create)
             .lang("LV Electric Motor")
+            .onRegister(attach(new TieredBehaviour(GTValues.LV)))
             .tag(CustomTags.ELECTRIC_MOTORS)
             .register();
-    public static ItemEntry<Item> ELECTRIC_MOTOR_MV = REGISTRATE.item("mv_electric_motor", Item::new)
+    public static ItemEntry<ComponentItem> ELECTRIC_MOTOR_MV = REGISTRATE
+            .item("mv_electric_motor", ComponentItem::create)
             .lang("MV Electric Motor")
+            .onRegister(attach(new TieredBehaviour(GTValues.MV)))
             .tag(CustomTags.ELECTRIC_MOTORS)
             .register();
-    public static ItemEntry<Item> ELECTRIC_MOTOR_HV = REGISTRATE.item("hv_electric_motor", Item::new)
+    public static ItemEntry<ComponentItem> ELECTRIC_MOTOR_HV = REGISTRATE
+            .item("hv_electric_motor", ComponentItem::create)
             .lang("HV Electric Motor")
+            .onRegister(attach(new TieredBehaviour(GTValues.HV)))
             .tag(CustomTags.ELECTRIC_MOTORS)
             .register();
-    public static ItemEntry<Item> ELECTRIC_MOTOR_EV = REGISTRATE.item("ev_electric_motor", Item::new)
+    public static ItemEntry<ComponentItem> ELECTRIC_MOTOR_EV = REGISTRATE
+            .item("ev_electric_motor", ComponentItem::create)
             .lang("EV Electric Motor")
+            .onRegister(attach(new TieredBehaviour(GTValues.EV)))
             .tag(CustomTags.ELECTRIC_MOTORS)
             .register();
-    public static ItemEntry<Item> ELECTRIC_MOTOR_IV = REGISTRATE.item("iv_electric_motor", Item::new)
+    public static ItemEntry<ComponentItem> ELECTRIC_MOTOR_IV = REGISTRATE
+            .item("iv_electric_motor", ComponentItem::create)
             .lang("IV Electric Motor")
+            .onRegister(attach(new TieredBehaviour(GTValues.IV)))
             .tag(CustomTags.ELECTRIC_MOTORS)
             .register();
-    public static ItemEntry<Item> ELECTRIC_MOTOR_LuV = REGISTRATE.item("luv_electric_motor", Item::new)
+    public static ItemEntry<ComponentItem> ELECTRIC_MOTOR_LuV = REGISTRATE
+            .item("luv_electric_motor", ComponentItem::create)
             .lang("LuV Electric Motor")
+            .onRegister(attach(new TieredBehaviour(GTValues.LuV)))
             .tag(CustomTags.ELECTRIC_MOTORS)
             .register();
-    public static ItemEntry<Item> ELECTRIC_MOTOR_ZPM = REGISTRATE.item("zpm_electric_motor", Item::new)
+    public static ItemEntry<ComponentItem> ELECTRIC_MOTOR_ZPM = REGISTRATE
+            .item("zpm_electric_motor", ComponentItem::create)
             .lang("ZPM Electric Motor")
+            .onRegister(attach(new TieredBehaviour(GTValues.ZPM)))
             .tag(CustomTags.ELECTRIC_MOTORS)
             .register();
-    public static ItemEntry<Item> ELECTRIC_MOTOR_UV = REGISTRATE.item("uv_electric_motor", Item::new)
+    public static ItemEntry<ComponentItem> ELECTRIC_MOTOR_UV = REGISTRATE
+            .item("uv_electric_motor", ComponentItem::create)
             .lang("UV Electric Motor")
+            .onRegister(attach(new TieredBehaviour(GTValues.UV)))
             .tag(CustomTags.ELECTRIC_MOTORS)
             .register();
     public static ItemEntry<Item> ELECTRIC_MOTOR_UHV = GTCEuAPI.isHighTier() ?
             REGISTRATE.item("uhv_electric_motor", Item::new).lang("UHV Electric Motor")
+                    .tag(CustomTags.ELECTRIC_MOTORS)
                     .register() :
             null;
     public static ItemEntry<Item> ELECTRIC_MOTOR_UEV = GTCEuAPI.isHighTier() ?
             REGISTRATE.item("uev_electric_motor", Item::new).lang("UEV Electric Motor")
+                    .tag(CustomTags.ELECTRIC_MOTORS)
                     .register() :
             null;
     public static ItemEntry<Item> ELECTRIC_MOTOR_UIV = GTCEuAPI.isHighTier() ?
             REGISTRATE.item("uiv_electric_motor", Item::new).lang("UIV Electric Motor")
+                    .tag(CustomTags.ELECTRIC_MOTORS)
                     .register() :
             null;
     public static ItemEntry<Item> ELECTRIC_MOTOR_UXV = GTCEuAPI.isHighTier() ?
             REGISTRATE.item("uxv_electric_motor", Item::new).lang("UXV Electric Motor")
+                    .tag(CustomTags.ELECTRIC_MOTORS)
                     .register() :
             null;
     public static ItemEntry<Item> ELECTRIC_MOTOR_OpV = GTCEuAPI.isHighTier() ?
             REGISTRATE.item("opv_electric_motor", Item::new).lang("OpV Electric Motor")
+                    .tag(CustomTags.ELECTRIC_MOTORS)
                     .register() :
             null;
 
     public static ItemEntry<ComponentItem> ELECTRIC_PUMP_LV = REGISTRATE.item("lv_electric_pump", ComponentItem::create)
             .lang("LV Electric Pump")
+            .onRegister(attach(new TieredBehaviour(GTValues.LV)))
             .onRegister(attach(new CoverPlaceBehavior(GTCovers.PUMPS[0])))
             .onRegister(attach(new TooltipBehavior(lines -> {
                 lines.add(Component.translatable("item.gtceu.electric.pump.tooltip"));
@@ -735,6 +763,7 @@ public static ItemEntry<ComponentItem> createFluidCell(Material mat, int capacit
 
     public static ItemEntry<ComponentItem> ELECTRIC_PUMP_MV = REGISTRATE.item("mv_electric_pump", ComponentItem::create)
             .lang("MV Electric Pump")
+            .onRegister(attach(new TieredBehaviour(GTValues.MV)))
             .onRegister(attach(new CoverPlaceBehavior(GTCovers.PUMPS[1])))
             .onRegister(attach(new TooltipBehavior(lines -> {
                 lines.add(Component.translatable("item.gtceu.electric.pump.tooltip"));
@@ -745,6 +774,7 @@ public static ItemEntry<ComponentItem> createFluidCell(Material mat, int capacit
             .register();
     public static ItemEntry<ComponentItem> ELECTRIC_PUMP_HV = REGISTRATE.item("hv_electric_pump", ComponentItem::create)
             .lang("HV Electric Pump")
+            .onRegister(attach(new TieredBehaviour(GTValues.HV)))
             .onRegister(attach(new CoverPlaceBehavior(GTCovers.PUMPS[2])))
             .onRegister(attach(new TooltipBehavior(lines -> {
                 lines.add(Component.translatable("item.gtceu.electric.pump.tooltip"));
@@ -755,6 +785,7 @@ public static ItemEntry<ComponentItem> createFluidCell(Material mat, int capacit
             .register();
     public static ItemEntry<ComponentItem> ELECTRIC_PUMP_EV = REGISTRATE.item("ev_electric_pump", ComponentItem::create)
             .lang("EV Electric Pump")
+            .onRegister(attach(new TieredBehaviour(GTValues.EV)))
             .onRegister(attach(new CoverPlaceBehavior(GTCovers.PUMPS[3])))
             .onRegister(attach(new TooltipBehavior(lines -> {
                 lines.add(Component.translatable("item.gtceu.electric.pump.tooltip"));
@@ -765,6 +796,7 @@ public static ItemEntry<ComponentItem> createFluidCell(Material mat, int capacit
             .register();
     public static ItemEntry<ComponentItem> ELECTRIC_PUMP_IV = REGISTRATE.item("iv_electric_pump", ComponentItem::create)
             .lang("IV Electric Pump")
+            .onRegister(attach(new TieredBehaviour(GTValues.IV)))
             .onRegister(attach(new CoverPlaceBehavior(GTCovers.PUMPS[4])))
             .onRegister(attach(new TooltipBehavior(lines -> {
                 lines.add(Component.translatable("item.gtceu.electric.pump.tooltip"));
@@ -776,6 +808,7 @@ public static ItemEntry<ComponentItem> createFluidCell(Material mat, int capacit
     public static ItemEntry<ComponentItem> ELECTRIC_PUMP_LuV = REGISTRATE
             .item("luv_electric_pump", ComponentItem::create)
             .lang("LuV Electric Pump")
+            .onRegister(attach(new TieredBehaviour(GTValues.LuV)))
             .onRegister(attach(new CoverPlaceBehavior(GTCovers.PUMPS[5])))
             .onRegister(attach(new TooltipBehavior(lines -> {
                 lines.add(Component.translatable("item.gtceu.electric.pump.tooltip"));
@@ -787,6 +820,7 @@ public static ItemEntry<ComponentItem> createFluidCell(Material mat, int capacit
     public static ItemEntry<ComponentItem> ELECTRIC_PUMP_ZPM = REGISTRATE
             .item("zpm_electric_pump", ComponentItem::create)
             .lang("ZPM Electric Pump")
+            .onRegister(attach(new TieredBehaviour(GTValues.ZPM)))
             .onRegister(attach(new CoverPlaceBehavior(GTCovers.PUMPS[6])))
             .onRegister(attach(new TooltipBehavior(lines -> {
                 lines.add(Component.translatable("item.gtceu.electric.pump.tooltip"));
@@ -797,6 +831,7 @@ public static ItemEntry<ComponentItem> createFluidCell(Material mat, int capacit
             .register();
     public static ItemEntry<ComponentItem> ELECTRIC_PUMP_UV = REGISTRATE.item("uv_electric_pump", ComponentItem::create)
             .lang("UV Electric Pump")
+            .onRegister(attach(new TieredBehaviour(GTValues.UV)))
             .onRegister(attach(new CoverPlaceBehavior(GTCovers.PUMPS[7])))
             .onRegister(attach(new TooltipBehavior(lines -> {
                 lines.add(Component.translatable("item.gtceu.electric.pump.tooltip"));
@@ -810,60 +845,70 @@ public static ItemEntry<ComponentItem> createFluidCell(Material mat, int capacit
     public static ItemEntry<ComponentItem> ELECTRIC_PUMP_UHV = GTCEuAPI.isHighTier() ?
             REGISTRATE.item("uhv_electric_pump", ComponentItem::create)
                     .lang("UHV Electric Pump")
+                    .onRegister(attach(new TieredBehaviour(GTValues.UHV)))
                     .onRegister(attach(new CoverPlaceBehavior(GTCovers.PUMPS[8])))
                     .onRegister(attach(new TooltipBehavior(lines -> {
                         lines.add(Component.translatable("item.gtceu.electric.pump.tooltip"));
                         lines.add(Component.translatable("gtceu.universal.tooltip.fluid_transfer_rate",
                                 1280 * 64 * 64 * 4 / 20));
                     })))
+                    .tag(CustomTags.ELECTRIC_PUMPS)
                     .register() :
             null;
 
     public static ItemEntry<ComponentItem> ELECTRIC_PUMP_UEV = GTCEuAPI.isHighTier() ?
             REGISTRATE.item("uev_electric_pump", ComponentItem::create)
                     .lang("UEV Electric Pump")
+                    .onRegister(attach(new TieredBehaviour(GTValues.UEV)))
                     .onRegister(attach(new CoverPlaceBehavior(GTCovers.PUMPS[9])))
                     .onRegister(attach(new TooltipBehavior(lines -> {
                         lines.add(Component.translatable("item.gtceu.electric.pump.tooltip"));
                         lines.add(Component.translatable("gtceu.universal.tooltip.fluid_transfer_rate",
                                 1280 * 64 * 64 * 4 / 20));
                     })))
+                    .tag(CustomTags.ELECTRIC_PUMPS)
                     .register() :
             null;
 
     public static ItemEntry<ComponentItem> ELECTRIC_PUMP_UIV = GTCEuAPI.isHighTier() ?
             REGISTRATE.item("uiv_electric_pump", ComponentItem::create)
                     .lang("UIV Electric Pump")
+                    .onRegister(attach(new TieredBehaviour(GTValues.UIV)))
                     .onRegister(attach(new CoverPlaceBehavior(GTCovers.PUMPS[10])))
                     .onRegister(attach(new TooltipBehavior(lines -> {
                         lines.add(Component.translatable("item.gtceu.electric.pump.tooltip"));
                         lines.add(Component.translatable("gtceu.universal.tooltip.fluid_transfer_rate",
                                 1280 * 64 * 64 * 4 / 20));
                     })))
+                    .tag(CustomTags.ELECTRIC_PUMPS)
                     .register() :
             null;
 
     public static ItemEntry<ComponentItem> ELECTRIC_PUMP_UXV = GTCEuAPI.isHighTier() ?
             REGISTRATE.item("uxv_electric_pump", ComponentItem::create)
                     .lang("UXV Electric Pump")
+                    .onRegister(attach(new TieredBehaviour(GTValues.UXV)))
                     .onRegister(attach(new CoverPlaceBehavior(GTCovers.PUMPS[11])))
                     .onRegister(attach(new TooltipBehavior(lines -> {
                         lines.add(Component.translatable("item.gtceu.electric.pump.tooltip"));
                         lines.add(Component.translatable("gtceu.universal.tooltip.fluid_transfer_rate",
                                 1280 * 64 * 64 * 4 / 20));
                     })))
+                    .tag(CustomTags.ELECTRIC_PUMPS)
                     .register() :
             null;
 
     public static ItemEntry<ComponentItem> ELECTRIC_PUMP_OpV = GTCEuAPI.isHighTier() ?
             REGISTRATE.item("opv_electric_pump", ComponentItem::create)
                     .lang("OpV Electric Pump")
+                    .onRegister(attach(new TieredBehaviour(GTValues.OpV)))
                     .onRegister(attach(new CoverPlaceBehavior(GTCovers.PUMPS[12])))
                     .onRegister(attach(new TooltipBehavior(lines -> {
                         lines.add(Component.translatable("item.gtceu.electric.pump.tooltip"));
                         lines.add(Component.translatable("gtceu.universal.tooltip.fluid_transfer_rate",
                                 1280 * 64 * 64 * 4 / 20));
                     })))
+                    .tag(CustomTags.ELECTRIC_PUMPS)
                     .register() :
             null;
 
@@ -1013,6 +1058,7 @@ public static ItemEntry<ComponentItem> createFluidCell(Material mat, int capacit
     public static ItemEntry<ComponentItem> CONVEYOR_MODULE_LV = REGISTRATE
             .item("lv_conveyor_module", ComponentItem::create)
             .lang("LV Conveyor Module")
+            .onRegister(attach(new TieredBehaviour(GTValues.LV)))
             .onRegister(attach(new CoverPlaceBehavior(GTCovers.CONVEYORS[0])))
             .onRegister(attach(new TooltipBehavior(lines -> {
                 lines.add(Component.translatable("item.gtceu.conveyor.module.tooltip"));
@@ -1023,6 +1069,7 @@ public static ItemEntry<ComponentItem> createFluidCell(Material mat, int capacit
     public static ItemEntry<ComponentItem> CONVEYOR_MODULE_MV = REGISTRATE
             .item("mv_conveyor_module", ComponentItem::create)
             .lang("MV Conveyor Module")
+            .onRegister(attach(new TieredBehaviour(GTValues.MV)))
             .onRegister(attach(new CoverPlaceBehavior(GTCovers.CONVEYORS[1])))
             .onRegister(attach(new TooltipBehavior(lines -> {
                 lines.add(Component.translatable("item.gtceu.conveyor.module.tooltip"));
@@ -1033,6 +1080,7 @@ public static ItemEntry<ComponentItem> createFluidCell(Material mat, int capacit
     public static ItemEntry<ComponentItem> CONVEYOR_MODULE_HV = REGISTRATE
             .item("hv_conveyor_module", ComponentItem::create)
             .lang("HV Conveyor Module")
+            .onRegister(attach(new TieredBehaviour(GTValues.HV)))
             .onRegister(attach(new CoverPlaceBehavior(GTCovers.CONVEYORS[2])))
             .onRegister(attach(new TooltipBehavior(lines -> {
                 lines.add(Component.translatable("item.gtceu.conveyor.module.tooltip"));
@@ -1043,6 +1091,7 @@ public static ItemEntry<ComponentItem> createFluidCell(Material mat, int capacit
     public static ItemEntry<ComponentItem> CONVEYOR_MODULE_EV = REGISTRATE
             .item("ev_conveyor_module", ComponentItem::create)
             .lang("EV Conveyor Module")
+            .onRegister(attach(new TieredBehaviour(GTValues.EV)))
             .onRegister(attach(new CoverPlaceBehavior(GTCovers.CONVEYORS[3])))
             .onRegister(attach(new TooltipBehavior(lines -> {
                 lines.add(Component.translatable("item.gtceu.conveyor.module.tooltip"));
@@ -1053,6 +1102,7 @@ public static ItemEntry<ComponentItem> createFluidCell(Material mat, int capacit
     public static ItemEntry<ComponentItem> CONVEYOR_MODULE_IV = REGISTRATE
             .item("iv_conveyor_module", ComponentItem::create)
             .lang("IV Conveyor Module")
+            .onRegister(attach(new TieredBehaviour(GTValues.IV)))
             .onRegister(attach(new CoverPlaceBehavior(GTCovers.CONVEYORS[4])))
             .onRegister(attach(new TooltipBehavior(lines -> {
                 lines.add(Component.translatable("item.gtceu.conveyor.module.tooltip"));
@@ -1063,6 +1113,7 @@ public static ItemEntry<ComponentItem> createFluidCell(Material mat, int capacit
     public static ItemEntry<ComponentItem> CONVEYOR_MODULE_LuV = REGISTRATE
             .item("luv_conveyor_module", ComponentItem::create)
             .lang("LuV Conveyor Module")
+            .onRegister(attach(new TieredBehaviour(GTValues.LuV)))
             .onRegister(attach(new CoverPlaceBehavior(GTCovers.CONVEYORS[5])))
             .onRegister(attach(new TooltipBehavior(lines -> {
                 lines.add(Component.translatable("item.gtceu.conveyor.module.tooltip"));
@@ -1073,6 +1124,7 @@ public static ItemEntry<ComponentItem> createFluidCell(Material mat, int capacit
     public static ItemEntry<ComponentItem> CONVEYOR_MODULE_ZPM = REGISTRATE
             .item("zpm_conveyor_module", ComponentItem::create)
             .lang("ZPM Conveyor Module")
+            .onRegister(attach(new TieredBehaviour(GTValues.ZPM)))
             .onRegister(attach(new CoverPlaceBehavior(GTCovers.CONVEYORS[6])))
             .onRegister(attach(new TooltipBehavior(lines -> {
                 lines.add(Component.translatable("item.gtceu.conveyor.module.tooltip"));
@@ -1083,6 +1135,7 @@ public static ItemEntry<ComponentItem> createFluidCell(Material mat, int capacit
     public static ItemEntry<ComponentItem> CONVEYOR_MODULE_UV = REGISTRATE
             .item("uv_conveyor_module", ComponentItem::create)
             .lang("UV Conveyor Module")
+            .onRegister(attach(new TieredBehaviour(GTValues.UV)))
             .onRegister(attach(new CoverPlaceBehavior(GTCovers.CONVEYORS[7])))
             .onRegister(attach(new TooltipBehavior(lines -> {
                 lines.add(Component.translatable("item.gtceu.conveyor.module.tooltip"));
@@ -1093,6 +1146,7 @@ public static ItemEntry<ComponentItem> createFluidCell(Material mat, int capacit
     public static ItemEntry<ComponentItem> CONVEYOR_MODULE_UHV = GTCEuAPI.isHighTier() ?
             REGISTRATE.item("uhv_conveyor_module", ComponentItem::create)
                     .lang("UHV Conveyor Module")
+                    .onRegister(attach(new TieredBehaviour(GTValues.UHV)))
                     .onRegister(attach(new CoverPlaceBehavior(GTCovers.CONVEYORS[8])))
                     .onRegister(attach(new TooltipBehavior(lines -> {
                         lines.add(Component.translatable("item.gtceu.conveyor.module.tooltip"));
@@ -1103,6 +1157,7 @@ public static ItemEntry<ComponentItem> createFluidCell(Material mat, int capacit
     public static ItemEntry<ComponentItem> CONVEYOR_MODULE_UEV = GTCEuAPI.isHighTier() ?
             REGISTRATE.item("uev_conveyor_module", ComponentItem::create)
                     .lang("UEV Conveyor Module")
+                    .onRegister(attach(new TieredBehaviour(GTValues.UEV)))
                     .onRegister(attach(new CoverPlaceBehavior(GTCovers.CONVEYORS[9])))
                     .onRegister(attach(new TooltipBehavior(lines -> {
                         lines.add(Component.translatable("item.gtceu.conveyor.module.tooltip"));
@@ -1113,6 +1168,7 @@ public static ItemEntry<ComponentItem> createFluidCell(Material mat, int capacit
     public static ItemEntry<ComponentItem> CONVEYOR_MODULE_UIV = GTCEuAPI.isHighTier() ?
             REGISTRATE.item("uiv_conveyor_module", ComponentItem::create)
                     .lang("UIV Conveyor Module")
+                    .onRegister(attach(new TieredBehaviour(GTValues.UIV)))
                     .onRegister(attach(new CoverPlaceBehavior(GTCovers.CONVEYORS[10])))
                     .onRegister(attach(new TooltipBehavior(lines -> {
                         lines.add(Component.translatable("item.gtceu.conveyor.module.tooltip"));
@@ -1123,6 +1179,7 @@ public static ItemEntry<ComponentItem> createFluidCell(Material mat, int capacit
     public static ItemEntry<ComponentItem> CONVEYOR_MODULE_UXV = GTCEuAPI.isHighTier() ?
             REGISTRATE.item("uxv_conveyor_module", ComponentItem::create)
                     .lang("UXV Conveyor Module")
+                    .onRegister(attach(new TieredBehaviour(GTValues.UXV)))
                     .onRegister(attach(new CoverPlaceBehavior(GTCovers.CONVEYORS[11])))
                     .onRegister(attach(new TooltipBehavior(lines -> {
                         lines.add(Component.translatable("item.gtceu.conveyor.module.tooltip"));
@@ -1133,6 +1190,7 @@ public static ItemEntry<ComponentItem> createFluidCell(Material mat, int capacit
     public static ItemEntry<ComponentItem> CONVEYOR_MODULE_OpV = GTCEuAPI.isHighTier() ?
             REGISTRATE.item("opv_conveyor_module", ComponentItem::create)
                     .lang("OpV Conveyor Module")
+                    .onRegister(attach(new TieredBehaviour(GTValues.OpV)))
                     .onRegister(attach(new CoverPlaceBehavior(GTCovers.CONVEYORS[12])))
                     .onRegister(attach(new TooltipBehavior(lines -> {
                         lines.add(Component.translatable("item.gtceu.conveyor.module.tooltip"));
@@ -1141,36 +1199,52 @@ public static ItemEntry<ComponentItem> createFluidCell(Material mat, int capacit
                     .register() :
             null;
 
-    public static ItemEntry<Item> ELECTRIC_PISTON_LV = REGISTRATE.item("lv_electric_piston", Item::new)
+    public static ItemEntry<ComponentItem> ELECTRIC_PISTON_LV = REGISTRATE
+            .item("lv_electric_piston", ComponentItem::create)
             .lang("LV Electric Piston")
+            .onRegister(attach(new TieredBehaviour(GTValues.LV)))
             .tag(CustomTags.ELECTRIC_PISTONS)
             .register();
-    public static ItemEntry<Item> ELECTRIC_PISTON_MV = REGISTRATE.item("mv_electric_piston", Item::new)
+    public static ItemEntry<ComponentItem> ELECTRIC_PISTON_MV = REGISTRATE
+            .item("mv_electric_piston", ComponentItem::create)
             .lang("MV Electric Piston")
+            .onRegister(attach(new TieredBehaviour(GTValues.MV)))
             .tag(CustomTags.ELECTRIC_PISTONS)
             .register();
-    public static ItemEntry<Item> ELECTRIC_PISTON_HV = REGISTRATE.item("hv_electric_piston", Item::new)
+    public static ItemEntry<ComponentItem> ELECTRIC_PISTON_HV = REGISTRATE
+            .item("hv_electric_piston", ComponentItem::create)
             .lang("HV Electric Piston")
+            .onRegister(attach(new TieredBehaviour(GTValues.HV)))
             .tag(CustomTags.ELECTRIC_PISTONS)
             .register();
-    public static ItemEntry<Item> ELECTRIC_PISTON_EV = REGISTRATE.item("ev_electric_piston", Item::new)
+    public static ItemEntry<ComponentItem> ELECTRIC_PISTON_EV = REGISTRATE
+            .item("ev_electric_piston", ComponentItem::create)
             .lang("EV Electric Piston")
+            .onRegister(attach(new TieredBehaviour(GTValues.EV)))
             .tag(CustomTags.ELECTRIC_PISTONS)
             .register();
-    public static ItemEntry<Item> ELECTRIC_PISTON_IV = REGISTRATE.item("iv_electric_piston", Item::new)
+    public static ItemEntry<ComponentItem> ELECTRIC_PISTON_IV = REGISTRATE
+            .item("iv_electric_piston", ComponentItem::create)
             .lang("IV Electric Piston")
+            .onRegister(attach(new TieredBehaviour(GTValues.IV)))
             .tag(CustomTags.ELECTRIC_PISTONS)
             .register();
-    public static ItemEntry<Item> ELECTRIC_PISTON_LuV = REGISTRATE.item("luv_electric_piston", Item::new)
+    public static ItemEntry<ComponentItem> ELECTRIC_PISTON_LuV = REGISTRATE
+            .item("luv_electric_piston", ComponentItem::create)
             .lang("LuV Electric Piston")
+            .onRegister(attach(new TieredBehaviour(GTValues.LuV)))
             .tag(CustomTags.ELECTRIC_PISTONS)
             .register();
-    public static ItemEntry<Item> ELECTRIC_PISTON_ZPM = REGISTRATE.item("zpm_electric_piston", Item::new)
+    public static ItemEntry<ComponentItem> ELECTRIC_PISTON_ZPM = REGISTRATE
+            .item("zpm_electric_piston", ComponentItem::create)
             .lang("ZPM Electric Piston")
+            .onRegister(attach(new TieredBehaviour(GTValues.ZPM)))
             .tag(CustomTags.ELECTRIC_PISTONS)
             .register();
-    public static ItemEntry<Item> ELECTRIC_PISTON_UV = REGISTRATE.item("uv_electric_piston", Item::new)
+    public static ItemEntry<ComponentItem> ELECTRIC_PISTON_UV = REGISTRATE
+            .item("uv_electric_piston", ComponentItem::create)
             .lang("UV Electric Piston")
+            .onRegister(attach(new TieredBehaviour(GTValues.UV)))
             .tag(CustomTags.ELECTRIC_PISTONS)
             .register();
     public static ItemEntry<Item> ELECTRIC_PISTON_UHV = GTCEuAPI.isHighTier() ?
@@ -1196,7 +1270,7 @@ public static ItemEntry<ComponentItem> createFluidCell(Material mat, int capacit
 
     public static ItemEntry<ComponentItem> ROBOT_ARM_LV = REGISTRATE.item("lv_robot_arm", ComponentItem::create)
             .lang("LV Robot Arm")
-            .onRegister(attach(new CoverPlaceBehavior(GTCovers.ROBOT_ARMS[0])))
+            .onRegister(attach(new CoverPlaceBehavior(GTCovers.ROBOT_ARMS[0]), new TieredBehaviour(GTValues.LV)))
             .onRegister(attach(new TooltipBehavior(lines -> {
                 lines.add(Component.translatable("item.gtceu.robot.arm.tooltip"));
                 lines.add(Component.translatable("gtceu.universal.tooltip.item_transfer_rate", 8));
@@ -1205,7 +1279,7 @@ public static ItemEntry<ComponentItem> createFluidCell(Material mat, int capacit
             .register();
     public static ItemEntry<ComponentItem> ROBOT_ARM_MV = REGISTRATE.item("mv_robot_arm", ComponentItem::create)
             .lang("MV Robot Arm")
-            .onRegister(attach(new CoverPlaceBehavior(GTCovers.ROBOT_ARMS[1])))
+            .onRegister(attach(new CoverPlaceBehavior(GTCovers.ROBOT_ARMS[1]), new TieredBehaviour(GTValues.MV)))
             .onRegister(attach(new TooltipBehavior(lines -> {
                 lines.add(Component.translatable("item.gtceu.robot.arm.tooltip"));
                 lines.add(Component.translatable("gtceu.universal.tooltip.item_transfer_rate", 32));
@@ -1214,7 +1288,7 @@ public static ItemEntry<ComponentItem> createFluidCell(Material mat, int capacit
             .register();
     public static ItemEntry<ComponentItem> ROBOT_ARM_HV = REGISTRATE.item("hv_robot_arm", ComponentItem::create)
             .lang("HV Robot Arm")
-            .onRegister(attach(new CoverPlaceBehavior(GTCovers.ROBOT_ARMS[2])))
+            .onRegister(attach(new CoverPlaceBehavior(GTCovers.ROBOT_ARMS[2]), new TieredBehaviour(GTValues.HV)))
             .onRegister(attach(new TooltipBehavior(lines -> {
                 lines.add(Component.translatable("item.gtceu.robot.arm.tooltip"));
                 lines.add(Component.translatable("gtceu.universal.tooltip.item_transfer_rate", 64));
@@ -1223,7 +1297,7 @@ public static ItemEntry<ComponentItem> createFluidCell(Material mat, int capacit
             .register();
     public static ItemEntry<ComponentItem> ROBOT_ARM_EV = REGISTRATE.item("ev_robot_arm", ComponentItem::create)
             .lang("EV Robot Arm")
-            .onRegister(attach(new CoverPlaceBehavior(GTCovers.ROBOT_ARMS[3])))
+            .onRegister(attach(new CoverPlaceBehavior(GTCovers.ROBOT_ARMS[3]), new TieredBehaviour(GTValues.EV)))
             .onRegister(attach(new TooltipBehavior(lines -> {
                 lines.add(Component.translatable("item.gtceu.robot.arm.tooltip"));
                 lines.add(Component.translatable("gtceu.universal.tooltip.item_transfer_rate_stacks", 3));
@@ -1232,7 +1306,7 @@ public static ItemEntry<ComponentItem> createFluidCell(Material mat, int capacit
             .register();
     public static ItemEntry<ComponentItem> ROBOT_ARM_IV = REGISTRATE.item("iv_robot_arm", ComponentItem::create)
             .lang("IV Robot Arm")
-            .onRegister(attach(new CoverPlaceBehavior(GTCovers.ROBOT_ARMS[4])))
+            .onRegister(attach(new CoverPlaceBehavior(GTCovers.ROBOT_ARMS[4]), new TieredBehaviour(GTValues.IV)))
             .onRegister(attach(new TooltipBehavior(lines -> {
                 lines.add(Component.translatable("item.gtceu.robot.arm.tooltip"));
                 lines.add(Component.translatable("gtceu.universal.tooltip.item_transfer_rate_stacks", 8));
@@ -1241,7 +1315,7 @@ public static ItemEntry<ComponentItem> createFluidCell(Material mat, int capacit
             .register();
     public static ItemEntry<ComponentItem> ROBOT_ARM_LuV = REGISTRATE.item("luv_robot_arm", ComponentItem::create)
             .lang("LuV Robot Arm")
-            .onRegister(attach(new CoverPlaceBehavior(GTCovers.ROBOT_ARMS[5])))
+            .onRegister(attach(new CoverPlaceBehavior(GTCovers.ROBOT_ARMS[5]), new TieredBehaviour(GTValues.LuV)))
             .onRegister(attach(new TooltipBehavior(lines -> {
                 lines.add(Component.translatable("item.gtceu.robot.arm.tooltip"));
                 lines.add(Component.translatable("gtceu.universal.tooltip.item_transfer_rate_stacks", 16));
@@ -1250,7 +1324,7 @@ public static ItemEntry<ComponentItem> createFluidCell(Material mat, int capacit
             .register();
     public static ItemEntry<ComponentItem> ROBOT_ARM_ZPM = REGISTRATE.item("zpm_robot_arm", ComponentItem::create)
             .lang("ZPM Robot Arm")
-            .onRegister(attach(new CoverPlaceBehavior(GTCovers.ROBOT_ARMS[6])))
+            .onRegister(attach(new CoverPlaceBehavior(GTCovers.ROBOT_ARMS[6]), new TieredBehaviour(GTValues.ZPM)))
             .onRegister(attach(new TooltipBehavior(lines -> {
                 lines.add(Component.translatable("item.gtceu.robot.arm.tooltip"));
                 lines.add(Component.translatable("gtceu.universal.tooltip.item_transfer_rate_stacks", 16));
@@ -1259,7 +1333,7 @@ public static ItemEntry<ComponentItem> createFluidCell(Material mat, int capacit
             .register();
     public static ItemEntry<ComponentItem> ROBOT_ARM_UV = REGISTRATE.item("uv_robot_arm", ComponentItem::create)
             .lang("UV Robot Arm")
-            .onRegister(attach(new CoverPlaceBehavior(GTCovers.ROBOT_ARMS[7])))
+            .onRegister(attach(new CoverPlaceBehavior(GTCovers.ROBOT_ARMS[7]), new TieredBehaviour(GTValues.UV)))
             .onRegister(attach(new TooltipBehavior(lines -> {
                 lines.add(Component.translatable("item.gtceu.robot.arm.tooltip"));
                 lines.add(Component.translatable("gtceu.universal.tooltip.item_transfer_rate_stacks", 16));
@@ -1269,7 +1343,8 @@ public static ItemEntry<ComponentItem> createFluidCell(Material mat, int capacit
     public static ItemEntry<ComponentItem> ROBOT_ARM_UHV = GTCEuAPI.isHighTier() ?
             REGISTRATE.item("uhv_robot_arm", ComponentItem::create)
                     .lang("UHV Robot Arm")
-                    .onRegister(attach(new CoverPlaceBehavior(GTCovers.ROBOT_ARMS[8])))
+                    .onRegister(
+                            attach(new CoverPlaceBehavior(GTCovers.ROBOT_ARMS[8]), new TieredBehaviour(GTValues.UHV)))
                     .onRegister(attach(new TooltipBehavior(lines -> {
                         lines.add(Component.translatable("item.gtceu.robot.arm.tooltip"));
                         lines.add(Component.translatable("gtceu.universal.tooltip.item_transfer_rate_stacks", 16));
@@ -1279,7 +1354,8 @@ public static ItemEntry<ComponentItem> createFluidCell(Material mat, int capacit
     public static ItemEntry<ComponentItem> ROBOT_ARM_UEV = GTCEuAPI.isHighTier() ?
             REGISTRATE.item("uev_robot_arm", ComponentItem::create)
                     .lang("UEV Robot Arm")
-                    .onRegister(attach(new CoverPlaceBehavior(GTCovers.ROBOT_ARMS[9])))
+                    .onRegister(
+                            attach(new CoverPlaceBehavior(GTCovers.ROBOT_ARMS[9]), new TieredBehaviour(GTValues.UEV)))
                     .onRegister(attach(new TooltipBehavior(lines -> {
                         lines.add(Component.translatable("item.gtceu.robot.arm.tooltip"));
                         lines.add(Component.translatable("gtceu.universal.tooltip.item_transfer_rate_stacks", 16));
@@ -1289,7 +1365,8 @@ public static ItemEntry<ComponentItem> createFluidCell(Material mat, int capacit
     public static ItemEntry<ComponentItem> ROBOT_ARM_UIV = GTCEuAPI.isHighTier() ?
             REGISTRATE.item("uiv_robot_arm", ComponentItem::create)
                     .lang("UIV Robot Arm")
-                    .onRegister(attach(new CoverPlaceBehavior(GTCovers.ROBOT_ARMS[10])))
+                    .onRegister(
+                            attach(new CoverPlaceBehavior(GTCovers.ROBOT_ARMS[10]), new TieredBehaviour(GTValues.UIV)))
                     .onRegister(attach(new TooltipBehavior(lines -> {
                         lines.add(Component.translatable("item.gtceu.robot.arm.tooltip"));
                         lines.add(Component.translatable("gtceu.universal.tooltip.item_transfer_rate_stacks", 16));
@@ -1299,7 +1376,8 @@ public static ItemEntry<ComponentItem> createFluidCell(Material mat, int capacit
     public static ItemEntry<ComponentItem> ROBOT_ARM_UXV = GTCEuAPI.isHighTier() ?
             REGISTRATE.item("uxv_robot_arm", ComponentItem::create)
                     .lang("UXV Robot Arm")
-                    .onRegister(attach(new CoverPlaceBehavior(GTCovers.ROBOT_ARMS[11])))
+                    .onRegister(
+                            attach(new CoverPlaceBehavior(GTCovers.ROBOT_ARMS[11]), new TieredBehaviour(GTValues.UXV)))
                     .onRegister(attach(new TooltipBehavior(lines -> {
                         lines.add(Component.translatable("item.gtceu.robot.arm.tooltip"));
                         lines.add(Component.translatable("gtceu.universal.tooltip.item_transfer_rate_stacks", 16));
@@ -1309,7 +1387,8 @@ public static ItemEntry<ComponentItem> createFluidCell(Material mat, int capacit
     public static ItemEntry<ComponentItem> ROBOT_ARM_OpV = GTCEuAPI.isHighTier() ?
             REGISTRATE.item("opv_robot_arm", ComponentItem::create)
                     .lang("OpV Robot Arm")
-                    .onRegister(attach(new CoverPlaceBehavior(GTCovers.ROBOT_ARMS[12])))
+                    .onRegister(
+                            attach(new CoverPlaceBehavior(GTCovers.ROBOT_ARMS[12]), new TieredBehaviour(GTValues.OpV)))
                     .onRegister(attach(new TooltipBehavior(lines -> {
                         lines.add(Component.translatable("item.gtceu.robot.arm.tooltip"));
                         lines.add(Component.translatable("gtceu.universal.tooltip.item_transfer_rate_stacks", 16));
@@ -1317,36 +1396,52 @@ public static ItemEntry<ComponentItem> createFluidCell(Material mat, int capacit
                     .register() :
             null;
 
-    public static ItemEntry<Item> FIELD_GENERATOR_LV = REGISTRATE.item("lv_field_generator", Item::new)
+    public static ItemEntry<ComponentItem> FIELD_GENERATOR_LV = REGISTRATE
+            .item("lv_field_generator", ComponentItem::create)
             .lang("LV Field Generator")
+            .onRegister(attach(new TieredBehaviour(GTValues.LV)))
             .tag(CustomTags.FIELD_GENERATORS)
             .register();
-    public static ItemEntry<Item> FIELD_GENERATOR_MV = REGISTRATE.item("mv_field_generator", Item::new)
+    public static ItemEntry<ComponentItem> FIELD_GENERATOR_MV = REGISTRATE
+            .item("mv_field_generator", ComponentItem::create)
             .lang("MV Field Generator")
+            .onRegister(attach(new TieredBehaviour(GTValues.MV)))
             .tag(CustomTags.FIELD_GENERATORS)
             .register();
-    public static ItemEntry<Item> FIELD_GENERATOR_HV = REGISTRATE.item("hv_field_generator", Item::new)
+    public static ItemEntry<ComponentItem> FIELD_GENERATOR_HV = REGISTRATE
+            .item("hv_field_generator", ComponentItem::create)
             .lang("HV Field Generator")
+            .onRegister(attach(new TieredBehaviour(GTValues.HV)))
             .tag(CustomTags.FIELD_GENERATORS)
             .register();
-    public static ItemEntry<Item> FIELD_GENERATOR_EV = REGISTRATE.item("ev_field_generator", Item::new)
+    public static ItemEntry<ComponentItem> FIELD_GENERATOR_EV = REGISTRATE
+            .item("ev_field_generator", ComponentItem::create)
             .lang("EV Field Generator")
+            .onRegister(attach(new TieredBehaviour(GTValues.EV)))
             .tag(CustomTags.FIELD_GENERATORS)
             .register();
-    public static ItemEntry<Item> FIELD_GENERATOR_IV = REGISTRATE.item("iv_field_generator", Item::new)
+    public static ItemEntry<ComponentItem> FIELD_GENERATOR_IV = REGISTRATE
+            .item("iv_field_generator", ComponentItem::create)
             .lang("IV Field Generator")
+            .onRegister(attach(new TieredBehaviour(GTValues.IV)))
             .tag(CustomTags.FIELD_GENERATORS)
             .register();
-    public static ItemEntry<Item> FIELD_GENERATOR_LuV = REGISTRATE.item("luv_field_generator", Item::new)
+    public static ItemEntry<ComponentItem> FIELD_GENERATOR_LuV = REGISTRATE
+            .item("luv_field_generator", ComponentItem::create)
             .lang("LuV Field Generator")
+            .onRegister(attach(new TieredBehaviour(GTValues.LuV)))
             .tag(CustomTags.FIELD_GENERATORS)
             .register();
-    public static ItemEntry<Item> FIELD_GENERATOR_ZPM = REGISTRATE.item("zpm_field_generator", Item::new)
+    public static ItemEntry<ComponentItem> FIELD_GENERATOR_ZPM = REGISTRATE
+            .item("zpm_field_generator", ComponentItem::create)
             .lang("ZPM Field Generator")
+            .onRegister(attach(new TieredBehaviour(GTValues.ZPM)))
             .tag(CustomTags.FIELD_GENERATORS)
             .register();
-    public static ItemEntry<Item> FIELD_GENERATOR_UV = REGISTRATE.item("uv_field_generator", Item::new)
+    public static ItemEntry<ComponentItem> FIELD_GENERATOR_UV = REGISTRATE
+            .item("uv_field_generator", ComponentItem::create)
             .lang("UV Field Generator")
+            .onRegister(attach(new TieredBehaviour(GTValues.UV)))
             .tag(CustomTags.FIELD_GENERATORS)
             .register();
     public static ItemEntry<Item> FIELD_GENERATOR_UHV = GTCEuAPI.isHighTier() ?
@@ -1370,28 +1465,44 @@ public static ItemEntry<ComponentItem> createFluidCell(Material mat, int capacit
                     .register() :
             null;
 
-    public static ItemEntry<Item> EMITTER_LV = REGISTRATE.item("lv_emitter", Item::new).lang("LV Emitter")
+    public static ItemEntry<ComponentItem> EMITTER_LV = REGISTRATE.item("lv_emitter", ComponentItem::create)
+            .lang("LV Emitter")
+            .onRegister(attach(new TieredBehaviour(GTValues.LV)))
             .tag(CustomTags.EMITTERS)
             .register();
-    public static ItemEntry<Item> EMITTER_MV = REGISTRATE.item("mv_emitter", Item::new).lang("MV Emitter")
+    public static ItemEntry<ComponentItem> EMITTER_MV = REGISTRATE.item("mv_emitter", ComponentItem::create)
+            .lang("MV Emitter")
+            .onRegister(attach(new TieredBehaviour(GTValues.MV)))
             .tag(CustomTags.EMITTERS)
             .register();
-    public static ItemEntry<Item> EMITTER_HV = REGISTRATE.item("hv_emitter", Item::new).lang("HV Emitter")
+    public static ItemEntry<ComponentItem> EMITTER_HV = REGISTRATE.item("hv_emitter", ComponentItem::create)
+            .lang("HV Emitter")
+            .onRegister(attach(new TieredBehaviour(GTValues.HV)))
             .tag(CustomTags.EMITTERS)
             .register();
-    public static ItemEntry<Item> EMITTER_EV = REGISTRATE.item("ev_emitter", Item::new).lang("EV Emitter")
+    public static ItemEntry<ComponentItem> EMITTER_EV = REGISTRATE.item("ev_emitter", ComponentItem::create)
+            .lang("EV Emitter")
+            .onRegister(attach(new TieredBehaviour(GTValues.EV)))
             .tag(CustomTags.EMITTERS)
             .register();
-    public static ItemEntry<Item> EMITTER_IV = REGISTRATE.item("iv_emitter", Item::new).lang("IV Emitter")
+    public static ItemEntry<ComponentItem> EMITTER_IV = REGISTRATE.item("iv_emitter", ComponentItem::create)
+            .lang("IV Emitter")
+            .onRegister(attach(new TieredBehaviour(GTValues.IV)))
             .tag(CustomTags.EMITTERS)
             .register();
-    public static ItemEntry<Item> EMITTER_LuV = REGISTRATE.item("luv_emitter", Item::new).lang("LuV Emitter")
+    public static ItemEntry<ComponentItem> EMITTER_LuV = REGISTRATE.item("luv_emitter", ComponentItem::create)
+            .lang("LuV Emitter")
+            .onRegister(attach(new TieredBehaviour(GTValues.LuV)))
             .tag(CustomTags.EMITTERS)
             .register();
-    public static ItemEntry<Item> EMITTER_ZPM = REGISTRATE.item("zpm_emitter", Item::new).lang("ZPM Emitter")
+    public static ItemEntry<ComponentItem> EMITTER_ZPM = REGISTRATE.item("zpm_emitter", ComponentItem::create)
+            .lang("ZPM Emitter")
+            .onRegister(attach(new TieredBehaviour(GTValues.ZPM)))
             .tag(CustomTags.EMITTERS)
             .register();
-    public static ItemEntry<Item> EMITTER_UV = REGISTRATE.item("uv_emitter", Item::new).lang("UV Emitter")
+    public static ItemEntry<ComponentItem> EMITTER_UV = REGISTRATE.item("uv_emitter", ComponentItem::create)
+            .lang("UV Emitter")
+            .onRegister(attach(new TieredBehaviour(GTValues.UV)))
             .tag(CustomTags.EMITTERS)
             .register();
     public static ItemEntry<Item> EMITTER_UHV = GTCEuAPI.isHighTier() ? REGISTRATE.item("uhv_emitter", Item::new)
@@ -1410,28 +1521,44 @@ public static ItemEntry<ComponentItem> createFluidCell(Material mat, int capacit
             .lang("OpV Emitter")
             .register() : null;
 
-    public static ItemEntry<Item> SENSOR_LV = REGISTRATE.item("lv_sensor", Item::new).lang("LV Sensor")
+    public static ItemEntry<ComponentItem> SENSOR_LV = REGISTRATE.item("lv_sensor", ComponentItem::create)
+            .lang("LV Sensor")
+            .onRegister(attach(new TieredBehaviour(GTValues.LV), new ChargingLinkingBehaviour()))
             .tag(CustomTags.SENSORS)
             .register();
-    public static ItemEntry<Item> SENSOR_MV = REGISTRATE.item("mv_sensor", Item::new).lang("MV Sensor")
+    public static ItemEntry<ComponentItem> SENSOR_MV = REGISTRATE.item("mv_sensor", ComponentItem::create)
+            .lang("MV Sensor")
+            .onRegister(attach(new TieredBehaviour(GTValues.MV), new ChargingLinkingBehaviour()))
             .tag(CustomTags.SENSORS)
             .register();
-    public static ItemEntry<Item> SENSOR_HV = REGISTRATE.item("hv_sensor", Item::new).lang("HV Sensor")
+    public static ItemEntry<ComponentItem> SENSOR_HV = REGISTRATE.item("hv_sensor", ComponentItem::create)
+            .lang("HV Sensor")
+            .onRegister(attach(new TieredBehaviour(GTValues.HV), new ChargingLinkingBehaviour()))
             .tag(CustomTags.SENSORS)
             .register();
-    public static ItemEntry<Item> SENSOR_EV = REGISTRATE.item("ev_sensor", Item::new).lang("EV Sensor")
+    public static ItemEntry<ComponentItem> SENSOR_EV = REGISTRATE.item("ev_sensor", ComponentItem::create)
+            .lang("EV Sensor")
+            .onRegister(attach(new TieredBehaviour(GTValues.EV), new ChargingLinkingBehaviour()))
             .tag(CustomTags.SENSORS)
             .register();
-    public static ItemEntry<Item> SENSOR_IV = REGISTRATE.item("iv_sensor", Item::new).lang("IV Sensor")
+    public static ItemEntry<ComponentItem> SENSOR_IV = REGISTRATE.item("iv_sensor", ComponentItem::create)
+            .lang("IV Sensor")
+            .onRegister(attach(new TieredBehaviour(GTValues.IV), new ChargingLinkingBehaviour()))
             .tag(CustomTags.SENSORS)
             .register();
-    public static ItemEntry<Item> SENSOR_LuV = REGISTRATE.item("luv_sensor", Item::new).lang("LuV Sensor")
+    public static ItemEntry<ComponentItem> SENSOR_LuV = REGISTRATE.item("luv_sensor", ComponentItem::create)
+            .lang("LuV Sensor")
+            .onRegister(attach(new TieredBehaviour(GTValues.LuV), new ChargingLinkingBehaviour()))
             .tag(CustomTags.SENSORS)
             .register();
-    public static ItemEntry<Item> SENSOR_ZPM = REGISTRATE.item("zpm_sensor", Item::new).lang("ZPM Sensor")
+    public static ItemEntry<ComponentItem> SENSOR_ZPM = REGISTRATE.item("zpm_sensor", ComponentItem::create)
+            .lang("ZPM Sensor")
+            .onRegister(attach(new TieredBehaviour(GTValues.ZPM), new ChargingLinkingBehaviour()))
             .tag(CustomTags.SENSORS)
             .register();
-    public static ItemEntry<Item> SENSOR_UV = REGISTRATE.item("uv_sensor", Item::new).lang("UV Sensor")
+    public static ItemEntry<ComponentItem> SENSOR_UV = REGISTRATE.item("uv_sensor", ComponentItem::create)
+            .lang("UV Sensor")
+            .onRegister(attach(new TieredBehaviour(GTValues.UV), new ChargingLinkingBehaviour()))
             .tag(CustomTags.SENSORS)
             .register();
     public static ItemEntry<Item> SENSOR_UHV = GTCEuAPI.isHighTier() ? REGISTRATE.item("uhv_sensor", Item::new)
@@ -1786,7 +1913,7 @@ public static ItemEntry<ComponentItem> createFluidCell(Material mat, int capacit
 
     /////////////////////////////////////////
     // *********** COVERS ***********//
-    /////////////////////////////////////////
+    /// //////////////////////////////////////
 
     public static ItemEntry<ComponentItem> ITEM_FILTER = REGISTRATE.item("item_filter", ComponentItem::create)
             .onRegister(attach(new ItemFilterBehaviour(SimpleItemFilter::loadFilter),
@@ -2185,6 +2312,7 @@ public static ItemEntry<ComponentItem> createFluidCell(Material mat, int capacit
             .register();
 
     public static final ItemEntry<DyeItem>[] DYE_ONLY_ITEMS = new ItemEntry[DyeColor.values().length];
+
     static {
         DyeColor[] colors = DyeColor.values();
         for (int i = 0; i < colors.length; i++) {
@@ -2198,6 +2326,7 @@ public static ItemEntry<ComponentItem> createFluidCell(Material mat, int capacit
     }
 
     public static final ItemEntry<ComponentItem>[] SPRAY_CAN_DYES = new ItemEntry[DyeColor.values().length];
+
     static {
         for (int i = 0; i < DyeColor.values().length; i++) {
             var dyeColor = DyeColor.values()[i];
@@ -2281,52 +2410,37 @@ public static ItemEntry<ComponentItem> createFluidCell(Material mat, int capacit
             .tag(Tags.Items.ARMORS_HELMETS)
             .register();
 
-    public static ItemEntry<ArmorComponentItem> NANO_CHESTPLATE = REGISTRATE
+    public static ItemEntry<ModularArmorItem> NANO_CHESTPLATE = REGISTRATE
             .item("nanomuscle_chestplate",
-                    (p) -> new ArmorComponentItem(GTArmorMaterials.ARMOR, ArmorItem.Type.CHESTPLATE, p)
-                            .setArmorLogic(new NanoMuscleSuite(ArmorItem.Type.CHESTPLATE,
-                                    512,
-                                    6_400_000L * (long) Math.max(1,
-                                            Math.pow(4, ConfigHolder.INSTANCE.tools.voltageTierNanoSuit - 3)),
-                                    ConfigHolder.INSTANCE.tools.voltageTierNanoSuit)))
+                    (p) -> new ModularArmorItem(GTArmorMaterials.NANO_MUSCLE, ArmorItem.Type.CHESTPLATE, p))
             .lang("NanoMuscle™ Suite Chestplate")
             .properties(p -> p.rarity(Rarity.UNCOMMON))
             .tag(Tags.Items.ARMORS_CHESTPLATES)
+            .onRegister(attach(new ModularItemComponent(4, GTValues.EV)))
             .register();
-    public static ItemEntry<ArmorComponentItem> NANO_LEGGINGS = REGISTRATE
+    public static ItemEntry<ModularArmorItem> NANO_LEGGINGS = REGISTRATE
             .item("nanomuscle_leggings",
-                    (p) -> new ArmorComponentItem(GTArmorMaterials.ARMOR, ArmorItem.Type.LEGGINGS, p)
-                            .setArmorLogic(new NanoMuscleSuite(ArmorItem.Type.LEGGINGS,
-                                    512,
-                                    6_400_000L * (long) Math.max(1,
-                                            Math.pow(4, ConfigHolder.INSTANCE.tools.voltageTierNanoSuit - 3)),
-                                    ConfigHolder.INSTANCE.tools.voltageTierNanoSuit)))
+                    (p) -> new ModularArmorItem(GTArmorMaterials.NANO_MUSCLE, ArmorItem.Type.LEGGINGS, p))
             .lang("NanoMuscle™ Suite Leggings")
             .properties(p -> p.rarity(Rarity.UNCOMMON))
             .tag(Tags.Items.ARMORS_LEGGINGS)
+            .onRegister(attach(new ModularItemComponent(4, GTValues.EV)))
             .register();
-    public static ItemEntry<ArmorComponentItem> NANO_BOOTS = REGISTRATE
-            .item("nanomuscle_boots", (p) -> new ArmorComponentItem(GTArmorMaterials.ARMOR, ArmorItem.Type.BOOTS, p)
-                    .setArmorLogic(new NanoMuscleSuite(ArmorItem.Type.BOOTS,
-                            512,
-                            6_400_000L * (long) Math.max(1,
-                                    Math.pow(4, ConfigHolder.INSTANCE.tools.voltageTierNanoSuit - 3)),
-                            ConfigHolder.INSTANCE.tools.voltageTierNanoSuit)))
+    public static ItemEntry<ModularArmorItem> NANO_BOOTS = REGISTRATE
+            .item("nanomuscle_boots",
+                    (p) -> new ModularArmorItem(GTArmorMaterials.NANO_MUSCLE, ArmorItem.Type.BOOTS, p))
             .lang("NanoMuscle™ Suite Boots")
             .properties(p -> p.rarity(Rarity.UNCOMMON))
-            .tag(Tags.Items.ARMORS_BOOTS)
-            .tag(CustomTags.STEP_BOOTS)
-            .register();
-    public static ItemEntry<ArmorComponentItem> NANO_HELMET = REGISTRATE
-            .item("nanomuscle_helmet", (p) -> new ArmorComponentItem(GTArmorMaterials.ARMOR, ArmorItem.Type.HELMET, p)
-                    .setArmorLogic(new NanoMuscleSuite(ArmorItem.Type.HELMET,
-                            512,
-                            6_400_000L * (long) Math.max(1,
-                                    Math.pow(4, ConfigHolder.INSTANCE.tools.voltageTierNanoSuit - 3)),
-                            ConfigHolder.INSTANCE.tools.voltageTierNanoSuit)))
+            .tag(Tags.Items.ARMORS_BOOTS, CustomTags.STEP_BOOTS)
+            .onRegister(attach(new ModularItemComponent(4, GTValues.EV)))
+            .register();
+    public static ItemEntry<ModularArmorItem> NANO_HELMET = REGISTRATE
+            .item("nanomuscle_helmet",
+                    (p) -> new ModularArmorItem(GTArmorMaterials.NANO_MUSCLE, ArmorItem.Type.HELMET, p))
             .lang("NanoMuscle™ Suite Helmet")
             .tag(Tags.Items.ARMORS_HELMETS)
             .properties(p -> p.rarity(Rarity.UNCOMMON))
+            .onRegister(attach(new ModularItemComponent(4, GTValues.EV)))
             .register();
 
     public static ItemEntry<ArmorComponentItem> FACE_MASK = REGISTRATE
@@ -2334,8 +2448,7 @@ public static ItemEntry<ComponentItem> createFluidCell(Material mat, int capacit
                     (p) -> new ArmorComponentItem(GTArmorMaterials.BAD_PPE_EQUIPMENT, ArmorItem.Type.HELMET, p)
                             .setArmorLogic(new HazmatSuit(ArmorItem.Type.HELMET, "bad_hazmat")))
             .lang("Face Mask")
-            .tag(Tags.Items.ARMORS_HELMETS)
-            .tag(CustomTags.PPE_ARMOR)
+            .tag(Tags.Items.ARMORS_HELMETS, CustomTags.PPE_ARMOR)
             .onRegister(attach(new TooltipBehavior(tooltips -> {
                 tooltips.add(Component.translatable("tooltip.gtceu.hazard_trigger.protection"));
                 tooltips.add(Component.translatable("tooltip.gtceu.hazard_trigger.inhalation"));
@@ -2346,8 +2459,7 @@ public static ItemEntry<ComponentItem> createFluidCell(Material mat, int capacit
                     (p) -> new ArmorComponentItem(GTArmorMaterials.BAD_PPE_EQUIPMENT, ArmorItem.Type.HELMET, p)
                             .setArmorLogic(new HazmatSuit(ArmorItem.Type.CHESTPLATE, "bad_hazmat")))
             .lang("Rubber Gloves")
-            .tag(Tags.Items.ARMORS_CHESTPLATES)
-            .tag(CustomTags.PPE_ARMOR)
+            .tag(Tags.Items.ARMORS_CHESTPLATES, CustomTags.PPE_ARMOR)
             .onRegister(attach(new TooltipBehavior(tooltips -> {
                 tooltips.add(Component.translatable("tooltip.gtceu.hazard_trigger.protection"));
                 tooltips.add(Component.translatable("tooltip.gtceu.hazard_trigger.skin_contact"));
@@ -2359,8 +2471,7 @@ public static ItemEntry<ComponentItem> createFluidCell(Material mat, int capacit
                             .setArmorLogic(new HazmatSuit(ArmorItem.Type.CHESTPLATE, "hazmat")))
             .lang("Hazardous Materials Suit Chestpiece")
             .properties(p -> p.rarity(Rarity.UNCOMMON))
-            .tag(Tags.Items.ARMORS_CHESTPLATES)
-            .tag(CustomTags.PPE_ARMOR)
+            .tag(Tags.Items.ARMORS_CHESTPLATES, CustomTags.PPE_ARMOR)
             .register();
     public static ItemEntry<ArmorComponentItem> HAZMAT_LEGGINGS = REGISTRATE
             .item("hazmat_leggings",
@@ -2368,8 +2479,7 @@ public static ItemEntry<ComponentItem> createFluidCell(Material mat, int capacit
                             .setArmorLogic(new HazmatSuit(ArmorItem.Type.LEGGINGS, "hazmat")))
             .lang("Hazardous Materials Suit Leggings")
             .properties(p -> p.rarity(Rarity.UNCOMMON))
-            .tag(Tags.Items.ARMORS_LEGGINGS)
-            .tag(CustomTags.PPE_ARMOR)
+            .tag(Tags.Items.ARMORS_LEGGINGS, CustomTags.PPE_ARMOR)
             .register();
     public static ItemEntry<ArmorComponentItem> HAZMAT_BOOTS = REGISTRATE
             .item("hazmat_boots",
@@ -2377,8 +2487,7 @@ public static ItemEntry<ComponentItem> createFluidCell(Material mat, int capacit
                             .setArmorLogic(new HazmatSuit(ArmorItem.Type.BOOTS, "hazmat")))
             .lang("Hazardous Materials Suit Boots")
             .properties(p -> p.rarity(Rarity.UNCOMMON))
-            .tag(Tags.Items.ARMORS_BOOTS)
-            .tag(CustomTags.PPE_ARMOR)
+            .tag(Tags.Items.ARMORS_BOOTS, CustomTags.PPE_ARMOR)
             .register();
     public static ItemEntry<ArmorComponentItem> HAZMAT_HELMET = REGISTRATE
             .item("hazmat_headpiece",
@@ -2390,57 +2499,39 @@ public static ItemEntry<ComponentItem> createFluidCell(Material mat, int capacit
             .tag(CustomTags.PPE_ARMOR)
             .register();
 
-    public static ItemEntry<ArmorComponentItem> QUANTUM_CHESTPLATE = REGISTRATE
+    public static ItemEntry<ModularArmorItem> QUANTUM_CHESTPLATE = REGISTRATE
             .item("quarktech_chestplate",
-                    (p) -> new ArmorComponentItem(GTArmorMaterials.ARMOR, ArmorItem.Type.CHESTPLATE, p)
-                            .setArmorLogic(new QuarkTechSuite(ArmorItem.Type.CHESTPLATE,
-                                    8192,
-                                    100_000_000L * (long) Math.max(1,
-                                            Math.pow(4, ConfigHolder.INSTANCE.tools.voltageTierQuarkTech - 5)),
-                                    ConfigHolder.INSTANCE.tools.voltageTierQuarkTech)))
+                    (p) -> new ModularArmorItem(GTArmorMaterials.QUARK_TECH, ArmorItem.Type.CHESTPLATE, p))
             .lang("QuarkTech™ Suite Chestplate")
             .properties(p -> p.rarity(Rarity.RARE))
-            .tag(Tags.Items.ARMORS_CHESTPLATES)
-            .tag(ItemTags.FREEZE_IMMUNE_WEARABLES)
+            .tag(Tags.Items.ARMORS_CHESTPLATES, CustomTags.PPE_ARMOR,
+                    ItemTags.FREEZE_IMMUNE_WEARABLES)
             .tag(CustomTags.PPE_ARMOR)
+            .onRegister(attach(new ModularItemComponent(8, GTValues.MAX)))
             .register();
-    public static ItemEntry<ArmorComponentItem> QUANTUM_LEGGINGS = REGISTRATE
+    public static ItemEntry<ModularArmorItem> QUANTUM_LEGGINGS = REGISTRATE
             .item("quarktech_leggings",
-                    (p) -> new ArmorComponentItem(GTArmorMaterials.ARMOR, ArmorItem.Type.LEGGINGS, p)
-                            .setArmorLogic(new QuarkTechSuite(ArmorItem.Type.LEGGINGS,
-                                    8192,
-                                    100_000_000L * (long) Math.max(1,
-                                            Math.pow(4, ConfigHolder.INSTANCE.tools.voltageTierQuarkTech - 5)),
-                                    ConfigHolder.INSTANCE.tools.voltageTierQuarkTech)))
+                    (p) -> new ModularArmorItem(GTArmorMaterials.QUARK_TECH, ArmorItem.Type.LEGGINGS, p))
             .lang("QuarkTech™ Suite Leggings")
             .properties(p -> p.rarity(Rarity.RARE))
-            .tag(Tags.Items.ARMORS_LEGGINGS)
-            .tag(CustomTags.PPE_ARMOR)
+            .tag(Tags.Items.ARMORS_LEGGINGS, CustomTags.PPE_ARMOR)
+            .onRegister(attach(new ModularItemComponent(8, GTValues.MAX)))
             .register();
-    public static ItemEntry<ArmorComponentItem> QUANTUM_BOOTS = REGISTRATE
-            .item("quarktech_boots", (p) -> new ArmorComponentItem(GTArmorMaterials.ARMOR, ArmorItem.Type.BOOTS, p)
-                    .setArmorLogic(new QuarkTechSuite(ArmorItem.Type.BOOTS,
-                            8192,
-                            100_000_000L * (long) Math.max(1,
-                                    Math.pow(4, ConfigHolder.INSTANCE.tools.voltageTierQuarkTech - 5)),
-                            ConfigHolder.INSTANCE.tools.voltageTierQuarkTech)))
+    public static ItemEntry<ModularArmorItem> QUANTUM_BOOTS = REGISTRATE
+            .item("quarktech_boots",
+                    (p) -> new ModularArmorItem(GTArmorMaterials.QUARK_TECH, ArmorItem.Type.BOOTS, p))
             .lang("QuarkTech™ Suite Boots")
             .properties(p -> p.rarity(Rarity.RARE))
-            .tag(Tags.Items.ARMORS_BOOTS)
-            .tag(CustomTags.PPE_ARMOR)
-            .tag(CustomTags.STEP_BOOTS)
-            .register();
-    public static ItemEntry<ArmorComponentItem> QUANTUM_HELMET = REGISTRATE
-            .item("quarktech_helmet", (p) -> new ArmorComponentItem(GTArmorMaterials.ARMOR, ArmorItem.Type.HELMET, p)
-                    .setArmorLogic(new QuarkTechSuite(ArmorItem.Type.HELMET,
-                            8192,
-                            100_000_000L * (long) Math.max(1,
-                                    Math.pow(4, ConfigHolder.INSTANCE.tools.voltageTierQuarkTech - 5)),
-                            ConfigHolder.INSTANCE.tools.voltageTierQuarkTech)))
+            .tag(Tags.Items.ARMORS_BOOTS, CustomTags.PPE_ARMOR, CustomTags.STEP_BOOTS)
+            .onRegister(attach(new ModularItemComponent(8, GTValues.MAX)))
+            .register();
+    public static ItemEntry<ModularArmorItem> QUANTUM_HELMET = REGISTRATE
+            .item("quarktech_helmet",
+                    (p) -> new ModularArmorItem(GTArmorMaterials.QUARK_TECH, ArmorItem.Type.HELMET, p))
             .lang("QuarkTech™ Suite Helmet")
             .properties(p -> p.rarity(Rarity.RARE))
-            .tag(Tags.Items.ARMORS_HELMETS)
-            .tag(CustomTags.PPE_ARMOR)
+            .tag(Tags.Items.ARMORS_HELMETS, CustomTags.PPE_ARMOR)
+            .onRegister(attach(new ModularItemComponent(8, GTValues.MAX)))
             .register();
 
     public static ItemEntry<ArmorComponentItem> LIQUID_FUEL_JETPACK = REGISTRATE
@@ -2476,31 +2567,23 @@ public static ItemEntry<ComponentItem> createFluidCell(Material mat, int capacit
             .properties(p -> p.rarity(Rarity.RARE))
             .tag(Tags.Items.ARMORS_CHESTPLATES)
             .register();
-    public static ItemEntry<ArmorComponentItem> NANO_CHESTPLATE_ADVANCED = REGISTRATE
+    public static ItemEntry<ModularArmorItem> NANO_CHESTPLATE_ADVANCED = REGISTRATE
             .item("advanced_nanomuscle_chestplate",
-                    (p) -> new ArmorComponentItem(GTArmorMaterials.ARMOR, ArmorItem.Type.CHESTPLATE, p)
-                            .setArmorLogic(new AdvancedNanoMuscleSuite(512,
-                                    12_800_000L * (long) Math.max(1,
-                                            Math.pow(4, ConfigHolder.INSTANCE.tools.voltageTierAdvNanoSuit - 3)),
-                                    ConfigHolder.INSTANCE.tools.voltageTierAdvNanoSuit)))
+                    (p) -> new ModularArmorItem(GTArmorMaterials.ADVANCED_NANO_MUSCLE, ArmorItem.Type.CHESTPLATE, p))
             .lang("Advanced NanoMuscle™ Suite Chestplate")
             .properties(p -> p.rarity(Rarity.RARE))
-            .tag(Tags.Items.ARMORS_CHESTPLATES)
-            .tag(CustomTags.PPE_ARMOR)
+            .tag(Tags.Items.ARMORS_CHESTPLATES, CustomTags.PPE_ARMOR)
+            .onRegister(attach(new ModularItemComponent(5, GTValues.EV)))
             .register();
-    public static ItemEntry<ArmorComponentItem> QUANTUM_CHESTPLATE_ADVANCED = REGISTRATE
-            .item("advanced_quarktech_chestplate", (p) -> new ArmorComponentItem(GTArmorMaterials.ARMOR,
-                    ArmorItem.Type.CHESTPLATE, p)
-                    .setArmorLogic(new AdvancedQuarkTechSuite(8192,
-                            1_000_000_000L *
-                                    (long) Math.max(1,
-                                            Math.pow(4, ConfigHolder.INSTANCE.tools.voltageTierAdvQuarkTech - 6)),
-                            ConfigHolder.INSTANCE.tools.voltageTierAdvQuarkTech)))
+    public static ItemEntry<ModularArmorItem> QUANTUM_CHESTPLATE_ADVANCED = REGISTRATE
+            .item("advanced_quarktech_chestplate",
+                    (p) -> new ModularArmorItem(GTArmorMaterials.ADVANCED_QUARK_TECH, ArmorItem.Type.CHESTPLATE, p))
             .lang("Advanced QuarkTech™ Suite Chestplate")
             .properties(p -> p.rarity(Rarity.EPIC))
             .tag(Tags.Items.ARMORS_CHESTPLATES)
             .tag(ItemTags.FREEZE_IMMUNE_WEARABLES)
             .tag(CustomTags.PPE_ARMOR)
+            .onRegister(attach(new ModularItemComponent(9, GTValues.MAX)))
             .register();
 
     public static ItemEntry<Item> POWER_THRUSTER = REGISTRATE.item("power_thruster", Item::new)
@@ -2554,6 +2637,14 @@ public static ItemEntry<ComponentItem> createFluidCell(Material mat, int capacit
             .onRegister(attach(new ImageModuleBehaviour()))
             .register();
 
+    public static ItemEntry<ComponentItem> GUI_MODULE = REGISTRATE.item("gui_module", ComponentItem::create)
+            .onRegister(attach(new GuiModuleBehaviour()))
+            .register();
+
+    public static ItemEntry<Item> CREATIVE_FLIGHT_MODULE = REGISTRATE.item("creative_flight_module", Item::new)
+            .lang("Gravitation Module")
+            .register();
+
     public static void init() {
         GTMaterialItems.generateMaterialItems();
         GTMaterialItems.generateTools();
diff --git a/src/main/java/com/gregtechceu/gtceu/common/data/GTMachines.java b/src/main/java/com/gregtechceu/gtceu/common/data/GTMachines.java
index dfdf9ae80ef..f0ee613fc6e 100644
--- a/src/main/java/com/gregtechceu/gtceu/common/data/GTMachines.java
+++ b/src/main/java/com/gregtechceu/gtceu/common/data/GTMachines.java
@@ -22,6 +22,8 @@
 import com.gregtechceu.gtceu.common.data.machines.*;
 import com.gregtechceu.gtceu.common.data.models.GTModels;
 import com.gregtechceu.gtceu.common.machine.electric.*;
+import com.gregtechceu.gtceu.common.machine.muimachine.TestMuiMachine;
+import com.gregtechceu.gtceu.common.machine.muimachine.TestMuiMachine2;
 import com.gregtechceu.gtceu.common.machine.multiblock.part.*;
 import com.gregtechceu.gtceu.common.machine.multiblock.part.monitor.AdvancedMonitorPartMachine;
 import com.gregtechceu.gtceu.common.machine.multiblock.part.monitor.MonitorPartMachine;
@@ -30,6 +32,8 @@
 import com.gregtechceu.gtceu.common.machine.steam.SteamSolarBoiler;
 import com.gregtechceu.gtceu.common.machine.steam.SteamSolidBoilerMachine;
 import com.gregtechceu.gtceu.common.machine.storage.*;
+import com.gregtechceu.gtceu.common.mui.GTGuiTheme;
+import com.gregtechceu.gtceu.common.mui.GTSingleblockMachinePanels;
 import com.gregtechceu.gtceu.common.pipelike.fluidpipe.longdistance.LDFluidEndpointMachine;
 import com.gregtechceu.gtceu.common.pipelike.item.longdistance.LDItemEndpointMachine;
 import com.gregtechceu.gtceu.config.ConfigHolder;
@@ -78,6 +82,7 @@ public class GTMachines {
                     .recipeType(STEAM_BOILER_RECIPES)
                     .recipeModifier(SteamBoilerMachine::recipeModifier)
                     .workableSteamHullModel(pressure, GTCEu.id("block/generators/boiler/coal"))
+                    .themeId((i) -> i > 0 ? GTGuiTheme.STEEL.getId() : GTGuiTheme.BRONZE.getId())
                     .tooltips(Component.translatable("gtceu.universal.tooltip.produces_fluid",
                             (pressure ? ConfigHolder.INSTANCE.machines.smallBoilers.hpSolidBoilerBaseOutput :
                                     ConfigHolder.INSTANCE.machines.smallBoilers.solidBoilerBaseOutput) *
@@ -91,6 +96,7 @@ public class GTMachines {
                     .recipeType(STEAM_BOILER_RECIPES)
                     .recipeModifier(SteamBoilerMachine::recipeModifier)
                     .workableSteamHullModel(pressure, GTCEu.id("block/generators/boiler/lava"))
+                    .themeId((i) -> i > 0 ? GTGuiTheme.STEEL.getId() : GTGuiTheme.BRONZE.getId())
                     .tooltips(Component.translatable("gtceu.universal.tooltip.produces_fluid",
                             (pressure ? ConfigHolder.INSTANCE.machines.smallBoilers.hpLiquidBoilerBaseOutput :
                                     ConfigHolder.INSTANCE.machines.smallBoilers.liquidBoilerBaseOutput) *
@@ -104,6 +110,7 @@ public class GTMachines {
                     .recipeType(STEAM_BOILER_RECIPES)
                     .recipeModifier(SteamBoilerMachine::recipeModifier)
                     .workableSteamHullModel(pressure, GTCEu.id("block/generators/boiler/solar"))
+                    .themeId((i) -> i > 0 ? GTGuiTheme.STEEL.getId() : GTGuiTheme.BRONZE.getId())
                     .tooltips(Component.translatable("gtceu.universal.tooltip.produces_fluid",
                             (pressure ? ConfigHolder.INSTANCE.machines.smallBoilers.hpSolarBoilerBaseOutput :
                                     ConfigHolder.INSTANCE.machines.smallBoilers.solarBoilerBaseOutput) *
@@ -118,6 +125,8 @@ public class GTMachines {
                     .recipeType(GTRecipeTypes.MACERATOR_RECIPES)
                     .recipeModifier(SimpleSteamMachine::recipeModifier)
                     .addOutputLimit(ItemRecipeCapability.CAP, 1)
+                    .themeId((i) -> i > 0 ? GTGuiTheme.STEEL.getId() : GTGuiTheme.BRONZE.getId())
+                    .ui(GTSingleblockMachinePanels.STEAM_MACHINE)
                     .modelProperty(GTMachineModelProperties.VENT_DIRECTION, RelativeDirection.BACK)
                     .workableSteamHullModel(pressure, GTCEu.id("block/machines/macerator"))
                     .register());
@@ -146,6 +155,7 @@ public class GTMachines {
                         int maxArea = IMiner.getWorkingArea(isHP ? 6 : 4);
                         tooltip.add(Component.translatable("gtceu.universal.tooltip.working_area", maxArea, maxArea));
                     })
+                    .themeId((i) -> i > 0 ? GTGuiTheme.STEEL.getId() : GTGuiTheme.BRONZE.getId())
                     .modelProperty(GTMachineModelProperties.VENT_DIRECTION, RelativeDirection.UP)
                     .workableSteamHullModel(isHP, isHP ?
                             GTCEu.id("block/machines/high_pressure_steam_miner") :
@@ -167,72 +177,117 @@ public class GTMachines {
                     .register(),
             ALL_TIERS);
 
-    public static final MachineDefinition[] ELECTRIC_FURNACE = registerSimpleMachines("electric_furnace",
-            GTRecipeTypes.FURNACE_RECIPES);
-    public static final MachineDefinition[] ALLOY_SMELTER = registerSimpleMachines("alloy_smelter",
-            GTRecipeTypes.ALLOY_SMELTER_RECIPES);
-    public static final MachineDefinition[] ARC_FURNACE = registerSimpleMachines("arc_furnace",
-            GTRecipeTypes.ARC_FURNACE_RECIPES, hvCappedTankSizeFunction);
-    public static final MachineDefinition[] ASSEMBLER = registerSimpleMachines("assembler",
-            GTRecipeTypes.ASSEMBLER_RECIPES, hvCappedTankSizeFunction, true);
-    public static final MachineDefinition[] AUTOCLAVE = registerSimpleMachines("autoclave",
-            GTRecipeTypes.AUTOCLAVE_RECIPES, hvCappedTankSizeFunction);
-    public static final MachineDefinition[] BENDER = registerSimpleMachines("bender", GTRecipeTypes.BENDER_RECIPES);
-    public static final MachineDefinition[] BREWERY = registerSimpleMachines("brewery", GTRecipeTypes.BREWING_RECIPES,
-            hvCappedTankSizeFunction);
-    public static final MachineDefinition[] CANNER = registerSimpleMachines("canner", GTRecipeTypes.CANNER_RECIPES);
-    public static final MachineDefinition[] CENTRIFUGE = registerSimpleMachines("centrifuge",
-            GTRecipeTypes.CENTRIFUGE_RECIPES, largeTankSizeFunction);
-    public static final MachineDefinition[] CHEMICAL_BATH = registerSimpleMachines("chemical_bath",
-            GTRecipeTypes.CHEMICAL_BATH_RECIPES, hvCappedTankSizeFunction);
-    public static final MachineDefinition[] CHEMICAL_REACTOR = registerSimpleMachines("chemical_reactor",
-            GTRecipeTypes.CHEMICAL_RECIPES, tier -> 16 * FluidType.BUCKET_VOLUME, true);
-    public static final MachineDefinition[] COMPRESSOR = registerSimpleMachines("compressor",
-            GTRecipeTypes.COMPRESSOR_RECIPES);
-    public static final MachineDefinition[] CUTTER = registerSimpleMachines("cutter", GTRecipeTypes.CUTTER_RECIPES);
-    public static final MachineDefinition[] DISTILLERY = registerSimpleMachines("distillery",
-            GTRecipeTypes.DISTILLERY_RECIPES, hvCappedTankSizeFunction);
-    public static final MachineDefinition[] ELECTROLYZER = registerSimpleMachines("electrolyzer",
-            GTRecipeTypes.ELECTROLYZER_RECIPES, largeTankSizeFunction);
-    public static final MachineDefinition[] ELECTROMAGNETIC_SEPARATOR = registerSimpleMachines(
-            "electromagnetic_separator", GTRecipeTypes.ELECTROMAGNETIC_SEPARATOR_RECIPES);
-    public static final MachineDefinition[] EXTRACTOR = registerSimpleMachines("extractor",
-            GTRecipeTypes.EXTRACTOR_RECIPES);
-    public static final MachineDefinition[] EXTRUDER = registerSimpleMachines("extruder",
-            GTRecipeTypes.EXTRUDER_RECIPES);
-    public static final MachineDefinition[] FERMENTER = registerSimpleMachines("fermenter",
-            GTRecipeTypes.FERMENTING_RECIPES, hvCappedTankSizeFunction);
-    public static final MachineDefinition[] FLUID_HEATER = registerSimpleMachines("fluid_heater",
-            GTRecipeTypes.FLUID_HEATER_RECIPES, hvCappedTankSizeFunction);
-    public static final MachineDefinition[] FLUID_SOLIDIFIER = registerSimpleMachines("fluid_solidifier",
-            GTRecipeTypes.FLUID_SOLIDFICATION_RECIPES, hvCappedTankSizeFunction);
-    public static final MachineDefinition[] FORGE_HAMMER = registerSimpleMachines("forge_hammer",
-            GTRecipeTypes.FORGE_HAMMER_RECIPES);
-    public static final MachineDefinition[] FORMING_PRESS = registerSimpleMachines("forming_press",
-            GTRecipeTypes.FORMING_PRESS_RECIPES);
-    public static final MachineDefinition[] LATHE = registerSimpleMachines("lathe", GTRecipeTypes.LATHE_RECIPES);
-    public static final MachineDefinition[] SCANNER = registerSimpleMachines("scanner", GTRecipeTypes.SCANNER_RECIPES);
-    public static final MachineDefinition[] MIXER = registerSimpleMachines("mixer", GTRecipeTypes.MIXER_RECIPES,
-            hvCappedTankSizeFunction);
-    public static final MachineDefinition[] ORE_WASHER = registerSimpleMachines("ore_washer",
-            GTRecipeTypes.ORE_WASHER_RECIPES);
-    public static final MachineDefinition[] PACKER = registerSimpleMachines("packer", GTRecipeTypes.PACKER_RECIPES);
-    public static final MachineDefinition[] POLARIZER = registerSimpleMachines("polarizer",
-            GTRecipeTypes.POLARIZER_RECIPES);
-    public static final MachineDefinition[] LASER_ENGRAVER = registerSimpleMachines("laser_engraver",
-            GTRecipeTypes.LASER_ENGRAVER_RECIPES, defaultTankSizeFunction, true);
-    public static final MachineDefinition[] SIFTER = registerSimpleMachines("sifter", GTRecipeTypes.SIFTER_RECIPES);
-    public static final MachineDefinition[] THERMAL_CENTRIFUGE = registerSimpleMachines("thermal_centrifuge",
-            GTRecipeTypes.THERMAL_CENTRIFUGE_RECIPES);
-    public static final MachineDefinition[] WIREMILL = registerSimpleMachines("wiremill",
-            GTRecipeTypes.WIREMILL_RECIPES);
-    public static final MachineDefinition[] CIRCUIT_ASSEMBLER = registerSimpleMachines("circuit_assembler",
-            GTRecipeTypes.CIRCUIT_ASSEMBLER_RECIPES, hvCappedTankSizeFunction, true);
+    public static final MachineDefinition[] ELECTRIC_FURNACE = new SimpleMachineBuilder("electric_furnace",
+            GTRecipeTypes.FURNACE_RECIPES).register();
+    public static final MachineDefinition[] ALLOY_SMELTER = new SimpleMachineBuilder("alloy_smelter",
+            GTRecipeTypes.ALLOY_SMELTER_RECIPES).register();
+
+    public static final MachineDefinition[] ARC_FURNACE = registerTieredMachines("arc_furnace",
+            (holder, tier) -> new SimpleTieredMachine(holder, tier, defaultTankSizeFunction), (tier, builder) -> builder
+                    .langValue("%s Arc Furnace %s".formatted(VLVH[tier], VLVT[tier]))
+                    .ui(GTSingleblockMachinePanels.ARC_FURNACE)
+                    // .editableUI(SimpleTieredMachine.EDITABLE_UI_CREATOR.apply(GTCEu.id("arc_furnace"),
+                    // GTRecipeTypes.ARC_FURNACE_RECIPES))
+                    .rotationState(RotationState.NON_Y_AXIS)
+                    .recipeType(GTRecipeTypes.ARC_FURNACE_RECIPES)
+                    .recipeModifier(GTRecipeModifiers.OC_NON_PERFECT)
+                    .workableTieredHullModel(GTCEu.id("block/machines/arc_furnace"))
+                    .tooltips(workableTiered(tier, GTValues.V[tier], GTValues.V[tier] * 64,
+                            GTRecipeTypes.ARC_FURNACE_RECIPES, defaultTankSizeFunction.applyAsInt(tier), true))
+                    .register(),
+            ELECTRIC_TIERS);
+    public static final MachineDefinition[] ASSEMBLER = new SimpleMachineBuilder("assembler",
+            GTRecipeTypes.ASSEMBLER_RECIPES)
+            .tankScalingFunction(hvCappedTankSizeFunction)
+            .hasPollutionDebuff(true)
+            .register();
+    public static final MachineDefinition[] AUTOCLAVE = new SimpleMachineBuilder("autoclave",
+            GTRecipeTypes.AUTOCLAVE_RECIPES)
+            .tankScalingFunction(hvCappedTankSizeFunction)
+            .register();
+    public static final MachineDefinition[] BENDER = new SimpleMachineBuilder("bender", GTRecipeTypes.BENDER_RECIPES)
+            .register();
+    public static final MachineDefinition[] BREWERY = new SimpleMachineBuilder("brewery", GTRecipeTypes.BREWING_RECIPES)
+            .tankScalingFunction(hvCappedTankSizeFunction)
+            .register();
+    public static final MachineDefinition[] CANNER = new SimpleMachineBuilder("canner", GTRecipeTypes.CANNER_RECIPES)
+            .register();
+    public static final MachineDefinition[] CENTRIFUGE = new SimpleMachineBuilder("centrifuge",
+            GTRecipeTypes.CENTRIFUGE_RECIPES).tankScalingFunction(largeTankSizeFunction).register();
+    public static final MachineDefinition[] CHEMICAL_BATH = new SimpleMachineBuilder("chemical_bath",
+            GTRecipeTypes.CHEMICAL_BATH_RECIPES).tankScalingFunction(hvCappedTankSizeFunction).register();
+    public static final MachineDefinition[] CHEMICAL_REACTOR = new SimpleMachineBuilder("chemical_reactor",
+            GTRecipeTypes.CHEMICAL_RECIPES)
+            .tankScalingFunction(tier -> 16 * FluidType.BUCKET_VOLUME)
+            .hasPollutionDebuff(true)
+            .register();
+    public static final MachineDefinition[] COMPRESSOR = new SimpleMachineBuilder("compressor",
+            GTRecipeTypes.COMPRESSOR_RECIPES).register();
+    public static final MachineDefinition[] CUTTER = new SimpleMachineBuilder("cutter", GTRecipeTypes.CUTTER_RECIPES)
+            .register();
+    public static final MachineDefinition[] DISTILLERY = new SimpleMachineBuilder("distillery",
+            GTRecipeTypes.DISTILLERY_RECIPES)
+            .tankScalingFunction(hvCappedTankSizeFunction)
+            .register();
+    public static final MachineDefinition[] ELECTROLYZER = new SimpleMachineBuilder("electrolyzer",
+            GTRecipeTypes.ELECTROLYZER_RECIPES)
+            .tankScalingFunction(largeTankSizeFunction)
+            .register();
+    public static final MachineDefinition[] ELECTROMAGNETIC_SEPARATOR = new SimpleMachineBuilder(
+            "electromagnetic_separator", GTRecipeTypes.ELECTROMAGNETIC_SEPARATOR_RECIPES).register();
+    public static final MachineDefinition[] EXTRACTOR = new SimpleMachineBuilder("extractor",
+            GTRecipeTypes.EXTRACTOR_RECIPES).register();
+    public static final MachineDefinition[] EXTRUDER = new SimpleMachineBuilder("extruder",
+            GTRecipeTypes.EXTRUDER_RECIPES).register();
+    public static final MachineDefinition[] FERMENTER = new SimpleMachineBuilder("fermenter",
+            GTRecipeTypes.FERMENTING_RECIPES)
+            .tankScalingFunction(hvCappedTankSizeFunction)
+            .register();
+    public static final MachineDefinition[] FLUID_HEATER = new SimpleMachineBuilder("fluid_heater",
+            GTRecipeTypes.FLUID_HEATER_RECIPES)
+            .tankScalingFunction(hvCappedTankSizeFunction)
+            .register();
+    public static final MachineDefinition[] FLUID_SOLIDIFIER = new SimpleMachineBuilder("fluid_solidifier",
+            GTRecipeTypes.FLUID_SOLIDFICATION_RECIPES)
+            .tankScalingFunction(hvCappedTankSizeFunction)
+            .register();
+    public static final MachineDefinition[] FORGE_HAMMER = new SimpleMachineBuilder("forge_hammer",
+            GTRecipeTypes.FORGE_HAMMER_RECIPES).register();
+    public static final MachineDefinition[] FORMING_PRESS = new SimpleMachineBuilder("forming_press",
+            GTRecipeTypes.FORMING_PRESS_RECIPES).register();
+    public static final MachineDefinition[] LATHE = new SimpleMachineBuilder("lathe", GTRecipeTypes.LATHE_RECIPES)
+            .register();
+    public static final MachineDefinition[] SCANNER = new SimpleMachineBuilder("scanner", GTRecipeTypes.SCANNER_RECIPES)
+            .register();
+    public static final MachineDefinition[] MIXER = new SimpleMachineBuilder("mixer", GTRecipeTypes.MIXER_RECIPES)
+            .tankScalingFunction(hvCappedTankSizeFunction)
+            .register();
+    public static final MachineDefinition[] ORE_WASHER = new SimpleMachineBuilder("ore_washer",
+            GTRecipeTypes.ORE_WASHER_RECIPES).register();
+    public static final MachineDefinition[] PACKER = new SimpleMachineBuilder("packer", GTRecipeTypes.PACKER_RECIPES)
+            .register();
+    public static final MachineDefinition[] POLARIZER = new SimpleMachineBuilder("polarizer",
+            GTRecipeTypes.POLARIZER_RECIPES).register();
+    public static final MachineDefinition[] LASER_ENGRAVER = new SimpleMachineBuilder("laser_engraver",
+            GTRecipeTypes.LASER_ENGRAVER_RECIPES)
+            .tankScalingFunction(defaultTankSizeFunction)
+            .hasPollutionDebuff(true)
+            .register();
+    public static final MachineDefinition[] SIFTER = new SimpleMachineBuilder("sifter", GTRecipeTypes.SIFTER_RECIPES)
+            .register();
+    public static final MachineDefinition[] THERMAL_CENTRIFUGE = new SimpleMachineBuilder("thermal_centrifuge",
+            GTRecipeTypes.THERMAL_CENTRIFUGE_RECIPES).register();
+    public static final MachineDefinition[] WIREMILL = new SimpleMachineBuilder("wiremill",
+            GTRecipeTypes.WIREMILL_RECIPES).register();
+    public static final MachineDefinition[] CIRCUIT_ASSEMBLER = new SimpleMachineBuilder("circuit_assembler",
+            GTRecipeTypes.CIRCUIT_ASSEMBLER_RECIPES)
+            .tankScalingFunction(hvCappedTankSizeFunction)
+            .hasPollutionDebuff(true)
+            .register();
     public static final MachineDefinition[] MACERATOR = registerTieredMachines("macerator",
             (holder, tier) -> new SimpleTieredMachine(holder, tier, defaultTankSizeFunction), (tier, builder) -> builder
                     .langValue("%s Macerator %s".formatted(VLVH[tier], VLVT[tier]))
-                    .editableUI(SimpleTieredMachine.EDITABLE_UI_CREATOR.apply(GTCEu.id("macerator"),
-                            GTRecipeTypes.MACERATOR_RECIPES))
+                    .ui(GTSingleblockMachinePanels.MACERATOR)
                     .rotationState(RotationState.NON_Y_AXIS)
                     .recipeType(GTRecipeTypes.MACERATOR_RECIPES)
                     .addOutputLimit(ItemRecipeCapability.CAP, switch (tier) {
@@ -246,13 +301,16 @@ public class GTMachines {
                             GTRecipeTypes.MACERATOR_RECIPES, defaultTankSizeFunction.applyAsInt(tier), true))
                     .register(),
             ELECTRIC_TIERS);
-    public static final MachineDefinition[] GAS_COLLECTOR = registerSimpleMachines("gas_collector",
-            GTRecipeTypes.GAS_COLLECTOR_RECIPES, largeTankSizeFunction, true);
+    public static final MachineDefinition[] GAS_COLLECTOR = new SimpleMachineBuilder("gas_collector",
+            GTRecipeTypes.GAS_COLLECTOR_RECIPES)
+            .tankScalingFunction(largeTankSizeFunction)
+            .hasPollutionDebuff(true)
+            .register();
+
     public static final MachineDefinition[] ROCK_CRUSHER = registerTieredMachines("rock_crusher",
             RockCrusherMachine::new, (tier, builder) -> builder
                     .langValue("%s Rock Crusher %s".formatted(VLVH[tier], VLVT[tier]))
-                    .editableUI(SimpleTieredMachine.EDITABLE_UI_CREATOR.apply(GTCEu.id("rock_crusher"),
-                            GTRecipeTypes.ROCK_BREAKER_RECIPES))
+                    .ui(GTSingleblockMachinePanels.GENERAL_MACHINE)
                     .rotationState(RotationState.NON_Y_AXIS)
                     .recipeType(GTRecipeTypes.ROCK_BREAKER_RECIPES)
                     .recipeModifier(GTRecipeModifiers.OC_NON_PERFECT)
@@ -265,8 +323,7 @@ public class GTMachines {
     public static final MachineDefinition[] AIR_SCRUBBER = registerTieredMachines("air_scrubber",
             AirScrubberMachine::new, (tier, builder) -> builder
                     .langValue("%s Air Scrubber %s".formatted(VLVH[tier], VLVT[tier]))
-                    .editableUI(SimpleTieredMachine.EDITABLE_UI_CREATOR.apply(GTCEu.id("air_scrubber"),
-                            GTRecipeTypes.AIR_SCRUBBER_RECIPES))
+                    .ui(GTSingleblockMachinePanels.GENERAL_MACHINE)
                     .rotationState(RotationState.NON_Y_AXIS)
                     .recipeType(GTRecipeTypes.AIR_SCRUBBER_RECIPES)
                     .recipeModifier(GTRecipeModifiers.OC_NON_PERFECT)
@@ -367,7 +424,7 @@ public class GTMachines {
     public static final MachineDefinition[] FISHER = registerTieredMachines("fisher", FisherMachine::new,
             (tier, builder) -> builder
                     .rotationState(RotationState.ALL)
-                    .editableUI(FisherMachine.EDITABLE_UI_CREATOR.apply(GTCEu.id("fisher"), (tier + 1) * (tier + 1)))
+                    // .editableUI(FisherMachine.EDITABLE_UI_CREATOR.apply(GTCEu.id("fisher"), (tier + 1) * (tier + 1)))
                     .model(createFisherModel())
                     .langValue("%s Fisher %s".formatted(VLVH[tier], VLVT[tier]))
                     .tooltips(Component.translatable("gtceu.machine.fisher.tooltip"),
@@ -386,8 +443,6 @@ public class GTMachines {
             BlockBreakerMachine::new,
             (tier, builder) -> builder
                     .rotationState(RotationState.NON_Y_AXIS)
-                    .editableUI(BlockBreakerMachine.EDITABLE_UI_CREATOR.apply(GTCEu.id("block_breaker"),
-                            (tier + 1) * (tier + 1)))
                     .workableTieredHullModel(GTCEu.id("block/machines/block_breaker"))
                     .langValue("%s Block Breaker %s".formatted(VLVH[tier], VLVT[tier]))
                     .tooltips(Component.translatable("gtceu.machine.block_breaker.tooltip"),
@@ -408,7 +463,6 @@ public class GTMachines {
                     .rotationState(RotationState.NON_Y_AXIS)
                     .langValue("%s Miner %s".formatted(VLVH[tier], VLVT[tier]))
                     .recipeType(DUMMY_RECIPES)
-                    .editableUI(MinerMachine.EDITABLE_UI_CREATOR.apply(GTCEu.id("miner"), (tier + 1) * (tier + 1)))
                     .workableTieredHullModel(GTCEu.id("block/machines/miner"))
                     .tooltipBuilder((stack, tooltip) -> {
                         int maxArea = IMiner.getWorkingArea(tier * 8);
@@ -467,8 +521,6 @@ public class GTMachines {
                     .recipeType(DUMMY_RECIPES)
                     .modelProperty(GTMachineModelProperties.IS_ACTIVE, false)
                     .modelProperty(GTMachineModelProperties.IS_WORKING_ENABLED, false)
-                    .editableUI(ItemCollectorMachine.EDITABLE_UI_CREATOR.apply(GTCEu.id("item_collector"),
-                            ItemCollectorMachine.getINVENTORY_SIZES()[tier]))
                     .model(createItemCollectorModel(GTCEu.id("block/machines/item_collector")))
                     .tooltips(
                             Component.translatable("gtceu.machine.item_collector.tooltip"),
@@ -571,14 +623,14 @@ public class GTMachines {
     public static final MachineDefinition[] SUPER_TANK = registerQuantumTanks("super_tank", LOW_TIERS);
     public static final MachineDefinition[] QUANTUM_TANK = registerQuantumTanks("quantum_tank", HIGH_TIERS);
 
-    public static MachineDefinition WOODEN_CRATE = registerCrate(GTMaterials.Wood, 27, "Wooden Crate");
-    public static MachineDefinition BRONZE_CRATE = registerCrate(GTMaterials.Bronze, 54, "Bronze Crate");
-    public static MachineDefinition STEEL_CRATE = registerCrate(GTMaterials.Steel, 72, "Steel Crate");
-    public static MachineDefinition ALUMINIUM_CRATE = registerCrate(GTMaterials.Aluminium, 90, "Aluminium Crate");
-    public static MachineDefinition STAINLESS_STEEL_CRATE = registerCrate(GTMaterials.StainlessSteel, 108,
+    public static MachineDefinition WOODEN_CRATE = registerCrate(GTMaterials.Wood, 27, 9, "Wooden Crate");
+    public static MachineDefinition BRONZE_CRATE = registerCrate(GTMaterials.Bronze, 54, 9, "Bronze Crate");
+    public static MachineDefinition STEEL_CRATE = registerCrate(GTMaterials.Steel, 72, 9, "Steel Crate");
+    public static MachineDefinition ALUMINIUM_CRATE = registerCrate(GTMaterials.Aluminium, 90, 10, "Aluminium Crate");
+    public static MachineDefinition STAINLESS_STEEL_CRATE = registerCrate(GTMaterials.StainlessSteel, 108, 12,
             "Stainless Steel Crate");
-    public static MachineDefinition TITANIUM_CRATE = registerCrate(GTMaterials.Titanium, 126, "Titanium Crate");
-    public static MachineDefinition TUNGSTENSTEEL_CRATE = registerCrate(GTMaterials.TungstenSteel, 144,
+    public static MachineDefinition TITANIUM_CRATE = registerCrate(GTMaterials.Titanium, 126, 14, "Titanium Crate");
+    public static MachineDefinition TUNGSTENSTEEL_CRATE = registerCrate(GTMaterials.TungstenSteel, 144, 16,
             "Tungstensteel Crate");
 
     public static MachineDefinition WOODEN_DRUM = registerDrum(GTMaterials.Wood, (16 * FluidType.BUCKET_VOLUME),
@@ -835,6 +887,7 @@ public class GTMachines {
             .abilities(PartAbility.STEAM_IMPORT_ITEMS)
             .modelProperty(IS_FORMED, false)
             .colorOverlaySteamHullModel(OVERLAY_ITEM_HATCH_INPUT, "overlay_pipe", "overlay_pipe_in_emissive")
+            .themeId(GTGuiTheme.BRONZE.getId())
             .langValue("Steam Input Bus")
             .tooltips(Component.translatable("gtceu.machine.item_bus.import.tooltip"),
                     Component.translatable("gtceu.machine.steam_bus.tooltip"),
@@ -848,6 +901,7 @@ public class GTMachines {
             .abilities(PartAbility.STEAM_EXPORT_ITEMS)
             .modelProperty(IS_FORMED, false)
             .colorOverlaySteamHullModel(OVERLAY_ITEM_HATCH_OUTPUT, "overlay_pipe", "overlay_pipe_out_emissive")
+            .themeId(GTGuiTheme.BRONZE.getId())
             .langValue("Steam Output Bus")
             .tooltips(Component.translatable("gtceu.machine.item_bus.export.tooltip"),
                     Component.translatable("gtceu.machine.steam_bus.tooltip"),
@@ -861,6 +915,7 @@ public class GTMachines {
             .abilities(PartAbility.STEAM)
             .modelProperty(IS_FORMED, false)
             .overlaySteamHullModel("steam_hatch")
+            .themeId(GTGuiTheme.BRONZE.getId())
             .tooltips(Component.translatable("gtceu.universal.tooltip.fluid_storage_capacity",
                     SteamHatchPartMachine.INITIAL_TANK_CAPACITY),
                     Component.translatable("gtceu.machine.steam.steam_hatch.tooltip"))
@@ -872,6 +927,7 @@ public class GTMachines {
             .modelProperty(IS_FORMED, false)
             .tooltips(Component.translatable("gtceu.part_sharing.disabled"))
             .simpleModel(GTCEu.id("block/machine/part/coke_oven_hatch"))
+            .themeId(GTGuiTheme.PRIMITIVE.getId())
             .register();
 
     public static final MachineDefinition PUMP_HATCH = REGISTRATE.machine("pump_hatch", PumpHatchPartMachine::new)
@@ -879,6 +935,7 @@ public class GTMachines {
             .abilities(PartAbility.PUMP_FLUID_HATCH)
             .modelProperty(IS_FORMED, false)
             .model(createBasicReplaceableTextureMachineModel(GTCEu.id("block/machine/part/pump_hatch")))
+            .themeId(GTGuiTheme.PRIMITIVE.getId())
             .register();
 
     public static final MachineDefinition MAINTENANCE_HATCH = REGISTRATE
@@ -1084,6 +1141,21 @@ public class GTMachines {
             .allowExtendedFacing(true)
             .register();
 
+    public static final MachineDefinition MUI_TEST = REGISTRATE
+            .machine("test_mui", TestMuiMachine::new)
+            .rotationState(RotationState.ALL)
+            .model(createOverlayCasingMachineModel(GTCEu.id("block/casings/solid/machine_casing_clean_stainless_steel"),
+                    GTCEu.id("block/machine/part/computer_monitor")))
+            .register();
+
+    public static final MachineDefinition MUI_TEST_2 = REGISTRATE
+            .machine("test_mui_new", TestMuiMachine2::new)
+            .rotationState(RotationState.ALL)
+            .recipeType(GTRecipeTypes.ALLOY_SMELTER_RECIPES)
+            .model(createOverlayCasingMachineModel(GTCEu.id("block/casings/solid/machine_casing_clean_stainless_steel"),
+                    GTCEu.id("block/machine/part/computer_monitor")))
+            .register();
+
     public static void init() {
         GTMultiMachines.init();
         GCYMMachines.init();
diff --git a/src/main/java/com/gregtechceu/gtceu/common/data/GTMenuTypes.java b/src/main/java/com/gregtechceu/gtceu/common/data/GTMenuTypes.java
new file mode 100644
index 00000000000..7bc2e31dd6f
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/common/data/GTMenuTypes.java
@@ -0,0 +1,26 @@
+package com.gregtechceu.gtceu.common.data;
+
+import com.gregtechceu.gtceu.GTCEu;
+
+import net.minecraft.core.registries.Registries;
+import net.minecraft.world.inventory.MenuType;
+import net.minecraftforge.common.extensions.IForgeMenuType;
+import net.minecraftforge.eventbus.api.IEventBus;
+import net.minecraftforge.registries.DeferredRegister;
+import net.minecraftforge.registries.RegistryObject;
+
+import brachy.modularui.screen.ModularContainerMenu;
+
+public class GTMenuTypes {
+
+    private static final DeferredRegister<MenuType<?>> MENU_TYPES = DeferredRegister.create(Registries.MENU,
+            GTCEu.MOD_ID);
+
+    public static final RegistryObject<MenuType<ModularContainerMenu>> MODULAR_CONTAINER = MENU_TYPES.register(
+            "modular",
+            () -> IForgeMenuType.create(ModularContainerMenu::new));
+
+    public static void init(IEventBus modBus) {
+        MENU_TYPES.register(modBus);
+    }
+}
diff --git a/src/main/java/com/gregtechceu/gtceu/common/data/GTPlaceholders.java b/src/main/java/com/gregtechceu/gtceu/common/data/GTPlaceholders.java
index 0aae9122642..b84b32de7e2 100644
--- a/src/main/java/com/gregtechceu/gtceu/common/data/GTPlaceholders.java
+++ b/src/main/java/com/gregtechceu/gtceu/common/data/GTPlaceholders.java
@@ -23,6 +23,7 @@
 import com.gregtechceu.gtceu.utils.GTMath;
 import com.gregtechceu.gtceu.utils.GTStringUtils;
 import com.gregtechceu.gtceu.utils.GTTransferUtils;
+import com.gregtechceu.gtceu.utils.math.ParseResult;
 
 import net.minecraft.ChatFormatting;
 import net.minecraft.commands.CommandSource;
@@ -106,6 +107,11 @@ public MultiLineComponent apply(PlaceholderContext ctx,
                 IEnergyContainer energy = GTCapabilityHelper.getEnergyContainer(ctx.level(), ctx.pos(), ctx.side());
                 return MultiLineComponent.literal(energy != null ? energy.getEnergyStored() : 0);
             }
+
+            @Override
+            public boolean isView() {
+                return true;
+            }
         });
         PlaceholderHandler.addPlaceholder(new Placeholder("energyCapacity") {
 
@@ -119,14 +125,27 @@ public MultiLineComponent apply(PlaceholderContext ctx,
                 IEnergyContainer energy = GTCapabilityHelper.getEnergyContainer(ctx.level(), ctx.pos(), ctx.side());
                 return MultiLineComponent.literal(energy != null ? energy.getEnergyCapacity() : 0);
             }
+
+            @Override
+            public boolean isView() {
+                return true;
+            }
         });
         PlaceholderHandler.addPlaceholder(new Placeholder("calc") {
 
             @Override
-            public MultiLineComponent apply(PlaceholderContext ctx, List<MultiLineComponent> args) {
-                List<String> stringArgs = new ArrayList<>();
-                args.forEach((components) -> stringArgs.add(GTStringUtils.componentsToString(components)));
-                return MultiLineComponent.literal(GTStringUtils.calc(stringArgs));
+            public MultiLineComponent apply(PlaceholderContext ctx,
+                                            List<MultiLineComponent> args) throws PlaceholderException {
+                String expression = args.stream().map(MultiLineComponent::toString).reduce("", (a, b) -> a + b);
+                ParseResult result = GTMath.parseExpression(expression, 0, true);
+                if (result.isFailure())
+                    throw new PlaceholderException(result.getError().toString());
+                return MultiLineComponent.literal(result.getResult().getNumberValue().toString());
+            }
+
+            @Override
+            public boolean isPure() {
+                return true;
             }
         });
         PlaceholderHandler.addPlaceholder(new Placeholder("itemCount") {
@@ -153,6 +172,11 @@ public MultiLineComponent apply(PlaceholderContext ctx,
                 }
                 throw new InvalidArgsException();
             }
+
+            @Override
+            public boolean isView() {
+                return true;
+            }
         });
         PlaceholderHandler.addPlaceholder(new Placeholder("fluidCount") {
 
@@ -168,6 +192,11 @@ public MultiLineComponent apply(PlaceholderContext ctx,
                 PlaceholderUtils.checkArgs(args, 1);
                 return MultiLineComponent.empty(); // unreachable
             }
+
+            @Override
+            public boolean isView() {
+                return true;
+            }
         });
         PlaceholderHandler.addPlaceholder(new Placeholder("if") {
 
@@ -182,9 +211,16 @@ public MultiLineComponent apply(PlaceholderContext ctx,
                         return new MultiLineComponent(args.get(2)).setIgnoreSpaces(true);
                     } else return MultiLineComponent.empty();
                 } catch (NumberFormatException e) {
-                    return args.get(1);
+                    if (args.size() > 2 && args.get(0).equalsString(""))
+                        return args.get(2).setIgnoreSpaces(true);
+                    return args.get(1).setIgnoreSpaces(true);
                 }
             }
+
+            @Override
+            public boolean isPure() {
+                return true;
+            }
         });
         PlaceholderHandler.addPlaceholder(new Placeholder("color") {
 
@@ -242,13 +278,23 @@ public MultiLineComponent apply(PlaceholderContext ctx,
             @Override
             public MultiLineComponent apply(PlaceholderContext ctx,
                                             List<MultiLineComponent> args) throws PlaceholderException {
-                PlaceholderUtils.checkArgs(args, 2);
+                PlaceholderUtils.checkArgs(args, 1, true);
                 int count = PlaceholderUtils.toInt(args.get(0));
                 PlaceholderUtils.checkRange("n", 0, 50000, count);
+                MultiLineComponent arg = MultiLineComponent.empty();
+                for (int i = 1; i < args.size(); i++) {
+                    arg.append(args.get(i));
+                    if (i != args.size() - 1) arg.append(" ");
+                }
                 MultiLineComponent out = MultiLineComponent.empty();
-                for (int i = 0; i < count; i++) out.append(args.get(1));
+                for (int i = 0; i < count; i++) out.append(arg);
                 return out.setIgnoreSpaces(true);
             }
+
+            @Override
+            public boolean isPure() {
+                return true;
+            }
         });
         PlaceholderHandler.addPlaceholder(new Placeholder("block") {
 
@@ -258,6 +304,11 @@ public MultiLineComponent apply(PlaceholderContext ctx,
                 PlaceholderUtils.checkArgs(args, 0);
                 return MultiLineComponent.literal("█");
             }
+
+            @Override
+            public boolean isPure() {
+                return true;
+            }
         });
         PlaceholderHandler.addPlaceholder(new Placeholder("tick") {
 
@@ -267,6 +318,11 @@ public MultiLineComponent apply(PlaceholderContext ctx,
                 PlaceholderUtils.checkArgs(args, 0);
                 return MultiLineComponent.literal(ctx.level().getGameTime());
             }
+
+            @Override
+            public boolean isView() {
+                return true;
+            }
         });
         PlaceholderHandler.addPlaceholder(new Placeholder("select") {
 
@@ -278,6 +334,11 @@ public MultiLineComponent apply(PlaceholderContext ctx,
                 PlaceholderUtils.checkArgs(args, i + 1, true);
                 return new MultiLineComponent(args.get(i + 1)).setIgnoreSpaces(true);
             }
+
+            @Override
+            public boolean isPure() {
+                return true;
+            }
         });
         PlaceholderHandler.addPlaceholder(new Placeholder("redstone") {
 
@@ -312,6 +373,11 @@ public MultiLineComponent apply(PlaceholderContext ctx,
                 PlaceholderUtils.checkRange("line", 1, ctx.previousText().size(), i);
                 return MultiLineComponent.of(ctx.previousText().get(i - 1)).setIgnoreSpaces(true);
             }
+
+            @Override
+            public boolean isView() {
+                return true;
+            }
         });
         PlaceholderHandler.addPlaceholder(new Placeholder("progress") {
 
@@ -325,6 +391,11 @@ public MultiLineComponent apply(PlaceholderContext ctx,
                 if (workable == null) throw new NotSupportedException();
                 return MultiLineComponent.literal(workable.getProgress());
             }
+
+            @Override
+            public boolean isView() {
+                return true;
+            }
         });
         PlaceholderHandler.addPlaceholder(new Placeholder("maxProgress") {
 
@@ -338,6 +409,11 @@ public MultiLineComponent apply(PlaceholderContext ctx,
                 if (workable == null) throw new NotSupportedException();
                 return MultiLineComponent.literal(workable.getMaxProgress());
             }
+
+            @Override
+            public boolean isView() {
+                return true;
+            }
         });
         PlaceholderHandler.addPlaceholder(new Placeholder("maintenance") {
 
@@ -351,6 +427,11 @@ public MultiLineComponent apply(PlaceholderContext ctx,
                 if (maintenance == null) throw new NotSupportedException();
                 return MultiLineComponent.literal(maintenance.hasMaintenanceProblems() ? 1 : 0);
             }
+
+            @Override
+            public boolean isView() {
+                return true;
+            }
         });
         PlaceholderHandler.addPlaceholder(new Placeholder("active") {
 
@@ -364,6 +445,11 @@ public MultiLineComponent apply(PlaceholderContext ctx,
                 if (workable == null) throw new NotSupportedException();
                 return MultiLineComponent.literal(workable.isActive() ? 1 : 0);
             }
+
+            @Override
+            public boolean isView() {
+                return true;
+            }
         });
         PlaceholderHandler.addPlaceholder(new Placeholder("voltage") {
 
@@ -377,6 +463,11 @@ public MultiLineComponent apply(PlaceholderContext ctx,
                 }
                 throw new NotSupportedException();
             }
+
+            @Override
+            public boolean isView() {
+                return true;
+            }
         });
         PlaceholderHandler.addPlaceholder(new Placeholder("amperage") {
 
@@ -390,6 +481,11 @@ public MultiLineComponent apply(PlaceholderContext ctx,
                 }
                 throw new NotSupportedException();
             }
+
+            @Override
+            public boolean isView() {
+                return true;
+            }
         });
         PlaceholderHandler.addPlaceholder(new Placeholder("count") {
 
@@ -404,6 +500,11 @@ public MultiLineComponent apply(PlaceholderContext ctx,
                 }
                 return MultiLineComponent.literal(cnt);
             }
+
+            @Override
+            public boolean isPure() {
+                return true;
+            }
         });
         PlaceholderHandler.addPlaceholder(new Placeholder("data") {
 
@@ -413,6 +514,8 @@ public MultiLineComponent apply(PlaceholderContext ctx,
                 PlaceholderUtils.checkArgs(args, 2, true);
                 try {
                     int slot = PlaceholderUtils.toInt(args.get(1));
+                    slot = Math.max(slot, 1);
+                    PlaceholderUtils.checkRange("slot index", 1, 8, slot);
                     if (ctx.itemStackHandler() == null) throw new NotSupportedException();
                     PlaceholderUtils.checkRange("slot index", 0, ctx.itemStackHandler().getSlots(), slot);
                     ItemStack stack;
@@ -476,6 +579,11 @@ public MultiLineComponent apply(PlaceholderContext ctx, List<MultiLineComponent>
                 }
                 return out.setIgnoreSpaces(true);
             }
+
+            @Override
+            public boolean isPure() {
+                return true;
+            }
         });
         PlaceholderHandler.addPlaceholder(new Placeholder("nbt") {
 
@@ -493,6 +601,11 @@ public MultiLineComponent apply(PlaceholderContext ctx,
                 }
                 return tag == null ? MultiLineComponent.empty() : MultiLineComponent.literal(tag.toString());
             }
+
+            @Override
+            public boolean isView() {
+                return true;
+            }
         });
         PlaceholderHandler.addPlaceholder(new Placeholder("toChars") {
 
@@ -505,6 +618,11 @@ public MultiLineComponent apply(PlaceholderContext ctx,
                 for (char c : GTStringUtils.componentsToString(args.get(0)).toCharArray()) out.append(c).append(' ');
                 return MultiLineComponent.literal(out.substring(0, out.length() - 2));
             }
+
+            @Override
+            public boolean isPure() {
+                return true;
+            }
         });
         PlaceholderHandler.addPlaceholder(new Placeholder("toAscii") {
 
@@ -516,6 +634,11 @@ public MultiLineComponent apply(PlaceholderContext ctx,
                 if (arg.length() != 1) throw new InvalidArgsException();
                 return MultiLineComponent.literal((int) arg.toCharArray()[0]);
             }
+
+            @Override
+            public boolean isPure() {
+                return true;
+            }
         });
         PlaceholderHandler.addPlaceholder(new Placeholder("fromAscii") {
 
@@ -525,6 +648,11 @@ public MultiLineComponent apply(PlaceholderContext ctx,
                 PlaceholderUtils.checkArgs(args, 1);
                 return MultiLineComponent.literal((char) PlaceholderUtils.toInt(args.get(0))).setIgnoreSpaces(true);
             }
+
+            @Override
+            public boolean isPure() {
+                return true;
+            }
         });
         PlaceholderHandler.addPlaceholder(new Placeholder("subList") {
 
@@ -542,6 +670,11 @@ public MultiLineComponent apply(PlaceholderContext ctx,
                 out.setIgnoreSpaces(true);
                 return out;
             }
+
+            @Override
+            public boolean isPure() {
+                return true;
+            }
         });
         PlaceholderHandler.addPlaceholder(new Placeholder("cmp") {
 
@@ -561,6 +694,11 @@ public MultiLineComponent apply(PlaceholderContext ctx,
                     default -> throw new InvalidArgsException();
                 };
             }
+
+            @Override
+            public boolean isPure() {
+                return true;
+            }
         });
         PlaceholderHandler.addPlaceholder(new Placeholder("bf") {
 
@@ -727,6 +865,11 @@ public boolean shouldInformAdmins() {
             public MultiLineComponent apply(PlaceholderContext ctx, List<MultiLineComponent> args) {
                 return MultiLineComponent.literal("™");
             }
+
+            @Override
+            public boolean isPure() {
+                return true;
+            }
         });
         PlaceholderHandler.addPlaceholder(new Placeholder("formatInt") {
 
@@ -748,6 +891,11 @@ public MultiLineComponent apply(PlaceholderContext ctx,
                 return MultiLineComponent.literal(String.format(Locale.ROOT, "%.2f%s",
                         ((double) n) / max, suffixes.get(max)));
             }
+
+            @Override
+            public boolean isPure() {
+                return true;
+            }
         });
         PlaceholderHandler.addPlaceholder(new Placeholder("click") {
 
@@ -764,6 +912,11 @@ public MultiLineComponent apply(PlaceholderContext ctx,
                 if (args.get(0).equalsString("y")) return MultiLineComponent.literal(monitor.getClickPosY());
                 throw new InvalidArgsException();
             }
+
+            @Override
+            public boolean isView() {
+                return true;
+            }
         });
         PlaceholderHandler.addPlaceholder(new Placeholder("ender") {
 
@@ -782,29 +935,11 @@ public MultiLineComponent apply(PlaceholderContext ctx,
                     if (stack.getOrCreateTag().contains("boundPlayerUUID"))
                         owner = UUID.fromString(stack.getOrCreateTag().getString("boundPlayerUUID"));
                 }
-                VirtualEnderRegistry ender = VirtualEnderRegistry.getInstance();
+                VirtualEnderRegistry ender = VirtualEnderRegistry.get((ServerLevel) ctx.level());
                 switch (type) {
                     case "redstone" -> {
-                        channel = "ERLink#" + channel;
                         if (!ender.hasEntry(owner, EntryTypes.ENDER_REDSTONE, channel))
                             return MultiLineComponent.literal(0);
-                        if (args.size() > 4) {
-                            if (ctx.itemStackHandler() == null) throw new NotSupportedException();
-                            int slot = PlaceholderUtils.toInt(args.get(3));
-                            PlaceholderUtils.checkRange("slot index", 1, ctx.itemStackHandler().getSlots(), slot);
-                            ItemStack stack = ctx.itemStackHandler().getStackInSlot(slot - 1);
-                            UUID uuid;
-                            if (stack.getOrCreateTag().contains("enderRedstoneLinkTransmitterUUID")) {
-                                uuid = stack.getOrCreateTag().getUUID("enderRedstoneLinkTransmitterUUID");
-                            } else {
-                                uuid = UUID.randomUUID();
-                                stack.getOrCreateTag().putUUID("enderRedstoneLinkTransmitterUUID", uuid);
-                            }
-                            int power = PlaceholderUtils.toInt(args.get(4));
-                            PlaceholderUtils.checkRange("redstone signal", 0, 15, power);
-                            ender.getEntry(owner, EntryTypes.ENDER_REDSTONE, channel).setSignal(uuid, power);
-                            return MultiLineComponent.empty();
-                        }
                         return MultiLineComponent
                                 .literal(ender.getEntry(owner, EntryTypes.ENDER_REDSTONE, channel).getSignal());
                     }
@@ -860,9 +995,13 @@ public MultiLineComponent apply(PlaceholderContext ctx,
 
             @Override
             public MultiLineComponent apply(PlaceholderContext ctx,
-                                            List<MultiLineComponent> args) throws PlaceholderException {
-                PlaceholderUtils.checkArgs(args, 1);
-                return PlaceholderHandler.processPlaceholders(args.get(0).toString(), ctx);
+                                            List<MultiLineComponent> args) {
+                MultiLineComponent out = MultiLineComponent.empty();
+                for (int i = 0; i < args.size(); i++) {
+                    out.append(args.get(i));
+                    if (i != args.size() - 1) out.append(" ");
+                }
+                return PlaceholderHandler.processPlaceholders(out.toString(), ctx);
             }
         });
         PlaceholderHandler.addPlaceholder(new Placeholder("module") {
diff --git a/src/main/java/com/gregtechceu/gtceu/common/data/GTRecipeTypes.java b/src/main/java/com/gregtechceu/gtceu/common/data/GTRecipeTypes.java
index 35e97e539dc..d2a201686bd 100644
--- a/src/main/java/com/gregtechceu/gtceu/common/data/GTRecipeTypes.java
+++ b/src/main/java/com/gregtechceu/gtceu/common/data/GTRecipeTypes.java
@@ -17,13 +17,15 @@
 import com.gregtechceu.gtceu.api.sound.ExistingSoundEntry;
 import com.gregtechceu.gtceu.common.machine.multiblock.electric.FusionReactorMachine;
 import com.gregtechceu.gtceu.common.machine.trait.customlogic.*;
+import com.gregtechceu.gtceu.common.mui.GTGuiTextures;
 import com.gregtechceu.gtceu.common.recipe.condition.AdjacentFluidCondition;
+import com.gregtechceu.gtceu.common.recipe.type.EquipmentFoundryRecipe;
 import com.gregtechceu.gtceu.data.recipe.builder.GTRecipeBuilder;
 import com.gregtechceu.gtceu.integration.kjs.GTRegistryInfo;
-import com.gregtechceu.gtceu.integration.xei.entry.fluid.FluidEntryList;
-import com.gregtechceu.gtceu.integration.xei.entry.fluid.FluidHolderSetList;
-import com.gregtechceu.gtceu.integration.xei.handlers.fluid.CycleFluidEntryHandler;
-import com.gregtechceu.gtceu.integration.xei.handlers.item.CycleItemEntryHandler;
+import com.gregtechceu.gtceu.integration.recipeviewer.entry.fluid.FluidEntryList;
+import com.gregtechceu.gtceu.integration.recipeviewer.entry.fluid.FluidHolderSetList;
+import com.gregtechceu.gtceu.integration.recipeviewer.handlers.fluid.CycleFluidEntryHandler;
+import com.gregtechceu.gtceu.integration.recipeviewer.handlers.item.CycleItemEntryHandler;
 import com.gregtechceu.gtceu.utils.FormattingUtil;
 import com.gregtechceu.gtceu.utils.GTMath;
 import com.gregtechceu.gtceu.utils.ResearchManager;
@@ -33,6 +35,7 @@
 import net.minecraft.client.resources.language.I18n;
 import net.minecraft.core.HolderSet;
 import net.minecraft.core.registries.BuiltInRegistries;
+import net.minecraft.core.registries.Registries;
 import net.minecraft.resources.ResourceLocation;
 import net.minecraft.sounds.SoundEvents;
 import net.minecraft.sounds.SoundSource;
@@ -41,10 +44,14 @@
 import net.minecraft.world.level.material.Fluid;
 import net.minecraftforge.fml.ModLoader;
 
+import brachy.modularui.widgets.ProgressWidget;
+import com.tterrag.registrate.util.entry.RegistryEntry;
+
 import java.util.ArrayList;
 import java.util.Collections;
 import java.util.List;
 
+import static com.gregtechceu.gtceu.common.registry.GTRegistration.REGISTRATE;
 import static com.lowdragmc.lowdraglib.gui.texture.ProgressTexture.FillDirection.*;
 
 public class GTRecipeTypes {
@@ -60,6 +67,22 @@ public class GTRecipeTypes {
         GTRegistries.RECIPE_CATEGORIES.unfreeze();
     }
 
+    public static final RegistryEntry<? extends RecipeType<EquipmentFoundryRecipe>> EQUIPMENT_FOUNDRY_RECIPES = REGISTRATE
+            .generic("equipment_foundry",
+                    Registries.RECIPE_TYPE, () -> new RecipeType<EquipmentFoundryRecipe>() {
+
+                        @Override
+                        public String toString() {
+                            return "equipment_foundry";
+                        }
+                    })
+            .register();
+
+    public static final RegistryEntry<EquipmentFoundryRecipe.Serializer> EQUIPMENT_FOUNDRY_SERIALIZER = REGISTRATE
+            .generic("equipment_foundry",
+                    Registries.RECIPE_SERIALIZER, EquipmentFoundryRecipe.Serializer::new)
+            .register();
+
     //////////////////////////////////////
     // ********* Steam **********//
     //////////////////////////////////////
@@ -82,22 +105,28 @@ public class GTRecipeTypes {
     public final static GTRecipeType FURNACE_RECIPES = register("electric_furnace", ELECTRIC, RecipeType.SMELTING)
             .setMaxIOSize(1, 1, 0, 0).setEUIO(IO.IN)
             .prepareBuilder(recipeBuilder -> recipeBuilder.EUt(4))
-            .setSlotOverlay(false, false, GuiTextures.FURNACE_OVERLAY_1)
-            .setProgressBar(GuiTextures.PROGRESS_BAR_ARROW, LEFT_TO_RIGHT)
+            .UI(builder -> builder.setProgressBar(GTGuiTextures.PROGRESS_BAR_ARROW, 20)
+                    .setItemSlotOverlay(IO.IN, 0, GTGuiTextures.FURNACE_OVERLAY_1))
+            // .setSlotOverlay(false, false, GuiTextures.FURNACE_OVERLAY_1)
+            // .setProgressBar(GuiTextures.PROGRESS_BAR_ARROW, LEFT_TO_RIGHT)
             .setSteamProgressBar(GuiTextures.PROGRESS_BAR_ARROW_STEAM, LEFT_TO_RIGHT)
             .setSound(GTSoundEntries.FURNACE);
 
     public final static GTRecipeType ALLOY_SMELTER_RECIPES = register("alloy_smelter", ELECTRIC)
             .setMaxIOSize(2, 1, 0, 0).setEUIO(IO.IN)
-            .setSlotOverlay(false, false, GuiTextures.FURNACE_OVERLAY_1)
-            .setProgressBar(GuiTextures.PROGRESS_BAR_ARROW, LEFT_TO_RIGHT)
+            .UI(builder -> builder.setProgressBar(GTGuiTextures.PROGRESS_BAR_ARROW, 20)
+                    .setItemSlotOverlay(IO.IN, 0, GTGuiTextures.FURNACE_OVERLAY_1))
+            // .setSlotOverlay(false, false, GuiTextures.FURNACE_OVERLAY_1)
+            // .setProgressBar(GuiTextures.PROGRESS_BAR_ARROW, LEFT_TO_RIGHT)
             .setIconSupplier(() -> GTMachines.ALLOY_SMELTER[GTValues.LV].asStack())
             .setSteamProgressBar(GuiTextures.PROGRESS_BAR_ARROW_STEAM, LEFT_TO_RIGHT)
             .setSound(GTSoundEntries.FURNACE);
 
     public final static GTRecipeType ARC_FURNACE_RECIPES = register("arc_furnace", ELECTRIC).setMaxIOSize(1, 4, 1, 1)
             .setEUIO(IO.IN)
-            .setProgressBar(GuiTextures.PROGRESS_BAR_ARC_FURNACE, LEFT_TO_RIGHT)
+            .UI(builder -> builder.setProgressBar(GTGuiTextures.PROGRESS_BAR_ARROW, 20)
+                    .setIOSlotWidth(IO.OUT, ItemRecipeCapability.CAP, 0, 2))
+            // .setProgressBar(GuiTextures.PROGRESS_BAR_ARC_FURNACE, LEFT_TO_RIGHT)
             .setSound(GTSoundEntries.ARC)
             .onRecipeBuild((recipeBuilder, provider) -> {
                 if (recipeBuilder.input.getOrDefault(FluidRecipeCapability.CAP, Collections.emptyList()).isEmpty() &&
@@ -110,38 +139,53 @@ public class GTRecipeTypes {
 
     public final static GTRecipeType ASSEMBLER_RECIPES = register("assembler", ELECTRIC).setMaxIOSize(9, 1, 1, 0)
             .setEUIO(IO.IN)
-            .setSlotOverlay(false, false, GuiTextures.SLOT)
-            .setProgressBar(GuiTextures.PROGRESS_BAR_ASSEMBLER, LEFT_TO_RIGHT)
+            .UI(builder -> builder.setProgressBar(GTGuiTextures.PROGRESS_BAR_ASSEMBLER, 20))
+            // .setSlotOverlay(false, false, GuiTextures.SLOT)
+            // .setProgressBar(GuiTextures.PROGRESS_BAR_ASSEMBLER, LEFT_TO_RIGHT)
             .setSound(GTSoundEntries.ASSEMBLER);
 
     public final static GTRecipeType AUTOCLAVE_RECIPES = register("autoclave", ELECTRIC).setMaxIOSize(2, 2, 1, 1)
             .setEUIO(IO.IN)
-            .setSlotOverlay(false, false, GuiTextures.DUST_OVERLAY)
-            .setSlotOverlay(true, false, GuiTextures.CRYSTAL_OVERLAY)
-            .setProgressBar(GuiTextures.PROGRESS_BAR_CRYSTALLIZATION, LEFT_TO_RIGHT)
+            .UI(builder -> builder.setProgressBar(GTGuiTextures.PROGRESS_BAR_CRYSTALLIZATION, 20)
+                    .setItemSlotOverlay(IO.IN, 0, GTGuiTextures.DUST_OVERLAY)
+                    .setItemSlotOverlay(IO.OUT, 0, GTGuiTextures.CRYSTAL_OVERLAY))
+            // .setSlotOverlay(false, false, GuiTextures.DUST_OVERLAY)
+            // .setSlotOverlay(true, false, GuiTextures.CRYSTAL_OVERLAY)
+            // .setProgressBar(GuiTextures.PROGRESS_BAR_CRYSTALLIZATION, LEFT_TO_RIGHT)
             .setSound(GTSoundEntries.FURNACE);
 
     public final static GTRecipeType BENDER_RECIPES = register("bender", ELECTRIC).setMaxIOSize(2, 1, 0, 0)
             .setEUIO(IO.IN)
-            .setSlotOverlay(false, false, false, GuiTextures.BENDER_OVERLAY)
-            .setSlotOverlay(false, false, true, GuiTextures.INT_CIRCUIT_OVERLAY)
-            .setProgressBar(GuiTextures.PROGRESS_BAR_BENDING, LEFT_TO_RIGHT)
+            .UI(builder -> builder.setProgressBar(GTGuiTextures.PROGRESS_BAR_BENDING, 20)
+                    .setItemSlotOverlay(IO.IN, 0, GTGuiTextures.BENDER_OVERLAY)
+                    .setItemSlotOverlay(IO.IN, 1, GTGuiTextures.INT_CIRCUIT_OVERLAY))
+            // .setSlotOverlay(false, false, false, GuiTextures.BENDER_OVERLAY)
+            // .setSlotOverlay(false, false, true, GuiTextures.INT_CIRCUIT_OVERLAY)
+            // .setProgressBar(GuiTextures.PROGRESS_BAR_BENDING, LEFT_TO_RIGHT)
             .setSound(GTSoundEntries.MOTOR);
 
     public final static GTRecipeType BREWING_RECIPES = register("brewery", ELECTRIC).setMaxIOSize(1, 0, 1, 1)
             .setEUIO(IO.IN)
             .prepareBuilder(recipeBuilder -> recipeBuilder.duration(128).EUt(4))
-            .setSlotOverlay(false, false, GuiTextures.BREWER_OVERLAY)
-            .setProgressBar(GuiTextures.PROGRESS_BAR_ARROW_MULTIPLE, LEFT_TO_RIGHT)
+            .UI(builder -> builder.setProgressBar(GTGuiTextures.PROGRESS_BAR_ARROW_MULTIPLE, 20)
+                    .setItemSlotOverlay(IO.IN, 0, GTGuiTextures.BREWER_OVERLAY))
+            // .setSlotOverlay(false, false, GuiTextures.BREWER_OVERLAY)
+            // .setProgressBar(GuiTextures.PROGRESS_BAR_ARROW_MULTIPLE, LEFT_TO_RIGHT)
             .addCustomRecipeLogic(BreweryLogic.INSTANCE)
             .setSound(GTSoundEntries.CHEMICAL);
 
     public final static GTRecipeType MACERATOR_RECIPES = register("macerator", ELECTRIC).setMaxIOSize(1, 4, 0, 0)
             .setEUIO(IO.IN)
             .prepareBuilder(recipeBuilder -> recipeBuilder.duration(150).EUt(2))
-            .setSlotOverlay(false, false, GuiTextures.CRUSHED_ORE_OVERLAY)
-            .setSlotOverlay(true, false, GuiTextures.DUST_OVERLAY)
-            .setProgressBar(GuiTextures.PROGRESS_BAR_MACERATE, LEFT_TO_RIGHT)
+            .UI(builder -> builder.setProgressBar(GTGuiTextures.PROGRESS_BAR_MACERATE, 20)
+                    .setItemSlotOverlay(IO.IN, 0, GTGuiTextures.CRUSHED_ORE_OVERLAY)
+                    .setItemSlotsOverlay(IO.OUT, 0, 3, GTGuiTextures.DUST_OVERLAY)
+                    .setIOSlotLengths(IO.OUT, ItemRecipeCapability.CAP, 0, 2, 1)
+                    .setIOSlotLength(IO.OUT, ItemRecipeCapability.CAP, 3, 3)
+                    .setIOSlotWidths(IO.OUT, ItemRecipeCapability.CAP, 4, GTValues.MAX, 2))
+            // .setSlotOverlay(false, false, GuiTextures.CRUSHED_ORE_OVERLAY)
+            // .setSlotOverlay(true, false, GuiTextures.DUST_OVERLAY)
+            // .setProgressBar(GuiTextures.PROGRESS_BAR_MACERATE, LEFT_TO_RIGHT)
             .setIconSupplier(() -> GTMachines.MACERATOR[GTValues.LV].asStack())
             .setSteamProgressBar(GuiTextures.PROGRESS_BAR_MACERATE_STEAM, LEFT_TO_RIGHT)
             .addCustomRecipeLogic(MaceratorLogic.INSTANCE)
@@ -150,43 +194,65 @@ public class GTRecipeTypes {
 
     public final static GTRecipeType CANNER_RECIPES = register("canner", ELECTRIC).setMaxIOSize(2, 2, 1, 1)
             .setEUIO(IO.IN)
-            .setSlotOverlay(false, false, false, GuiTextures.CANNER_OVERLAY)
-            .setSlotOverlay(false, false, true, GuiTextures.CANISTER_OVERLAY)
-            .setSlotOverlay(true, false, GuiTextures.CANISTER_OVERLAY)
-            .setSlotOverlay(false, true, GuiTextures.DARK_CANISTER_OVERLAY)
-            .setSlotOverlay(true, true, GuiTextures.DARK_CANISTER_OVERLAY)
-            .setProgressBar(GuiTextures.PROGRESS_BAR_CANNER, LEFT_TO_RIGHT)
+            .UI(builder -> builder.setProgressBar(GTGuiTextures.PROGRESS_BAR_CANNER, 20)
+                    .setItemSlotOverlay(IO.IN, 0, GTGuiTextures.CANNER_OVERLAY)
+                    .setItemSlotOverlay(IO.IN, 1, GTGuiTextures.CANISTER_OVERLAY)
+                    .setItemSlotOverlay(IO.OUT, 0, GTGuiTextures.CANISTER_OVERLAY)
+                    .setFluidSlotOverlay(IO.IN, 0, GTGuiTextures.DARK_CANISTER_OVERLAY)
+                    .setFluidSlotOverlay(IO.OUT, 0, GTGuiTextures.DARK_CANISTER_OVERLAY))
+            // .setSlotOverlay(false, false, false, GuiTextures.CANNER_OVERLAY)
+            // .setSlotOverlay(false, false, true, GuiTextures.CANISTER_OVERLAY)
+            // .setSlotOverlay(true, false, GuiTextures.CANISTER_OVERLAY)
+            // .setSlotOverlay(false, true, GuiTextures.DARK_CANISTER_OVERLAY)
+            // .setSlotOverlay(true, true, GuiTextures.DARK_CANISTER_OVERLAY)
+            // .setProgressBar(GuiTextures.PROGRESS_BAR_CANNER, LEFT_TO_RIGHT)
             .addCustomRecipeLogic(CannerLogic.INSTANCE)
             .setSound(GTSoundEntries.BATH);
 
     public final static GTRecipeType CENTRIFUGE_RECIPES = register("centrifuge", ELECTRIC).setMaxIOSize(2, 6, 1, 6)
             .setEUIO(IO.IN)
             .prepareBuilder(recipeBuilder -> recipeBuilder.EUt(5))
-            .setSlotOverlay(false, false, false, GuiTextures.EXTRACTOR_OVERLAY)
-            .setSlotOverlay(false, false, true, GuiTextures.CANISTER_OVERLAY)
-            .setSlotOverlay(false, true, true, GuiTextures.CENTRIFUGE_OVERLAY)
-            .setProgressBar(GuiTextures.PROGRESS_BAR_EXTRACT, LEFT_TO_RIGHT)
+            .UI(builder -> builder.setProgressBar(GTGuiTextures.PROGRESS_BAR_EXTRACT, 20)
+                    .setItemSlotOverlay(IO.IN, 0, GTGuiTextures.EXTRACTOR_OVERLAY)
+                    .setItemSlotOverlay(IO.IN, 1, GTGuiTextures.CANISTER_OVERLAY)
+                    .setFluidSlotOverlay(IO.IN, 0, GTGuiTextures.CENTRIFUGE_OVERLAY))
+            // .setSlotOverlay(false, false, false, GuiTextures.EXTRACTOR_OVERLAY)
+            // .setSlotOverlay(false, false, true, GuiTextures.CANISTER_OVERLAY)
+            // .setSlotOverlay(false, true, true, GuiTextures.CENTRIFUGE_OVERLAY)
+            // .setProgressBar(GuiTextures.PROGRESS_BAR_EXTRACT, LEFT_TO_RIGHT)
             .setSound(GTSoundEntries.CENTRIFUGE);
 
     public final static GTRecipeType CHEMICAL_BATH_RECIPES = register("chemical_bath", ELECTRIC)
             .setMaxIOSize(1, 6, 1, 1).setEUIO(IO.IN)
             .prepareBuilder(recipeBuilder -> recipeBuilder.EUt(GTValues.VA[GTValues.LV]))
-            .setSlotOverlay(false, false, true, GuiTextures.BREWER_OVERLAY)
-            .setSlotOverlay(true, false, false, GuiTextures.DUST_OVERLAY)
-            .setSlotOverlay(true, false, true, GuiTextures.DUST_OVERLAY)
-            .setProgressBar(GuiTextures.PROGRESS_BAR_MIXER, LEFT_TO_RIGHT)
+            .UI(builder -> builder
+                    .setProgressBar(GTGuiTextures.PROGRESS_BAR_MIXER, 20, ProgressWidget.Direction.CIRCULAR_CW)
+                    .setItemSlotOverlay(IO.IN, 0, GTGuiTextures.BREWER_OVERLAY)
+                    .setItemSlotsOverlay(IO.OUT, 0, 5, GTGuiTextures.DUST_OVERLAY)
+                    .setFluidSlotOverlay(IO.IN, 0, GTGuiTextures.CENTRIFUGE_OVERLAY))
+            // .setSlotOverlay(false, false, true, GuiTextures.BREWER_OVERLAY)
+            // .setSlotOverlay(true, false, false, GuiTextures.DUST_OVERLAY)
+            // .setSlotOverlay(true, false, true, GuiTextures.DUST_OVERLAY)
+            // .setProgressBar(GuiTextures.PROGRESS_BAR_MIXER, LEFT_TO_RIGHT)
             .setSound(GTSoundEntries.BATH);
 
     public final static GTRecipeType CHEMICAL_RECIPES = register("chemical_reactor", ELECTRIC).setMaxIOSize(2, 2, 3, 2)
             .setEUIO(IO.IN)
             .prepareBuilder(recipeBuilder -> recipeBuilder.EUt(GTValues.VA[GTValues.LV]))
-            .setSlotOverlay(false, false, false, GuiTextures.MOLECULAR_OVERLAY_1)
-            .setSlotOverlay(false, false, true, GuiTextures.MOLECULAR_OVERLAY_2)
-            .setSlotOverlay(false, true, false, GuiTextures.MOLECULAR_OVERLAY_3)
-            .setSlotOverlay(false, true, true, GuiTextures.MOLECULAR_OVERLAY_4)
-            .setSlotOverlay(true, false, GuiTextures.VIAL_OVERLAY_1)
-            .setSlotOverlay(true, true, GuiTextures.VIAL_OVERLAY_2)
-            .setProgressBar(GuiTextures.PROGRESS_BAR_ARROW_MULTIPLE, LEFT_TO_RIGHT)
+            .UI(builder -> builder.setProgressBar(GTGuiTextures.PROGRESS_BAR_ARROW_MULTIPLE, 20)
+                    .setItemSlotOverlay(IO.IN, 0, GTGuiTextures.MOLECULAR_OVERLAY_1)
+                    .setItemSlotOverlay(IO.IN, 1, GTGuiTextures.MOLECULAR_OVERLAY_2)
+                    .setFluidSlotOverlay(IO.IN, 0, GTGuiTextures.MOLECULAR_OVERLAY_3)
+                    .setFluidSlotOverlay(IO.IN, 1, GTGuiTextures.MOLECULAR_OVERLAY_4)
+                    .setItemSlotOverlay(IO.OUT, 0, GTGuiTextures.VIAL_OVERLAY_1)
+                    .setFluidSlotOverlay(IO.OUT, 0, GTGuiTextures.VIAL_OVERLAY_2))
+            // .setSlotOverlay(false, false, false, GuiTextures.MOLECULAR_OVERLAY_1)
+            // .setSlotOverlay(false, false, true, GuiTextures.MOLECULAR_OVERLAY_2)
+            // .setSlotOverlay(false, true, false, GuiTextures.MOLECULAR_OVERLAY_3)
+            // .setSlotOverlay(false, true, true, GuiTextures.MOLECULAR_OVERLAY_4)
+            // .setSlotOverlay(true, false, GuiTextures.VIAL_OVERLAY_1)
+            // .setSlotOverlay(true, true, GuiTextures.VIAL_OVERLAY_2)
+            // .setProgressBar(GuiTextures.PROGRESS_BAR_ARROW_MULTIPLE, LEFT_TO_RIGHT)
             .setSound(GTValues.FOOLS.getAsBoolean() ? GTSoundEntries.SCIENCE : GTSoundEntries.CHEMICAL)
             .onRecipeBuild((recipeBuilder, provider) -> GTRecipeTypes.LARGE_CHEMICAL_RECIPES.copyFrom(recipeBuilder)
                     .save(provider));
@@ -194,18 +260,24 @@ public class GTRecipeTypes {
     public final static GTRecipeType COMPRESSOR_RECIPES = register("compressor", ELECTRIC).setMaxIOSize(1, 1, 0, 0)
             .setEUIO(IO.IN)
             .prepareBuilder(recipeBuilder -> recipeBuilder.duration(200).EUt(2))
-            .setSlotOverlay(false, false, GuiTextures.COMPRESSOR_OVERLAY)
-            .setProgressBar(GuiTextures.PROGRESS_BAR_COMPRESS, LEFT_TO_RIGHT)
+            .UI(builder -> builder.setProgressBar(GTGuiTextures.PROGRESS_BAR_COMPRESS, 20)
+                    .setItemSlotOverlay(IO.IN, 0, GTGuiTextures.COMPRESSOR_OVERLAY))
+            // .setSlotOverlay(false, false, GuiTextures.COMPRESSOR_OVERLAY)
+            // .setProgressBar(GuiTextures.PROGRESS_BAR_COMPRESS, LEFT_TO_RIGHT)
             .setIconSupplier(() -> GTMachines.COMPRESSOR[GTValues.LV].asStack())
             .setSteamProgressBar(GuiTextures.PROGRESS_BAR_COMPRESS_STEAM, LEFT_TO_RIGHT)
             .setSound(GTSoundEntries.COMPRESSOR);
 
     public final static GTRecipeType CUTTER_RECIPES = register("cutter", ELECTRIC).setMaxIOSize(1, 2, 1, 0)
             .setEUIO(IO.IN)
-            .setSlotOverlay(false, false, GuiTextures.SAWBLADE_OVERLAY)
-            .setSlotOverlay(true, false, false, GuiTextures.CUTTER_OVERLAY)
-            .setSlotOverlay(true, false, true, GuiTextures.DUST_OVERLAY)
-            .setProgressBar(GuiTextures.PROGRESS_BAR_SLICE, LEFT_TO_RIGHT)
+            .UI(builder -> builder.setProgressBar(GTGuiTextures.PROGRESS_BAR_SLICE, 20)
+                    .setItemSlotOverlay(IO.IN, 0, GTGuiTextures.SAWBLADE_OVERLAY)
+                    .setItemSlotOverlay(IO.OUT, 0, GTGuiTextures.CUTTER_OVERLAY)
+                    .setItemSlotOverlay(IO.OUT, 1, GTGuiTextures.DUST_OVERLAY))
+            // .setSlotOverlay(false, false, GuiTextures.SAWBLADE_OVERLAY)
+            // .setSlotOverlay(true, false, false, GuiTextures.CUTTER_OVERLAY)
+            // .setSlotOverlay(true, false, true, GuiTextures.DUST_OVERLAY)
+            // .setProgressBar(GuiTextures.PROGRESS_BAR_SLICE, LEFT_TO_RIGHT)
             .setSound(GTSoundEntries.CUT)
             .onRecipeBuild((recipeBuilder, provider) -> {
                 if (recipeBuilder.input.getOrDefault(FluidRecipeCapability.CAP, Collections.emptyList()).isEmpty() &&
@@ -233,141 +305,195 @@ public class GTRecipeTypes {
 
     public final static GTRecipeType DISTILLERY_RECIPES = register("distillery", ELECTRIC).setMaxIOSize(1, 1, 1, 1)
             .setEUIO(IO.IN)
-            .setSlotOverlay(false, true, GuiTextures.BEAKER_OVERLAY_1)
-            .setSlotOverlay(true, true, GuiTextures.BEAKER_OVERLAY_4)
-            .setSlotOverlay(true, false, GuiTextures.DUST_OVERLAY)
-            .setSlotOverlay(false, false, GuiTextures.INT_CIRCUIT_OVERLAY)
-            .setProgressBar(GuiTextures.PROGRESS_BAR_ARROW_MULTIPLE, LEFT_TO_RIGHT)
+            .UI(builder -> builder.setProgressBar(GTGuiTextures.PROGRESS_BAR_ARROW_MULTIPLE, 20)
+                    .setItemSlotOverlay(IO.IN, 0, GTGuiTextures.INT_CIRCUIT_OVERLAY)
+                    .setItemSlotOverlay(IO.OUT, 0, GTGuiTextures.DUST_OVERLAY)
+                    .setFluidSlotOverlay(IO.IN, 0, GTGuiTextures.BEAKER_OVERLAY_1)
+                    .setFluidSlotOverlay(IO.OUT, 0, GTGuiTextures.BEAKER_OVERLAY_4))
+            // .setSlotOverlay(false, true, GuiTextures.BEAKER_OVERLAY_1)
+            // .setSlotOverlay(true, true, GuiTextures.BEAKER_OVERLAY_4)
+            // .setSlotOverlay(true, false, GuiTextures.DUST_OVERLAY)
+            // .setSlotOverlay(false, false, GuiTextures.INT_CIRCUIT_OVERLAY)
+            // .setProgressBar(GuiTextures.PROGRESS_BAR_ARROW_MULTIPLE, LEFT_TO_RIGHT)
             .setSound(GTSoundEntries.BOILER);
 
     public final static GTRecipeType ELECTROLYZER_RECIPES = register("electrolyzer", ELECTRIC).setMaxIOSize(2, 6, 1, 6)
             .setEUIO(IO.IN)
-            .setSlotOverlay(false, false, false, GuiTextures.LIGHTNING_OVERLAY_1)
-            .setSlotOverlay(false, false, true, GuiTextures.CANISTER_OVERLAY)
-            .setSlotOverlay(false, true, true, GuiTextures.LIGHTNING_OVERLAY_2)
-            .setProgressBar(GuiTextures.PROGRESS_BAR_EXTRACT, LEFT_TO_RIGHT)
+            .UI(builder -> builder.setProgressBar(GTGuiTextures.PROGRESS_BAR_EXTRACT, 20)
+                    .setItemSlotOverlay(IO.IN, 0, GTGuiTextures.LIGHTNING_OVERLAY_1)
+                    .setItemSlotOverlay(IO.IN, 1, GTGuiTextures.CANISTER_OVERLAY)
+                    .setFluidSlotsOverlay(IO.IN, 0, 5, GTGuiTextures.LIGHTNING_OVERLAY_2))
+            // .setSlotOverlay(false, false, false, GuiTextures.LIGHTNING_OVERLAY_1)
+            // .setSlotOverlay(false, false, true, GuiTextures.CANISTER_OVERLAY)
+            // .setSlotOverlay(false, true, true, GuiTextures.LIGHTNING_OVERLAY_2)
+            // .setProgressBar(GuiTextures.PROGRESS_BAR_EXTRACT, LEFT_TO_RIGHT)
             .setSound(GTSoundEntries.ELECTROLYZER);
 
     public final static GTRecipeType ELECTROMAGNETIC_SEPARATOR_RECIPES = register("electromagnetic_separator", ELECTRIC)
             .setMaxIOSize(1, 3, 0, 0).setEUIO(IO.IN)
-            .setSlotOverlay(false, false, GuiTextures.CRUSHED_ORE_OVERLAY)
-            .setSlotOverlay(true, false, GuiTextures.DUST_OVERLAY)
-            .setProgressBar(GuiTextures.PROGRESS_BAR_MAGNET, LEFT_TO_RIGHT)
+            .UI(builder -> builder.setProgressBar(GTGuiTextures.PROGRESS_BAR_MAGNET, 20)
+                    .setItemSlotOverlay(IO.IN, 0, GTGuiTextures.CRUSHED_ORE_OVERLAY)
+                    .setItemSlotOverlay(IO.OUT, 0, GTGuiTextures.DUST_OVERLAY))
+            // .setSlotOverlay(false, false, GuiTextures.CRUSHED_ORE_OVERLAY)
+            // .setSlotOverlay(true, false, GuiTextures.DUST_OVERLAY)
+            // .setProgressBar(GuiTextures.PROGRESS_BAR_MAGNET, LEFT_TO_RIGHT)
             .setSound(GTSoundEntries.ARC);
 
     public final static GTRecipeType EXTRACTOR_RECIPES = register("extractor", ELECTRIC).setMaxIOSize(1, 1, 0, 1)
             .setEUIO(IO.IN)
             .prepareBuilder(recipeBuilder -> recipeBuilder.duration(400).EUt(2))
-            .setSlotOverlay(false, false, GuiTextures.EXTRACTOR_OVERLAY)
-            .setProgressBar(GuiTextures.PROGRESS_BAR_EXTRACT, LEFT_TO_RIGHT)
+            .UI(builder -> builder.setProgressBar(GTGuiTextures.PROGRESS_BAR_EXTRACT, 20)
+                    .setItemSlotOverlay(IO.IN, 0, GTGuiTextures.EXTRACTOR_OVERLAY))
+            // .setSlotOverlay(false, false, GuiTextures.EXTRACTOR_OVERLAY)
+            // .setProgressBar(GuiTextures.PROGRESS_BAR_EXTRACT, LEFT_TO_RIGHT)
             .setIconSupplier(() -> GTMachines.EXTRACTOR[GTValues.LV].asStack())
             .setSteamProgressBar(GuiTextures.PROGRESS_BAR_EXTRACT_STEAM, LEFT_TO_RIGHT);
 
     public final static GTRecipeType EXTRUDER_RECIPES = register("extruder", ELECTRIC).setMaxIOSize(2, 1, 0, 0)
             .setEUIO(IO.IN)
-            .setSlotOverlay(false, false, true, GuiTextures.MOLD_OVERLAY)
-            .setProgressBar(GuiTextures.PROGRESS_BAR_EXTRUDER, LEFT_TO_RIGHT)
+            .UI(builder -> builder.setProgressBar(GTGuiTextures.PROGRESS_BAR_EXTRUDER, 20)
+                    .setItemSlotOverlay(IO.IN, 1, GTGuiTextures.MOLD_OVERLAY))
+            // .setSlotOverlay(false, false, true, GuiTextures.MOLD_OVERLAY)
+            // .setProgressBar(GuiTextures.PROGRESS_BAR_EXTRUDER, LEFT_TO_RIGHT)
             .setSound(GTSoundEntries.COMPRESSOR);
 
     public final static GTRecipeType FERMENTING_RECIPES = register("fermenter", ELECTRIC).setMaxIOSize(1, 1, 1, 1)
             .setEUIO(IO.IN)
             .prepareBuilder(recipeBuilder -> recipeBuilder.EUt(2))
-            .setSlotOverlay(false, false, true, GuiTextures.DUST_OVERLAY)
-            .setSlotOverlay(true, false, true, GuiTextures.DUST_OVERLAY)
-            .setProgressBar(GuiTextures.PROGRESS_BAR_ARROW, LEFT_TO_RIGHT)
+            .UI(builder -> builder.setProgressBar(GTGuiTextures.PROGRESS_BAR_ARROW, 20)
+                    .setItemSlotOverlay(IO.IN, 0, GTGuiTextures.DUST_OVERLAY)
+                    .setItemSlotOverlay(IO.OUT, 0, GTGuiTextures.DUST_OVERLAY))
+            // .setSlotOverlay(false, false, true, GuiTextures.DUST_OVERLAY)
+            // .setSlotOverlay(true, false, true, GuiTextures.DUST_OVERLAY)
+            // .setProgressBar(GuiTextures.PROGRESS_BAR_ARROW, LEFT_TO_RIGHT)
             .setSound(GTSoundEntries.CHEMICAL);
 
     public final static GTRecipeType FLUID_HEATER_RECIPES = register("fluid_heater", ELECTRIC).setMaxIOSize(1, 0, 1, 1)
             .setEUIO(IO.IN)
-            .setSlotOverlay(false, true, GuiTextures.HEATING_OVERLAY_1)
-            .setSlotOverlay(true, true, GuiTextures.HEATING_OVERLAY_2)
-            .setSlotOverlay(false, false, GuiTextures.INT_CIRCUIT_OVERLAY)
-            .setProgressBar(GuiTextures.PROGRESS_BAR_ARROW, LEFT_TO_RIGHT)
+            .UI(builder -> builder.setProgressBar(GTGuiTextures.PROGRESS_BAR_ARROW, 20)
+                    .setItemSlotOverlay(IO.IN, 0, GTGuiTextures.INT_CIRCUIT_OVERLAY)
+                    .setFluidSlotOverlay(IO.IN, 0, GTGuiTextures.HEATING_OVERLAY_1)
+                    .setFluidSlotOverlay(IO.OUT, 0, GTGuiTextures.HEATING_OVERLAY_2))
+            // .setSlotOverlay(false, true, GuiTextures.HEATING_OVERLAY_1)
+            // .setSlotOverlay(true, true, GuiTextures.HEATING_OVERLAY_2)
+            // .setSlotOverlay(false, false, GuiTextures.INT_CIRCUIT_OVERLAY)
+            // .setProgressBar(GuiTextures.PROGRESS_BAR_ARROW, LEFT_TO_RIGHT)
             .setSound(GTSoundEntries.BOILER);
 
     public final static GTRecipeType FLUID_SOLIDFICATION_RECIPES = register("fluid_solidifier", ELECTRIC)
             .setMaxIOSize(1, 1, 1, 0).setEUIO(IO.IN)
-            .setSlotOverlay(false, false, GuiTextures.SOLIDIFIER_OVERLAY)
-            .setProgressBar(GuiTextures.PROGRESS_BAR_ARROW, LEFT_TO_RIGHT)
+            .UI(builder -> builder.setProgressBar(GTGuiTextures.PROGRESS_BAR_ARROW, 20)
+                    .setItemSlotOverlay(IO.IN, 0, GTGuiTextures.SOLIDIFIER_OVERLAY))
+            // .setSlotOverlay(false, false, GuiTextures.SOLIDIFIER_OVERLAY)
+            // .setProgressBar(GuiTextures.PROGRESS_BAR_ARROW, LEFT_TO_RIGHT)
             .setSound(GTSoundEntries.COOLING);
 
     public final static GTRecipeType FORGE_HAMMER_RECIPES = register("forge_hammer", ELECTRIC).setMaxIOSize(1, 1, 0, 0)
             .setEUIO(IO.IN)
-            .setSlotOverlay(false, false, GuiTextures.HAMMER_OVERLAY)
-            .setProgressBar(GuiTextures.PROGRESS_BAR_HAMMER, UP_TO_DOWN)
+            .UI(builder -> builder.setProgressBar(GTGuiTextures.PROGRESS_BAR_HAMMER, 20, ProgressWidget.Direction.DOWN)
+                    .setItemSlotOverlay(IO.IN, 0, GTGuiTextures.HAMMER_OVERLAY))
+            // .setSlotOverlay(false, false, GuiTextures.HAMMER_OVERLAY)
+            // .setProgressBar(GuiTextures.PROGRESS_BAR_HAMMER, UP_TO_DOWN)
             .setIconSupplier(() -> GTMachines.FORGE_HAMMER[GTValues.LV].asStack())
             .setSteamProgressBar(GuiTextures.PROGRESS_BAR_HAMMER_STEAM, UP_TO_DOWN)
             .setSound(GTSoundEntries.FORGE_HAMMER);
 
     public final static GTRecipeType FORMING_PRESS_RECIPES = register("forming_press", ELECTRIC)
             .setMaxIOSize(6, 1, 0, 0).setEUIO(IO.IN)
-            .setProgressBar(GuiTextures.PROGRESS_BAR_COMPRESS, LEFT_TO_RIGHT)
+            .UI(builder -> builder.setProgressBar(GTGuiTextures.PROGRESS_BAR_COMPRESS, 20))
+            // .setProgressBar(GuiTextures.PROGRESS_BAR_COMPRESS, LEFT_TO_RIGHT)
             .addCustomRecipeLogic(FormingPressLogic.INSTANCE)
             .setSound(GTSoundEntries.COMPRESSOR);
 
     public final static GTRecipeType LATHE_RECIPES = register("lathe", ELECTRIC).setMaxIOSize(1, 2, 0, 0).setEUIO(IO.IN)
-            .setSlotOverlay(false, false, GuiTextures.PIPE_OVERLAY_1)
-            .setSlotOverlay(true, false, false, GuiTextures.PIPE_OVERLAY_2)
-            .setSlotOverlay(true, false, true, GuiTextures.DUST_OVERLAY)
-            .setProgressBar(GuiTextures.PROGRESS_BAR_LATHE, LEFT_TO_RIGHT)
+            .UI(builder -> builder.setProgressBar(GTGuiTextures.PROGRESS_BAR_LATHE, 20)
+                    .setItemSlotOverlay(IO.IN, 0, GTGuiTextures.PIPE_OVERLAY_1)
+                    .setItemSlotOverlay(IO.OUT, 0, GTGuiTextures.PIPE_OVERLAY_2)
+                    .setItemSlotOverlay(IO.OUT, 1, GTGuiTextures.DUST_OVERLAY))
+            // .setSlotOverlay(false, false, GuiTextures.PIPE_OVERLAY_1)
+            // .setSlotOverlay(true, false, false, GuiTextures.PIPE_OVERLAY_2)
+            // .setSlotOverlay(true, false, true, GuiTextures.DUST_OVERLAY)
+            // .setProgressBar(GuiTextures.PROGRESS_BAR_LATHE, LEFT_TO_RIGHT)
             .setSound(GTSoundEntries.CUT);
 
     public final static GTRecipeType MIXER_RECIPES = register("mixer", ELECTRIC).setMaxIOSize(6, 1, 2, 1).setEUIO(IO.IN)
-            .setSlotOverlay(false, false, GuiTextures.DUST_OVERLAY)
-            .setSlotOverlay(true, false, GuiTextures.DUST_OVERLAY)
-            .setProgressBar(GuiTextures.PROGRESS_BAR_MIXER, LEFT_TO_RIGHT)
+            .UI(builder -> builder
+                    .setProgressBar(GTGuiTextures.PROGRESS_BAR_MIXER, 20, ProgressWidget.Direction.CIRCULAR_CW)
+                    .setItemSlotsOverlay(IO.IN, 0, 5, GTGuiTextures.DUST_OVERLAY)
+                    .setItemSlotOverlay(IO.OUT, 0, GTGuiTextures.DUST_OVERLAY))
+            // .setSlotOverlay(false, false, GuiTextures.DUST_OVERLAY)
+            // .setSlotOverlay(true, false, GuiTextures.DUST_OVERLAY)
+            // .setProgressBar(GuiTextures.PROGRESS_BAR_MIXER, LEFT_TO_RIGHT)
             .setSound(GTSoundEntries.MIXER);
 
     public final static GTRecipeType ORE_WASHER_RECIPES = register("ore_washer", ELECTRIC).setMaxIOSize(2, 3, 1, 0)
             .setEUIO(IO.IN)
             .prepareBuilder(recipeBuilder -> recipeBuilder.duration(400).EUt(16))
-            .setSlotOverlay(false, false, GuiTextures.CRUSHED_ORE_OVERLAY)
-            .setSlotOverlay(true, false, GuiTextures.DUST_OVERLAY)
-            .setProgressBar(GuiTextures.PROGRESS_BAR_BATH, LEFT_TO_RIGHT)
+            .UI(builder -> builder
+                    .setProgressBar(GTGuiTextures.PROGRESS_BAR_BATH, 20, ProgressWidget.Direction.CIRCULAR_CW)
+                    .setItemSlotOverlay(IO.IN, 0, GTGuiTextures.CRUSHED_ORE_OVERLAY)
+                    .setItemSlotOverlay(IO.OUT, 0, GTGuiTextures.DUST_OVERLAY))
+            // .setSlotOverlay(false, false, GuiTextures.CRUSHED_ORE_OVERLAY)
+            // .setSlotOverlay(true, false, GuiTextures.DUST_OVERLAY)
+            // .setProgressBar(GuiTextures.PROGRESS_BAR_BATH, LEFT_TO_RIGHT)
             .setSound(GTSoundEntries.BATH);
 
     public final static GTRecipeType PACKER_RECIPES = register("packer", ELECTRIC).setMaxIOSize(2, 2, 0, 0)
             .setEUIO(IO.IN)
             .prepareBuilder(recipeBuilder -> recipeBuilder.EUt(12).duration(10))
-            .setSlotOverlay(false, false, true, GuiTextures.BOX_OVERLAY)
-            .setSlotOverlay(true, false, GuiTextures.BOXED_OVERLAY)
-            .setProgressBar(GuiTextures.PROGRESS_BAR_UNPACKER, LEFT_TO_RIGHT)
+            .UI(builder -> builder.setProgressBar(GTGuiTextures.PROGRESS_BAR_UNPACKER, 20)
+                    .setItemSlotOverlay(IO.IN, 1, GTGuiTextures.BOX_OVERLAY)
+                    .setItemSlotOverlay(IO.OUT, 0, GTGuiTextures.BOX_OVERLAY))
+            // .setSlotOverlay(false, false, true, GuiTextures.BOX_OVERLAY)
+            // .setSlotOverlay(true, false, GuiTextures.BOXED_OVERLAY)
+            // .setProgressBar(GuiTextures.PROGRESS_BAR_UNPACKER, LEFT_TO_RIGHT)
             .setSound(GTSoundEntries.ASSEMBLER);
 
     public final static GTRecipeType POLARIZER_RECIPES = register("polarizer", ELECTRIC).setMaxIOSize(1, 1, 0, 0)
             .setEUIO(IO.IN)
-            .setProgressBar(GuiTextures.PROGRESS_BAR_MAGNET, LEFT_TO_RIGHT)
+            .UI(builder -> builder.setProgressBar(GTGuiTextures.PROGRESS_BAR_MAGNET, 20))
+            // .setProgressBar(GuiTextures.PROGRESS_BAR_MAGNET, LEFT_TO_RIGHT)
             .setSound(GTSoundEntries.ARC);
 
     public final static GTRecipeType LASER_ENGRAVER_RECIPES = register("laser_engraver", ELECTRIC)
             .setMaxIOSize(2, 1, 0, 0).setEUIO(IO.IN)
-            .setSlotOverlay(false, false, true, GuiTextures.LENS_OVERLAY)
-            .setProgressBar(GuiTextures.PROGRESS_BAR_ARROW, LEFT_TO_RIGHT)
+            .UI(builder -> builder.setProgressBar(GTGuiTextures.PROGRESS_BAR_ARROW, 20)
+                    .setItemSlotOverlay(IO.IN, 1, GTGuiTextures.LENS_OVERLAY))
+            // .setSlotOverlay(false, false, true, GuiTextures.LENS_OVERLAY)
+            // .setProgressBar(GuiTextures.PROGRESS_BAR_ARROW, LEFT_TO_RIGHT)
             .setSound(GTSoundEntries.ELECTROLYZER);
 
     public final static GTRecipeType SIFTER_RECIPES = register("sifter", ELECTRIC).setMaxIOSize(1, 6, 0, 0)
             .setEUIO(IO.IN)
-            .setProgressBar(GuiTextures.PROGRESS_BAR_SIFT, UP_TO_DOWN)
+            .UI(builder -> builder.setProgressBar(GTGuiTextures.PROGRESS_BAR_SIFT, 20, ProgressWidget.Direction.DOWN))
+            // .setProgressBar(GuiTextures.PROGRESS_BAR_SIFT, UP_TO_DOWN)
             .setSound(new ExistingSoundEntry(SoundEvents.SAND_PLACE, SoundSource.BLOCKS));
 
     public final static GTRecipeType THERMAL_CENTRIFUGE_RECIPES = register("thermal_centrifuge", ELECTRIC)
             .setMaxIOSize(1, 3, 0, 0).setEUIO(IO.IN)
             .prepareBuilder(recipeBuilder -> recipeBuilder.duration(400).EUt(30))
-            .setSlotOverlay(false, false, GuiTextures.CRUSHED_ORE_OVERLAY)
-            .setSlotOverlay(true, false, GuiTextures.DUST_OVERLAY)
-            .setProgressBar(GuiTextures.PROGRESS_BAR_ARROW, LEFT_TO_RIGHT)
+            .UI(builder -> builder.setProgressBar(GTGuiTextures.PROGRESS_BAR_ARROW, 20)
+                    .setItemSlotOverlay(IO.IN, 0, GTGuiTextures.CRUSHED_ORE_OVERLAY)
+                    .setItemSlotOverlay(IO.OUT, 0, GTGuiTextures.DUST_OVERLAY))
+            // .setSlotOverlay(false, false, GuiTextures.CRUSHED_ORE_OVERLAY)
+            // .setSlotOverlay(true, false, GuiTextures.DUST_OVERLAY)
+            // .setProgressBar(GuiTextures.PROGRESS_BAR_ARROW, LEFT_TO_RIGHT)
             .setSound(GTSoundEntries.CENTRIFUGE);
 
     public final static GTRecipeType WIREMILL_RECIPES = register("wiremill", ELECTRIC).setMaxIOSize(2, 1, 0, 0)
             .setEUIO(IO.IN)
-            .setSlotOverlay(false, false, GuiTextures.WIREMILL_OVERLAY)
-            .setProgressBar(GuiTextures.PROGRESS_BAR_WIREMILL, LEFT_TO_RIGHT)
+            .UI(builder -> builder.setProgressBar(GTGuiTextures.PROGRESS_BAR_WIREMILL, 20)
+                    .setItemSlotOverlay(IO.IN, 0, GTGuiTextures.WIREMILL_OVERLAY))
+            // .setSlotOverlay(false, false, GuiTextures.WIREMILL_OVERLAY)
+            // .setProgressBar(GuiTextures.PROGRESS_BAR_WIREMILL, LEFT_TO_RIGHT)
             .setSound(GTSoundEntries.MOTOR);
 
     public final static GTRecipeType CIRCUIT_ASSEMBLER_RECIPES = register("circuit_assembler", ELECTRIC)
             .setMaxIOSize(6, 1, 1, 0).setEUIO(IO.IN)
-            .setSlotOverlay(false, false, GuiTextures.CIRCUIT_OVERLAY)
-            .setProgressBar(GuiTextures.PROGRESS_BAR_CIRCUIT_ASSEMBLER, LEFT_TO_RIGHT)
+            .UI(builder -> builder.setProgressBar(GTGuiTextures.PROGRESS_BAR_CIRCUIT_ASSEMBLER, 20)
+                    .setItemSlotOverlay(IO.IN, 0, GTGuiTextures.CIRCUIT_OVERLAY))
+            // .setSlotOverlay(false, false, GuiTextures.CIRCUIT_OVERLAY)
+            // .setProgressBar(GuiTextures.PROGRESS_BAR_CIRCUIT_ASSEMBLER, LEFT_TO_RIGHT)
             .setSound(GTSoundEntries.ASSEMBLER)
             .onRecipeBuild((recipeBuilder, provider) -> {
                 if (recipeBuilder.input.getOrDefault(FluidRecipeCapability.CAP, Collections.emptyList()).isEmpty() &&
@@ -388,31 +514,41 @@ public class GTRecipeTypes {
 
     public final static GTRecipeType GAS_COLLECTOR_RECIPES = register("gas_collector", ELECTRIC)
             .setMaxIOSize(1, 0, 0, 1).setEUIO(IO.IN)
-            .setSlotOverlay(false, false, GuiTextures.INT_CIRCUIT_OVERLAY)
-            .setSlotOverlay(true, true, GuiTextures.CENTRIFUGE_OVERLAY)
-            .setProgressBar(GuiTextures.PROGRESS_BAR_GAS_COLLECTOR, LEFT_TO_RIGHT)
+            .UI(builder -> builder.setProgressBar(GTGuiTextures.PROGRESS_BAR_GAS_COLLECTOR, 20)
+                    .setItemSlotOverlay(IO.IN, 0, GTGuiTextures.INT_CIRCUIT_OVERLAY)
+                    .setFluidSlotOverlay(IO.OUT, 0, GTGuiTextures.CENTRIFUGE_OVERLAY))
+            // .setSlotOverlay(false, false, GuiTextures.INT_CIRCUIT_OVERLAY)
+            // .setSlotOverlay(true, true, GuiTextures.CENTRIFUGE_OVERLAY)
+            // .setProgressBar(GuiTextures.PROGRESS_BAR_GAS_COLLECTOR, LEFT_TO_RIGHT)
             .setOffsetVoltageText(true)
             .setSound(GTSoundEntries.COOLING);
 
     public final static GTRecipeType AIR_SCRUBBER_RECIPES = register("air_scrubber", ELECTRIC)
             .setMaxIOSize(1, 3, 1, 3).setEUIO(IO.IN)
-            .setProgressBar(GuiTextures.PROGRESS_BAR_GAS_COLLECTOR, LEFT_TO_RIGHT)
+            .UI(builder -> builder.setProgressBar(GTGuiTextures.PROGRESS_BAR_GAS_COLLECTOR, 20))
+            // .setProgressBar(GuiTextures.PROGRESS_BAR_GAS_COLLECTOR, LEFT_TO_RIGHT)
             .setSound(GTSoundEntries.COOLING);
 
     public static final GTRecipeType RESEARCH_STATION_RECIPES = register("research_station", ELECTRIC)
             .setMaxIOSize(2, 1, 0, 0)
-            .setProgressBar(GuiTextures.PROGRESS_BAR_ARROW, LEFT_TO_RIGHT)
-            .setSlotOverlay(false, false, GuiTextures.SCANNER_OVERLAY)
-            .setSlotOverlay(true, false, GuiTextures.RESEARCH_STATION_OVERLAY)
+            .UI(builder -> builder.setProgressBar(GTGuiTextures.PROGRESS_BAR_ARROW, 20)
+                    .setItemSlotOverlay(IO.IN, 0, GTGuiTextures.SCANNER_OVERLAY)
+                    .setItemSlotOverlay(IO.OUT, 0, GTGuiTextures.RESEARCH_STATION_OVERLAY))
+            // .setProgressBar(GuiTextures.PROGRESS_BAR_ARROW, LEFT_TO_RIGHT)
+            // .setSlotOverlay(false, false, GuiTextures.SCANNER_OVERLAY)
+            // .setSlotOverlay(true, false, GuiTextures.RESEARCH_STATION_OVERLAY)
             .setScanner(true)
             .setMaxTooltips(4)
             .setSound(GTValues.FOOLS.getAsBoolean() ? GTSoundEntries.SCIENCE : GTSoundEntries.COMPUTATION);
 
     public final static GTRecipeType ROCK_BREAKER_RECIPES = register("rock_breaker", ELECTRIC).setMaxIOSize(1, 4, 0, 0)
             .setEUIO(IO.IN)
-            .setSlotOverlay(false, false, GuiTextures.DUST_OVERLAY)
-            .setSlotOverlay(true, false, GuiTextures.CRUSHED_ORE_OVERLAY)
-            .setProgressBar(GuiTextures.PROGRESS_BAR_MACERATE, LEFT_TO_RIGHT)
+            .UI(builder -> builder.setProgressBar(GTGuiTextures.PROGRESS_BAR_MACERATE, 20)
+                    .setItemSlotOverlay(IO.IN, 0, GTGuiTextures.DUST_OVERLAY)
+                    .setItemSlotOverlay(IO.OUT, 0, GTGuiTextures.CRUSHED_ORE_OVERLAY))
+            // .setSlotOverlay(false, false, GuiTextures.DUST_OVERLAY)
+            // .setSlotOverlay(true, false, GuiTextures.CRUSHED_ORE_OVERLAY)
+            // .setProgressBar(GuiTextures.PROGRESS_BAR_MACERATE, LEFT_TO_RIGHT)
             .setIconSupplier(() -> GTMachines.ROCK_CRUSHER[GTValues.LV].asStack())
             .setSteamProgressBar(GuiTextures.PROGRESS_BAR_MACERATE_STEAM, LEFT_TO_RIGHT)
             .setUiBuilder((recipe, widgetGroup) -> {
@@ -449,9 +585,12 @@ public class GTRecipeTypes {
 
     public static final GTRecipeType SCANNER_RECIPES = register("scanner", ELECTRIC)
             .setMaxIOSize(2, 1, 1, 0)
-            .setSlotOverlay(false, false, GuiTextures.DATA_ORB_OVERLAY)
-            .setSlotOverlay(false, false, true, GuiTextures.SCANNER_OVERLAY)
-            .setProgressBar(GuiTextures.PROGRESS_BAR_ARROW, LEFT_TO_RIGHT)
+            .UI(builder -> builder.setProgressBar(GTGuiTextures.PROGRESS_BAR_ARROW, 20)
+                    .setItemSlotOverlay(IO.IN, 0, GTGuiTextures.DATA_ORB_OVERLAY)
+                    .setItemSlotOverlay(IO.IN, 1, GTGuiTextures.SCANNER_OVERLAY))
+            // .setSlotOverlay(false, false, GuiTextures.DATA_ORB_OVERLAY)
+            // .setSlotOverlay(false, false, true, GuiTextures.SCANNER_OVERLAY)
+            // .setProgressBar(GuiTextures.PROGRESS_BAR_ARROW, LEFT_TO_RIGHT)
             .addCustomRecipeLogic(new ResearchManager.DataStickCopyScannerLogic())
             .setScanner(true)
             .setSound(GTSoundEntries.ELECTROLYZER);
diff --git a/src/main/java/com/gregtechceu/gtceu/common/data/GTRecipes.java b/src/main/java/com/gregtechceu/gtceu/common/data/GTRecipes.java
index b6197f6adec..fdd61f6f4c9 100644
--- a/src/main/java/com/gregtechceu/gtceu/common/data/GTRecipes.java
+++ b/src/main/java/com/gregtechceu/gtceu/common/data/GTRecipes.java
@@ -93,7 +93,8 @@ public static void recipeAddition(Consumer<FinishedRecipe> originalConsumer) {
         // GCYM
         GCYMRecipes.init(consumer);
 
-        // Config-dependent recipes
+        // non-GTRecipe things
+        EquipmentFoundryRecipes.init(consumer);
         RecipeAddition.init(consumer);
 
         AddonFinder.getAddons().forEach(addon -> addon.addRecipes(consumer));
diff --git a/src/main/java/com/gregtechceu/gtceu/common/data/machines/GTMachineUtils.java b/src/main/java/com/gregtechceu/gtceu/common/data/machines/GTMachineUtils.java
index 811b6093911..ce491a18804 100644
--- a/src/main/java/com/gregtechceu/gtceu/common/data/machines/GTMachineUtils.java
+++ b/src/main/java/com/gregtechceu/gtceu/common/data/machines/GTMachineUtils.java
@@ -22,6 +22,7 @@
 import com.gregtechceu.gtceu.api.machine.property.GTMachineModelProperties;
 import com.gregtechceu.gtceu.api.machine.steam.SimpleSteamMachine;
 import com.gregtechceu.gtceu.api.machine.trait.RecipeLogic;
+import com.gregtechceu.gtceu.api.mui.factory.PanelFactory;
 import com.gregtechceu.gtceu.api.pattern.FactoryBlockPattern;
 import com.gregtechceu.gtceu.api.pattern.MultiblockShapeInfo;
 import com.gregtechceu.gtceu.api.pattern.Predicates;
@@ -51,7 +52,10 @@
 import com.gregtechceu.gtceu.common.machine.storage.DrumMachine;
 import com.gregtechceu.gtceu.common.machine.storage.QuantumChestMachine;
 import com.gregtechceu.gtceu.common.machine.storage.QuantumTankMachine;
+import com.gregtechceu.gtceu.common.mui.GTGuiTheme;
+import com.gregtechceu.gtceu.common.mui.GTSingleblockMachinePanels;
 import com.gregtechceu.gtceu.config.ConfigHolder;
+import com.gregtechceu.gtceu.data.recipe.CustomTags;
 import com.gregtechceu.gtceu.utils.FormattingUtil;
 
 import com.lowdragmc.lowdraglib.utils.BlockInfo;
@@ -72,6 +76,8 @@
 import it.unimi.dsi.fastutil.ints.Int2IntFunction;
 import it.unimi.dsi.fastutil.objects.Object2IntArrayMap;
 import it.unimi.dsi.fastutil.objects.Object2IntMap;
+import lombok.Setter;
+import lombok.experimental.Accessors;
 import org.jetbrains.annotations.Nullable;
 
 import java.util.ArrayList;
@@ -126,36 +132,59 @@ public class GTMachineUtils {
 
     public static MachineDefinition[] registerSimpleMachines(String name, GTRecipeType recipeType,
                                                              Int2IntFunction tankScalingFunction,
-                                                             boolean hasPollutionDebuff) {
-        return registerSimpleMachines(REGISTRATE, name, recipeType, tankScalingFunction, hasPollutionDebuff);
+                                                             boolean hasPollutionDebuff, PanelFactory panelFactory) {
+        return new SimpleMachineBuilder(name, recipeType)
+                .tankScalingFunction(tankScalingFunction)
+                .hasPollutionDebuff(hasPollutionDebuff)
+                .panelFactory(panelFactory)
+                .register();
     }
 
     public static MachineDefinition[] registerSimpleMachines(GTRegistrate registrate, String name,
                                                              GTRecipeType recipeType,
                                                              Int2IntFunction tankScalingFunction,
-                                                             boolean hasPollutionDebuff) {
-        return registerSimpleMachines(registrate, name, recipeType, tankScalingFunction, hasPollutionDebuff,
-                ELECTRIC_TIERS);
+                                                             boolean hasPollutionDebuff, PanelFactory panelFactory) {
+        return new SimpleMachineBuilder(name, recipeType)
+                .registrate(registrate)
+                .tankScalingFunction(tankScalingFunction)
+                .hasPollutionDebuff(hasPollutionDebuff)
+                .panelFactory(panelFactory)
+                .register();
     }
 
     public static MachineDefinition[] registerSimpleMachines(String name, GTRecipeType recipeType,
-                                                             Int2IntFunction tankScalingFunction) {
-        return registerSimpleMachines(REGISTRATE, name, recipeType, tankScalingFunction);
+                                                             Int2IntFunction tankScalingFunction,
+                                                             PanelFactory panelFactory) {
+        return new SimpleMachineBuilder(name, recipeType)
+                .panelFactory(panelFactory)
+                .tankScalingFunction(tankScalingFunction)
+                .register();
     }
 
     public static MachineDefinition[] registerSimpleMachines(GTRegistrate registrate, String name,
                                                              GTRecipeType recipeType,
-                                                             Int2IntFunction tankScalingFunction) {
-        return registerSimpleMachines(registrate, name, recipeType, tankScalingFunction, false);
+                                                             Int2IntFunction tankScalingFunction,
+                                                             PanelFactory panelFactory) {
+        return new SimpleMachineBuilder(name, recipeType)
+                .registrate(registrate)
+                .panelFactory(panelFactory)
+                .tankScalingFunction(tankScalingFunction)
+                .register();
     }
 
-    public static MachineDefinition[] registerSimpleMachines(String name, GTRecipeType recipeType) {
-        return registerSimpleMachines(REGISTRATE, name, recipeType);
+    public static MachineDefinition[] registerSimpleMachines(String name, GTRecipeType recipeType,
+                                                             PanelFactory panelFactory) {
+        return new SimpleMachineBuilder(name, recipeType)
+                .panelFactory(panelFactory)
+                .register();
     }
 
     public static MachineDefinition[] registerSimpleMachines(GTRegistrate registrate, String name,
-                                                             GTRecipeType recipeType) {
-        return registerSimpleMachines(registrate, name, recipeType, defaultTankSizeFunction);
+                                                             GTRecipeType recipeType, PanelFactory panelFactory) {
+        return new SimpleMachineBuilder(name, recipeType)
+                .registrate(registrate)
+                .panelFactory(panelFactory)
+                .register();
     }
 
     public static MachineDefinition[] registerSimpleMachines(GTRegistrate registrate,
@@ -163,29 +192,15 @@ public static MachineDefinition[] registerSimpleMachines(GTRegistrate registrate
                                                              GTRecipeType recipeType,
                                                              Int2IntFunction tankScalingFunction,
                                                              boolean hasPollutionDebuff,
+                                                             PanelFactory panelFactory,
                                                              int... tiers) {
-        return registerTieredMachines(registrate, name,
-                (info, tier) -> new SimpleTieredMachine(info, tier, tankScalingFunction), (tier, builder) -> {
-                    if (hasPollutionDebuff) {
-                        builder.recipeModifiers(GTRecipeModifiers.ENVIRONMENT_REQUIREMENT
-                                .apply(GTMedicalConditions.CARBON_MONOXIDE_POISONING, 100 * tier),
-                                GTRecipeModifiers.OC_NON_PERFECT)
-                                .conditionalTooltip(defaultEnvironmentRequirement(),
-                                        ConfigHolder.INSTANCE.gameplay.environmentalHazards);
-                    } else {
-                        builder.recipeModifier(GTRecipeModifiers.OC_NON_PERFECT);
-                    }
-                    return builder
-                            .langValue("%s %s %s".formatted(VLVH[tier], toEnglishName(name), VLVT[tier]))
-                            .editableUI(SimpleTieredMachine.EDITABLE_UI_CREATOR.apply(GTCEu.id(name), recipeType))
-                            .rotationState(RotationState.NON_Y_AXIS)
-                            .recipeType(recipeType)
-                            .workableTieredHullModel(GTCEu.id("block/machines/" + name))
-                            .tooltips(workableTiered(tier, GTValues.V[tier], GTValues.V[tier] * 64, recipeType,
-                                    tankScalingFunction.applyAsInt(tier), true))
-                            .register();
-                },
-                tiers);
+        return new SimpleMachineBuilder(name, recipeType)
+                .registrate(registrate)
+                .tankScalingFunction(tankScalingFunction)
+                .hasPollutionDebuff(hasPollutionDebuff)
+                .panelFactory(panelFactory)
+                .tiers(tiers)
+                .register();
     }
 
     public static MachineDefinition[] registerTieredMachines(String name,
@@ -332,9 +347,9 @@ public static MachineDefinition[] registerSimpleGenerator(GTRegistrate registrat
                         tankScalingFunction),
                 (tier, builder) -> builder
                         .langValue("%s %s Generator %s".formatted(VLVH[tier], toEnglishName(name), VLVT[tier]))
-                        .editableUI(SimpleGeneratorMachine.EDITABLE_UI_CREATOR.apply(GTCEu.id(name), recipeType))
                         .rotationState(RotationState.ALL)
                         .recipeType(recipeType)
+                        .ui(GTSingleblockMachinePanels.GENERAL_MACHINE)
                         .recipeModifier(SimpleGeneratorMachine::recipeModifier, true)
                         .addOutputLimit(ItemRecipeCapability.CAP, 0)
                         .addOutputLimit(FluidRecipeCapability.CAP, 0)
@@ -358,6 +373,8 @@ public static Pair<MachineDefinition, MachineDefinition> registerSimpleSteamMach
                         .rotationState(RotationState.ALL)
                         .recipeType(recipeType)
                         .recipeModifier(SimpleSteamMachine::recipeModifier)
+                        .themeId((i) -> i > 0 ? GTGuiTheme.STEEL.getId() : GTGuiTheme.BRONZE.getId())
+                        .ui(GTSingleblockMachinePanels.STEAM_MACHINE)
                         .modelProperty(GTMachineModelProperties.VENT_DIRECTION, RelativeDirection.BACK)
                         .workableSteamHullModel(pressure, GTCEu.id("block/machines/" + name))
                         .register());
@@ -480,15 +497,17 @@ public static MachineDefinition[] registerLaserHatch(GTRegistrate registrate, IO
                 HIGH_TIERS);
     }
 
-    public static MachineDefinition registerCrate(Material material, int capacity, String lang) {
-        return registerCrate(REGISTRATE, material, capacity, lang);
+    public static MachineDefinition registerCrate(Material material, int capacity, int rowLength, String lang) {
+        return registerCrate(REGISTRATE, material, capacity, rowLength, lang);
     }
 
     public static MachineDefinition registerCrate(GTRegistrate registrate, Material material, int capacity,
-                                                  String lang) {
+                                                  int rowLength, String lang) {
         final boolean wooden = material.hasProperty(PropertyKey.WOOD);
 
-        return registrate.machine(material.getName() + "_crate", holder -> new CrateMachine(holder, material, capacity))
+        return registrate
+                .machine(material.getName() + "_crate",
+                        info -> new CrateMachine(info, material, capacity, rowLength))
                 .langValue(lang)
                 .rotationState(RotationState.NONE)
                 .tooltips(Component.translatable("gtceu.universal.tooltip.item_storage_capacity", capacity))
@@ -511,6 +530,7 @@ public static MachineDefinition registerDrum(GTRegistrate registrate, Material m
                         MetaMachineBlock::new,
                         (holder, prop) -> DrumMachineItem.create(holder, prop, material),
                         info -> new DrumMachine(info, material, capacity))
+                .itemBuilder(builder -> builder.tag(CustomTags.FLUID_CONTAINERS))
                 .langValue(lang)
                 .rotationState(RotationState.NONE)
                 .simpleModel(GTCEu.id("block/machine/template/drum/" + (wooden ? "wooden" : "metal") + "_drum"))
@@ -544,6 +564,7 @@ public static MachineDefinition[] registerQuantumTanks(GTRegistrate registrate,
                     MachineDefinition::new,
                     MetaMachineBlock::new, QuantumTankMachineItem::new,
                     (holder) -> new QuantumTankMachine(holder, tier, maxAmount))
+                    .itemBuilder(builder -> builder.tag(CustomTags.FLUID_CONTAINERS))
                     .langValue(toEnglishName(name) + " " + LVT[tier])
                     .blockProp(BlockBehaviour.Properties::dynamicShape)
                     .rotationState(RotationState.ALL)
@@ -943,5 +964,58 @@ public static Component[] workableTiered(int tier, long voltage, long energyCapa
         return tooltipComponents.toArray(Component[]::new);
     }
 
+    @Accessors(chain = true, fluent = true)
+    public static class SimpleMachineBuilder {
+
+        @Setter
+        private GTRegistrate registrate = REGISTRATE;
+        @Setter
+        private String name;
+        @Setter
+        private GTRecipeType recipeType;
+        @Setter
+        private Int2IntFunction tankScalingFunction = defaultTankSizeFunction;
+        @Setter
+        private boolean hasPollutionDebuff = false;
+        @Setter
+        private PanelFactory panelFactory = null;
+        @Setter
+        private int[] tiers = ELECTRIC_TIERS;
+
+        public SimpleMachineBuilder(String name, GTRecipeType recipeType) {
+            // Simple Machines need to have a name and a recipe type.
+            this.name = name;
+            this.recipeType = recipeType;
+        }
+
+        public MachineDefinition[] register() {
+            if (panelFactory == null) {
+                panelFactory = GTSingleblockMachinePanels.GENERAL_MACHINE;
+            }
+            return registerTieredMachines(registrate, name,
+                    (holder, tier) -> new SimpleTieredMachine(holder, tier, tankScalingFunction), (tier, builder) -> {
+                        if (hasPollutionDebuff) {
+                            builder.recipeModifiers(GTRecipeModifiers.ENVIRONMENT_REQUIREMENT
+                                    .apply(GTMedicalConditions.CARBON_MONOXIDE_POISONING, 100 * tier),
+                                    GTRecipeModifiers.OC_NON_PERFECT)
+                                    .conditionalTooltip(defaultEnvironmentRequirement(),
+                                            ConfigHolder.INSTANCE.gameplay.environmentalHazards);
+                        } else {
+                            builder.recipeModifier(GTRecipeModifiers.OC_NON_PERFECT);
+                        }
+                        return builder
+                                .langValue("%s %s %s".formatted(VLVH[tier], toEnglishName(name), VLVT[tier]))
+                                .rotationState(RotationState.NON_Y_AXIS)
+                                .recipeType(recipeType)
+                                .workableTieredHullModel(GTCEu.id("block/machines/" + name))
+                                .tooltips(workableTiered(tier, GTValues.V[tier], GTValues.V[tier] * 64, recipeType,
+                                        tankScalingFunction.applyAsInt(tier), true))
+                                .ui(panelFactory)
+                                .register();
+                    },
+                    tiers);
+        }
+    }
+
     public static void init() {}
 }
diff --git a/src/main/java/com/gregtechceu/gtceu/common/data/machines/GTMultiMachines.java b/src/main/java/com/gregtechceu/gtceu/common/data/machines/GTMultiMachines.java
index dfbcf64b53d..0f783694b61 100644
--- a/src/main/java/com/gregtechceu/gtceu/common/data/machines/GTMultiMachines.java
+++ b/src/main/java/com/gregtechceu/gtceu/common/data/machines/GTMultiMachines.java
@@ -29,6 +29,8 @@
 import com.gregtechceu.gtceu.common.machine.multiblock.primitive.PrimitiveBlastFurnaceMachine;
 import com.gregtechceu.gtceu.common.machine.multiblock.primitive.PrimitivePumpMachine;
 import com.gregtechceu.gtceu.common.machine.multiblock.steam.SteamParallelMultiblockMachine;
+import com.gregtechceu.gtceu.common.mui.GTGuiTheme;
+import com.gregtechceu.gtceu.common.mui.factory.CentralMonitorUIFactory;
 import com.gregtechceu.gtceu.config.ConfigHolder;
 import com.gregtechceu.gtceu.utils.FormattingUtil;
 import com.gregtechceu.gtceu.utils.GTUtil;
@@ -108,6 +110,7 @@ public class GTMultiMachines {
                     .build())
             .workableCasingModel(GTCEu.id("block/casings/solid/machine_coke_bricks"),
                     GTCEu.id("block/multiblock/coke_oven"))
+            .themeId((i) -> GTGuiTheme.PRIMITIVE.getId())
             .register();
 
     public static final MultiblockMachineDefinition PRIMITIVE_BLAST_FURNACE = REGISTRATE
@@ -129,6 +132,7 @@ public class GTMultiMachines {
                             .or(Predicates.custom(bws -> GTUtil.isBlockSnow(bws.getBlockState()), null)))
                     .where('Y', Predicates.controller(blocks(definition.getBlock())))
                     .build())
+            .themeId((i) -> GTGuiTheme.PRIMITIVE.getId())
             .register();
 
     public static final MultiblockMachineDefinition ELECTRIC_BLAST_FURNACE = REGISTRATE
@@ -600,6 +604,8 @@ public class GTMultiMachines {
             .multiblock("steam_grinder", SteamParallelMultiblockMachine::new)
             .rotationState(RotationState.ALL)
             .appearanceBlock(CASING_BRONZE_BRICKS)
+            .themeId(ConfigHolder.INSTANCE.machines.steelSteamMultiblocks ? GTGuiTheme.STEEL.getId() :
+                    GTGuiTheme.BRONZE.getId())
             .recipeType(GTRecipeTypes.MACERATOR_RECIPES)
             .recipeModifier(SteamParallelMultiblockMachine::recipeModifier, true)
             .addOutputLimit(ItemRecipeCapability.CAP, 1)
@@ -622,6 +628,8 @@ public class GTMultiMachines {
             .multiblock("steam_oven", SteamParallelMultiblockMachine::new)
             .rotationState(RotationState.ALL)
             .appearanceBlock(CASING_BRONZE_BRICKS)
+            .themeId(ConfigHolder.INSTANCE.machines.steelSteamMultiblocks ? GTGuiTheme.STEEL.getId() :
+                    GTGuiTheme.BRONZE.getId())
             .recipeType(GTRecipeTypes.FURNACE_RECIPES)
             .recipeModifier(SteamParallelMultiblockMachine::recipeModifier, true)
             .addOutputLimit(ItemRecipeCapability.CAP, 1)
@@ -1158,6 +1166,7 @@ public class GTMultiMachines {
                     GTCEu.id("block/multiblock/central_monitor"))
                     .andThen(b -> b.addDynamicRenderer(DynamicRenderHelper::createCentralMonitorRender)))
             .hasBER(true)
+            .ui(CentralMonitorUIFactory.INSTANCE)
             .register();
 
     public static void init() {}
diff --git a/src/main/java/com/gregtechceu/gtceu/common/item/ChargingLinkingBehaviour.java b/src/main/java/com/gregtechceu/gtceu/common/item/ChargingLinkingBehaviour.java
new file mode 100644
index 00000000000..d76d39ec711
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/common/item/ChargingLinkingBehaviour.java
@@ -0,0 +1,37 @@
+package com.gregtechceu.gtceu.common.item;
+
+import com.gregtechceu.gtceu.api.item.component.IInteractionItem;
+import com.gregtechceu.gtceu.api.machine.MetaMachine;
+import com.gregtechceu.gtceu.common.machine.electric.ChargerMachine;
+import com.gregtechceu.gtceu.common.machine.multiblock.electric.PowerSubstationMachine;
+import com.gregtechceu.gtceu.common.machine.owner.PlayerOwner;
+
+import net.minecraft.core.BlockPos;
+import net.minecraft.nbt.CompoundTag;
+import net.minecraft.network.chat.Component;
+import net.minecraft.world.InteractionResult;
+import net.minecraft.world.entity.player.Player;
+import net.minecraft.world.item.ItemStack;
+import net.minecraft.world.item.context.UseOnContext;
+
+public class ChargingLinkingBehaviour implements IInteractionItem {
+
+    @Override
+    public InteractionResult onItemUseFirst(ItemStack itemStack, UseOnContext context) {
+        BlockPos pos = context.getClickedPos();
+        MetaMachine machine = MetaMachine.getMachine(context.getLevel(), pos);
+        if (machine instanceof PowerSubstationMachine || machine instanceof ChargerMachine) {
+            PlayerOwner owner = machine.getPlayerOwner();
+            Player player = context.getPlayer();
+            if (owner == null || player != null && owner.isPlayerFriendly(player.getUUID())) {
+                CompoundTag tag = itemStack.getOrCreateTagElement("LinkedCharger");
+                tag.putInt("x", pos.getX());
+                tag.putInt("y", pos.getY());
+                tag.putInt("z", pos.getZ());
+                tag.putString("dim", context.getLevel().dimension().location().toString());
+                if (player != null) player.sendSystemMessage(Component.translatable("behaviour.charger_linked"));
+            }
+        }
+        return IInteractionItem.super.onItemUseFirst(itemStack, context);
+    }
+}
diff --git a/src/main/java/com/gregtechceu/gtceu/common/item/TieredBehaviour.java b/src/main/java/com/gregtechceu/gtceu/common/item/TieredBehaviour.java
new file mode 100644
index 00000000000..8e92a6c04fc
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/common/item/TieredBehaviour.java
@@ -0,0 +1,5 @@
+package com.gregtechceu.gtceu.common.item;
+
+import com.gregtechceu.gtceu.api.item.component.IItemComponent;
+
+public record TieredBehaviour(int tier) implements IItemComponent {}
diff --git a/src/main/java/com/gregtechceu/gtceu/common/item/armor/AdvancedNanoMuscleSuite.java b/src/main/java/com/gregtechceu/gtceu/common/item/armor/AdvancedNanoMuscleSuite.java
index 848422bc5fa..bae254095c5 100644
--- a/src/main/java/com/gregtechceu/gtceu/common/item/armor/AdvancedNanoMuscleSuite.java
+++ b/src/main/java/com/gregtechceu/gtceu/common/item/armor/AdvancedNanoMuscleSuite.java
@@ -228,7 +228,7 @@ public void drawHUD(ItemStack item, GuiGraphics guiGraphics) {
 
     @Override
     public ResourceLocation getArmorTexture(ItemStack stack, Entity entity, EquipmentSlot slot, String type) {
-        return GTCEu.id("textures/armor/advanced_nano_muscle_suite_1.png");
+        return GTCEu.id("textures/models/armor/advanced_nano_muscle_suite_layer_1.png");
     }
 
     @Override
@@ -307,7 +307,7 @@ public float getFallDamageReduction() {
     }
 
     @Override
-    public boolean isPPE() {
+    public boolean isPPE(ItemStack stack) {
         return true;
     }
 }
diff --git a/src/main/java/com/gregtechceu/gtceu/common/item/armor/AdvancedQuarkTechSuite.java b/src/main/java/com/gregtechceu/gtceu/common/item/armor/AdvancedQuarkTechSuite.java
index f38ffa9ffd6..e2343fc802b 100644
--- a/src/main/java/com/gregtechceu/gtceu/common/item/armor/AdvancedQuarkTechSuite.java
+++ b/src/main/java/com/gregtechceu/gtceu/common/item/armor/AdvancedQuarkTechSuite.java
@@ -255,7 +255,7 @@ public void drawHUD(ItemStack item, GuiGraphics guiGraphics) {
 
     @Override
     public ResourceLocation getArmorTexture(ItemStack stack, Entity entity, EquipmentSlot slot, String type) {
-        return GTCEu.id("textures/armor/advanced_quark_tech_suite_1.png");
+        return GTCEu.id("textures/models/armor/advanced_quark_tech_suite_layer_1.png");
     }
 
     @Override
diff --git a/src/main/java/com/gregtechceu/gtceu/common/item/armor/GTArmorMaterials.java b/src/main/java/com/gregtechceu/gtceu/common/item/armor/GTArmorMaterials.java
index f8717cd8d24..90cbba1e079 100644
--- a/src/main/java/com/gregtechceu/gtceu/common/item/armor/GTArmorMaterials.java
+++ b/src/main/java/com/gregtechceu/gtceu/common/item/armor/GTArmorMaterials.java
@@ -30,7 +30,25 @@ public enum GTArmorMaterials implements ArmorMaterial, StringRepresentable {
         map.put(ArmorItem.Type.CHESTPLATE, 0);
         map.put(ArmorItem.Type.HELMET, 0);
     }), 50, SoundEvents.ARMOR_EQUIP_GENERIC, 0.0F, 0.0F, () -> Ingredient.EMPTY),
-    ARMOR("armor", 0, Util.make(new EnumMap<>(ArmorItem.Type.class), map -> {
+    NANO_MUSCLE("gtceu:nano_muscle_suite", 0, Util.make(new EnumMap<>(ArmorItem.Type.class), map -> {
+        map.put(ArmorItem.Type.BOOTS, 3);
+        map.put(ArmorItem.Type.LEGGINGS, 4);
+        map.put(ArmorItem.Type.CHESTPLATE, 4);
+        map.put(ArmorItem.Type.HELMET, 2);
+    }), 50, SoundEvents.ARMOR_EQUIP_GENERIC, 1.0F, 0.0F, () -> Ingredient.EMPTY),
+    ADVANCED_NANO_MUSCLE("gtceu:advanced_nano_muscle_suite", 0, Util.make(new EnumMap<>(ArmorItem.Type.class), map -> {
+        map.put(ArmorItem.Type.BOOTS, 0);
+        map.put(ArmorItem.Type.LEGGINGS, 0);
+        map.put(ArmorItem.Type.CHESTPLATE, 0);
+        map.put(ArmorItem.Type.HELMET, 0);
+    }), 50, SoundEvents.ARMOR_EQUIP_GENERIC, 5.0F, 0.0F, () -> Ingredient.EMPTY),
+    QUARK_TECH("gtceu:quark_tech_suite", 0, Util.make(new EnumMap<>(ArmorItem.Type.class), map -> {
+        map.put(ArmorItem.Type.BOOTS, 0);
+        map.put(ArmorItem.Type.LEGGINGS, 0);
+        map.put(ArmorItem.Type.CHESTPLATE, 0);
+        map.put(ArmorItem.Type.HELMET, 0);
+    }), 50, SoundEvents.ARMOR_EQUIP_GENERIC, 5.0F, 0.0F, () -> Ingredient.EMPTY),
+    ADVANCED_QUARK_TECH("gtceu:advanced_quark_tech_suite", 0, Util.make(new EnumMap<>(ArmorItem.Type.class), map -> {
         map.put(ArmorItem.Type.BOOTS, 0);
         map.put(ArmorItem.Type.LEGGINGS, 0);
         map.put(ArmorItem.Type.CHESTPLATE, 0);
diff --git a/src/main/java/com/gregtechceu/gtceu/common/item/armor/HazmatSuit.java b/src/main/java/com/gregtechceu/gtceu/common/item/armor/HazmatSuit.java
index e6c015ff69e..bd4701eed16 100644
--- a/src/main/java/com/gregtechceu/gtceu/common/item/armor/HazmatSuit.java
+++ b/src/main/java/com/gregtechceu/gtceu/common/item/armor/HazmatSuit.java
@@ -41,7 +41,7 @@ public int getArmorDisplay(Player player, @NotNull ItemStack armor, EquipmentSlo
     }
 
     @Override
-    public boolean isPPE() {
+    public boolean isPPE(ItemStack stack) {
         return true;
     }
 }
diff --git a/src/main/java/com/gregtechceu/gtceu/common/item/armor/Jetpack.java b/src/main/java/com/gregtechceu/gtceu/common/item/armor/Jetpack.java
index 063cfb89bd6..7e62e3d0af4 100644
--- a/src/main/java/com/gregtechceu/gtceu/common/item/armor/Jetpack.java
+++ b/src/main/java/com/gregtechceu/gtceu/common/item/armor/Jetpack.java
@@ -96,7 +96,7 @@ public void drainEnergy(@NotNull ItemStack stack, int amount) {
         IElectricItem container = getIElectricItem(stack);
         if (container == null)
             return;
-        container.discharge(amount, tier, true, false, false);
+        container.discharge(amount, container.getTier(), true, false, false);
     }
 
     @Override
diff --git a/src/main/java/com/gregtechceu/gtceu/common/item/armor/NanoMuscleSuite.java b/src/main/java/com/gregtechceu/gtceu/common/item/armor/NanoMuscleSuite.java
index 546c6a24ccb..93d674b9ad4 100644
--- a/src/main/java/com/gregtechceu/gtceu/common/item/armor/NanoMuscleSuite.java
+++ b/src/main/java/com/gregtechceu/gtceu/common/item/armor/NanoMuscleSuite.java
@@ -149,11 +149,11 @@ public ResourceLocation getArmorTexture(ItemStack stack, Entity entity, Equipmen
         ItemStack currentChest = Minecraft.getInstance().player.getInventory()
                 .getArmor(ArmorItem.Type.CHESTPLATE.getSlot().getIndex());
         ItemStack advancedChest = GTItems.NANO_CHESTPLATE_ADVANCED.asStack();
-        String armorTexture = "nano_muscule_suite";
+        String armorTexture = "nano_muscle_suite";
         if (advancedChest.is(currentChest.getItem())) armorTexture = "advanced_nano_muscle_suite";
         return slot != EquipmentSlot.LEGS ?
-                GTCEu.id(String.format("textures/armor/%s_1.png", armorTexture)) :
-                GTCEu.id(String.format("textures/armor/%s_2.png", armorTexture));
+                GTCEu.id(String.format("textures/models/armor/%s_1.png", armorTexture)) :
+                GTCEu.id(String.format("textures/models/armor/%s_2.png", armorTexture));
     }
 
     @Override
diff --git a/src/main/java/com/gregtechceu/gtceu/common/item/armor/QuarkTechSuite.java b/src/main/java/com/gregtechceu/gtceu/common/item/armor/QuarkTechSuite.java
index 4c245423a1c..7f27843227c 100644
--- a/src/main/java/com/gregtechceu/gtceu/common/item/armor/QuarkTechSuite.java
+++ b/src/main/java/com/gregtechceu/gtceu/common/item/armor/QuarkTechSuite.java
@@ -88,7 +88,7 @@ public void onArmorTick(Level world, Player player, ItemStack itemStack) {
         if (type == ArmorItem.Type.HELMET) {
 
             if (!world.isClientSide) {
-                ret = supplyAir(item, player) || supplyFood(item, player);
+                ret = supplyAir(item, player, energyPerUse) || supplyFood(item, player, energyPerUse);
                 removeNegativeEffects(item, player);
             }
 
@@ -219,7 +219,7 @@ public void onArmorTick(Level world, Player player, ItemStack itemStack) {
         }
     }
 
-    public boolean supplyAir(@NotNull IElectricItem item, Player player) {
+    public static boolean supplyAir(@NotNull IElectricItem item, Player player, long energyPerUse) {
         int air = player.getAirSupply();
         if (item.canUse(energyPerUse / 100) && air < 100) {
             player.setAirSupply(air + 200);
@@ -229,7 +229,7 @@ public boolean supplyAir(@NotNull IElectricItem item, Player player) {
         return false;
     }
 
-    public boolean supplyFood(@NotNull IElectricItem item, Player player) {
+    public static boolean supplyFood(@NotNull IElectricItem item, Player player, long energyPerUse) {
         if (item.canUse(energyPerUse / 10) && player.getFoodData().needsFood()) {
             int slotId = -1;
             IItemHandler playerInv = player.getCapability(ForgeCapabilities.ITEM_HANDLER).resolve().orElse(null);
@@ -323,8 +323,8 @@ public ResourceLocation getArmorTexture(ItemStack stack, Entity entity, Equipmen
         String armorTexture = "quark_tech_suite";
         if (currentChest.is(GTItems.QUANTUM_CHESTPLATE_ADVANCED.get())) armorTexture = "advanced_quark_tech_suite";
         return slot != EquipmentSlot.LEGS ?
-                GTCEu.id(String.format("textures/armor/%s_1.png", armorTexture)) :
-                GTCEu.id(String.format("textures/armor/%s_2.png", armorTexture));
+                GTCEu.id(String.format("textures/models/armor/%s_1.png", armorTexture)) :
+                GTCEu.id(String.format("textures/models/armor/%s_2.png", armorTexture));
     }
 
     @Override
@@ -375,7 +375,7 @@ public void addInfo(ItemStack itemStack, List<Component> lines) {
     }
 
     @Override
-    public boolean isPPE() {
+    public boolean isPPE(ItemStack stack) {
         return true;
     }
 }
diff --git a/src/main/java/com/gregtechceu/gtceu/common/item/behavior/FluidFilterBehaviour.java b/src/main/java/com/gregtechceu/gtceu/common/item/behavior/FluidFilterBehaviour.java
index a842b379b8c..29da151b0f1 100644
--- a/src/main/java/com/gregtechceu/gtceu/common/item/behavior/FluidFilterBehaviour.java
+++ b/src/main/java/com/gregtechceu/gtceu/common/item/behavior/FluidFilterBehaviour.java
@@ -1,35 +1,43 @@
 package com.gregtechceu.gtceu.common.item.behavior;
 
 import com.gregtechceu.gtceu.api.cover.filter.FluidFilter;
-import com.gregtechceu.gtceu.api.gui.GuiTextures;
-import com.gregtechceu.gtceu.api.gui.UITemplate;
-import com.gregtechceu.gtceu.api.item.component.IItemUIFactory;
-
-import com.lowdragmc.lowdraglib.gui.factory.HeldItemUIFactory;
-import com.lowdragmc.lowdraglib.gui.modular.ModularUI;
-import com.lowdragmc.lowdraglib.gui.widget.LabelWidget;
+import com.gregtechceu.gtceu.api.mui.IItemUIHolder;
 
+import net.minecraft.world.InteractionHand;
+import net.minecraft.world.InteractionResultHolder;
 import net.minecraft.world.entity.player.Player;
 import net.minecraft.world.item.Item;
 import net.minecraft.world.item.ItemStack;
+import net.minecraft.world.level.Level;
+
+import brachy.modularui.factory.PlayerInventoryGuiData;
+import brachy.modularui.factory.UIFactories;
+import brachy.modularui.screen.ModularPanel;
+import brachy.modularui.screen.UISettings;
+import brachy.modularui.value.sync.PanelSyncManager;
 
 import java.util.function.Function;
 
-public record FluidFilterBehaviour(Function<ItemStack, FluidFilter> filterCreator) implements IItemUIFactory {
+public record FluidFilterBehaviour(Function<ItemStack, FluidFilter> filterCreator) implements IItemUIHolder {
 
     @Override
     public void onAttached(Item item) {
-        IItemUIFactory.super.onAttached(item);
         FluidFilter.FILTERS.put(item, filterCreator);
     }
 
     @Override
-    public ModularUI createUI(HeldItemUIFactory.HeldItemHolder holder, Player entityPlayer) {
-        var held = holder.getHeld();
-        return new ModularUI(176, 157, holder, entityPlayer)
-                .background(GuiTextures.BACKGROUND)
-                .widget(new LabelWidget(5, 5, held.getDescriptionId()))
-                .widget(FluidFilter.loadFilter(held).openConfigurator((176 - 80) / 2, (60 - 55) / 2 + 15))
-                .widget(UITemplate.bindPlayerInventory(entityPlayer.getInventory(), GuiTextures.SLOT, 7, 75, true));
+    public InteractionResultHolder<ItemStack> use(Item item, Level level, Player player, InteractionHand usedHand) {
+        if (!level.isClientSide) {
+            if (player.isCrouching()) {
+                UIFactories.playerInventory().openFromHand(player, usedHand);
+                return InteractionResultHolder.success(player.getItemInHand(usedHand));
+            }
+        }
+        return InteractionResultHolder.fail(player.getItemInHand(usedHand));
+    }
+
+    @Override
+    public ModularPanel<?> buildUI(PlayerInventoryGuiData<?> data, PanelSyncManager syncManager, UISettings settings) {
+        return FluidFilter.loadFilter(data.getUsedItemStack()).getPanel(data, syncManager, settings);
     }
 }
diff --git a/src/main/java/com/gregtechceu/gtceu/common/item/behavior/IntCircuitBehaviour.java b/src/main/java/com/gregtechceu/gtceu/common/item/behavior/IntCircuitBehaviour.java
index 6fc53c26f41..6597e21223e 100644
--- a/src/main/java/com/gregtechceu/gtceu/common/item/behavior/IntCircuitBehaviour.java
+++ b/src/main/java/com/gregtechceu/gtceu/common/item/behavior/IntCircuitBehaviour.java
@@ -1,39 +1,31 @@
 package com.gregtechceu.gtceu.common.item.behavior;
 
-import com.gregtechceu.gtceu.api.gui.GuiTextures;
-import com.gregtechceu.gtceu.api.gui.widget.SlotWidget;
 import com.gregtechceu.gtceu.api.item.component.IAddInformation;
-import com.gregtechceu.gtceu.api.item.component.IItemUIFactory;
 import com.gregtechceu.gtceu.api.machine.MetaMachine;
 import com.gregtechceu.gtceu.api.machine.feature.IHasCircuitSlot;
-import com.gregtechceu.gtceu.api.machine.trait.NotifiableItemStackHandler;
-import com.gregtechceu.gtceu.api.transfer.item.CustomItemStackHandler;
+import com.gregtechceu.gtceu.api.mui.IItemUIHolder;
 import com.gregtechceu.gtceu.common.data.GTItems;
+import com.gregtechceu.gtceu.common.mui.GTMuiWidgets;
 import com.gregtechceu.gtceu.config.ConfigHolder;
 
-import com.lowdragmc.lowdraglib.gui.factory.HeldItemUIFactory;
-import com.lowdragmc.lowdraglib.gui.modular.ModularUI;
-import com.lowdragmc.lowdraglib.gui.texture.GuiTextureGroup;
-import com.lowdragmc.lowdraglib.gui.texture.ItemStackTexture;
-import com.lowdragmc.lowdraglib.gui.widget.ButtonWidget;
-import com.lowdragmc.lowdraglib.gui.widget.LabelWidget;
-
 import net.minecraft.nbt.CompoundTag;
 import net.minecraft.network.chat.Component;
-import net.minecraft.util.Mth;
 import net.minecraft.world.InteractionResult;
-import net.minecraft.world.entity.player.Player;
 import net.minecraft.world.item.ItemStack;
 import net.minecraft.world.item.TooltipFlag;
 import net.minecraft.world.item.context.UseOnContext;
 import net.minecraft.world.level.Level;
 import net.minecraft.world.level.block.entity.BlockEntity;
 
+import brachy.modularui.factory.PlayerInventoryGuiData;
+import brachy.modularui.screen.ModularPanel;
+import brachy.modularui.screen.UISettings;
+import brachy.modularui.value.sync.PanelSyncManager;
 import org.jetbrains.annotations.Nullable;
 
 import java.util.List;
 
-public class IntCircuitBehaviour implements IItemUIFactory, IAddInformation {
+public class IntCircuitBehaviour implements IAddInformation, IItemUIHolder {
 
     public static final int CIRCUIT_MAX = 32;
 
@@ -43,11 +35,6 @@ public static ItemStack stack(int configuration) {
         return stack;
     }
 
-    public static void setCircuitConfiguration(HeldItemUIFactory.HeldItemHolder holder, int configuration) {
-        setCircuitConfiguration(holder.getHeld(), configuration);
-        holder.markAsDirty();
-    }
-
     public static void setCircuitConfiguration(ItemStack itemStack, int configuration) {
         if (configuration < 0 || configuration > CIRCUIT_MAX)
             throw new IllegalArgumentException("Given configuration number is out of range!");
@@ -74,23 +61,6 @@ public static boolean isIntegratedCircuit(ItemStack itemStack) {
         return isCircuit;
     }
 
-    // deprecated, not needed (for now)
-    @Deprecated
-    public static void adjustConfiguration(HeldItemUIFactory.HeldItemHolder holder, int amount) {
-        adjustConfiguration(holder.getHeld(), amount);
-        holder.markAsDirty();
-    }
-
-    // deprecated, not needed (for now)
-    @Deprecated
-    public static void adjustConfiguration(ItemStack stack, int amount) {
-        if (!isIntegratedCircuit(stack)) return;
-        int configuration = getCircuitConfiguration(stack);
-        configuration += amount;
-        configuration = Mth.clamp(configuration, 0, CIRCUIT_MAX);
-        setCircuitConfiguration(stack, configuration);
-    }
-
     @Override
     public void appendHoverText(ItemStack stack, @Nullable Level level, List<Component> tooltipComponents,
                                 TooltipFlag isAdvanced) {
@@ -99,41 +69,8 @@ public void appendHoverText(ItemStack stack, @Nullable Level level, List<Compone
     }
 
     @Override
-    public ModularUI createUI(HeldItemUIFactory.HeldItemHolder holder, Player entityPlayer) {
-        LabelWidget label = new LabelWidget(9, 8, "Programmed Circuit Configuration");
-        label.setDropShadow(false);
-        label.setTextColor(0x404040);
-        var modular = new ModularUI(184, 132, holder, entityPlayer)
-                .widget(label);
-        SlotWidget slotwidget = new SlotWidget(
-                new CustomItemStackHandler(stack(getCircuitConfiguration(holder.getHeld()))),
-                0, 82, 20, false, false);
-        slotwidget.setBackground(GuiTextures.SLOT);
-        modular.widget(slotwidget);
-        int idx = 0;
-        for (int x = 0; x <= 2; x++) {
-            for (int y = 0; y <= 8; y++) {
-                int finalIdx = idx;
-                modular.widget(new ButtonWidget(10 + (18 * y), 48 + (18 * x), 18, 18,
-                        new GuiTextureGroup(GuiTextures.SLOT, new ItemStackTexture(stack(finalIdx)).scale(16f / 18)),
-                        data -> {
-                            setCircuitConfiguration(holder, finalIdx);
-                            slotwidget.setHandlerSlot(new CustomItemStackHandler(stack(finalIdx)), 0);
-                        }));
-                idx++;
-            }
-        }
-        for (int x = 0; x <= 5; x++) {
-            int finalIdx = x + 27;
-            modular.widget(new ButtonWidget(10 + (18 * x), 102, 18, 18,
-                    new GuiTextureGroup(GuiTextures.SLOT, new ItemStackTexture(stack(finalIdx)).scale(16f / 18)),
-                    data -> {
-                        setCircuitConfiguration(holder, finalIdx);
-                        slotwidget.setHandlerSlot(new CustomItemStackHandler(stack(finalIdx)), 0);
-                    }));
-        }
-        modular.mainGroup.setBackground(GuiTextures.BACKGROUND);
-        return modular;
+    public ModularPanel<?> buildUI(PlayerInventoryGuiData<?> data, PanelSyncManager syncManager, UISettings settings) {
+        return GTMuiWidgets.createCircuitSlotPanel(data::setUsedItemStack, data::getUsedItemStack, syncManager);
     }
 
     @Override
@@ -144,16 +81,12 @@ public InteractionResult useOn(UseOnContext context) {
         if (entity instanceof MetaMachine machine && context.isSecondaryUseActive()) {
             if (machine instanceof IHasCircuitSlot circuitMachine &&
                     circuitMachine.getCircuitInventory().getSlots() > 0) {
-                setCircuitConfig(circuitMachine.getCircuitInventory(), circuitSetting);
+                setCircuitConfiguration(circuitMachine.getCircuitInventory().getStackInSlot(0), circuitSetting);
             }
             if (!ConfigHolder.INSTANCE.machines.ghostCircuit)
                 stack.shrink(1);
             return InteractionResult.SUCCESS;
         }
-        return IItemUIFactory.super.useOn(context);
-    }
-
-    void setCircuitConfig(NotifiableItemStackHandler circuit, int value) {
-        circuit.setStackInSlot(0, IntCircuitBehaviour.stack(value));
+        return IItemUIHolder.super.useOn(context);
     }
 }
diff --git a/src/main/java/com/gregtechceu/gtceu/common/item/behavior/ItemFilterBehaviour.java b/src/main/java/com/gregtechceu/gtceu/common/item/behavior/ItemFilterBehaviour.java
index 9e1c1badd2f..54bf60c67dc 100644
--- a/src/main/java/com/gregtechceu/gtceu/common/item/behavior/ItemFilterBehaviour.java
+++ b/src/main/java/com/gregtechceu/gtceu/common/item/behavior/ItemFilterBehaviour.java
@@ -1,35 +1,55 @@
 package com.gregtechceu.gtceu.common.item.behavior;
 
 import com.gregtechceu.gtceu.api.cover.filter.ItemFilter;
-import com.gregtechceu.gtceu.api.gui.GuiTextures;
-import com.gregtechceu.gtceu.api.gui.UITemplate;
-import com.gregtechceu.gtceu.api.item.component.IItemUIFactory;
-
-import com.lowdragmc.lowdraglib.gui.factory.HeldItemUIFactory;
-import com.lowdragmc.lowdraglib.gui.modular.ModularUI;
-import com.lowdragmc.lowdraglib.gui.widget.LabelWidget;
+import com.gregtechceu.gtceu.api.item.component.IInteractionItem;
+import com.gregtechceu.gtceu.api.mui.IItemUIHolder;
 
+import net.minecraft.world.InteractionHand;
+import net.minecraft.world.InteractionResultHolder;
 import net.minecraft.world.entity.player.Player;
 import net.minecraft.world.item.Item;
 import net.minecraft.world.item.ItemStack;
+import net.minecraft.world.level.Level;
+
+import brachy.modularui.factory.PlayerInventoryGuiData;
+import brachy.modularui.factory.UIFactories;
+import brachy.modularui.screen.ModularPanel;
+import brachy.modularui.screen.UISettings;
+import brachy.modularui.value.sync.PanelSyncManager;
 
 import java.util.function.Function;
 
-public record ItemFilterBehaviour(Function<ItemStack, ItemFilter> filterCreator) implements IItemUIFactory {
+public record ItemFilterBehaviour(Function<ItemStack, ItemFilter> filterCreator)
+        implements IInteractionItem, IItemUIHolder {
 
     @Override
     public void onAttached(Item item) {
-        IItemUIFactory.super.onAttached(item);
         ItemFilter.FILTERS.put(item, filterCreator);
     }
 
     @Override
-    public ModularUI createUI(HeldItemUIFactory.HeldItemHolder holder, Player entityPlayer) {
-        var held = holder.getHeld();
-        return new ModularUI(176, 157, holder, entityPlayer)
-                .background(GuiTextures.BACKGROUND)
-                .widget(new LabelWidget(5, 5, held.getDescriptionId()))
-                .widget(ItemFilter.loadFilter(held).openConfigurator((176 - 80) / 2, (60 - 55) / 2 + 15))
-                .widget(UITemplate.bindPlayerInventory(entityPlayer.getInventory(), GuiTextures.SLOT, 7, 75, true));
+    public InteractionResultHolder<ItemStack> use(Item item, Level level, Player player, InteractionHand usedHand) {
+        if (!level.isClientSide) {
+            if (player.isCrouching()) {
+                UIFactories.playerInventory().openFromHand(player, usedHand);
+                return InteractionResultHolder.success(player.getItemInHand(usedHand));
+            }
+        }
+        return InteractionResultHolder.fail(player.getItemInHand(usedHand));
+    }
+
+    @Override
+    public ModularPanel<?> buildUI(PlayerInventoryGuiData<?> data, PanelSyncManager syncManager, UISettings settings) {
+        return ItemFilter.loadFilter(data.getUsedItemStack()).getPanel(data, syncManager, settings);
     }
+
+    // @Override
+    // public ModularUI createUI(HeldItemUIFactory.HeldItemHolder holder, Player entityPlayer) {
+    // var held = holder.getHeld();
+    // return new ModularUI(176, 157, holder, entityPlayer)
+    // .background(GuiTextures.BACKGROUND)
+    // .widget(new LabelWidget(5, 5, held.getDescriptionId()))
+    // .widget(ItemFilter.loadFilter(held).openConfigurator((176 - 80) / 2, (60 - 55) / 2 + 15))
+    // .widget(UITemplate.bindPlayerInventory(entityPlayer.getInventory(), GuiTextures.SLOT, 7, 75, true));
+    // }
 }
diff --git a/src/main/java/com/gregtechceu/gtceu/common/item/behavior/ItemMagnetBehavior.java b/src/main/java/com/gregtechceu/gtceu/common/item/behavior/ItemMagnetBehavior.java
index c0af0800eec..d1f16f4e591 100644
--- a/src/main/java/com/gregtechceu/gtceu/common/item/behavior/ItemMagnetBehavior.java
+++ b/src/main/java/com/gregtechceu/gtceu/common/item/behavior/ItemMagnetBehavior.java
@@ -5,23 +5,16 @@
 import com.gregtechceu.gtceu.api.capability.GTCapabilityHelper;
 import com.gregtechceu.gtceu.api.capability.IElectricItem;
 import com.gregtechceu.gtceu.api.cover.filter.ItemFilter;
-import com.gregtechceu.gtceu.api.gui.GuiTextures;
-import com.gregtechceu.gtceu.api.gui.UITemplate;
-import com.gregtechceu.gtceu.api.gui.widget.EnumSelectorWidget;
+import com.gregtechceu.gtceu.api.cover.filter.SimpleItemFilter;
+import com.gregtechceu.gtceu.api.cover.filter.TagItemFilter;
 import com.gregtechceu.gtceu.api.item.ComponentItem;
 import com.gregtechceu.gtceu.api.item.IComponentItem;
 import com.gregtechceu.gtceu.api.item.component.IAddInformation;
 import com.gregtechceu.gtceu.api.item.component.IInteractionItem;
 import com.gregtechceu.gtceu.api.item.component.IItemLifeCycle;
-import com.gregtechceu.gtceu.api.item.component.IItemUIFactory;
+import com.gregtechceu.gtceu.api.mui.IItemUIHolder;
 import com.gregtechceu.gtceu.common.data.GTItems;
-
-import com.lowdragmc.lowdraglib.gui.factory.HeldItemUIFactory;
-import com.lowdragmc.lowdraglib.gui.modular.ModularUI;
-import com.lowdragmc.lowdraglib.gui.texture.IGuiTexture;
-import com.lowdragmc.lowdraglib.gui.texture.ResourceTexture;
-import com.lowdragmc.lowdraglib.gui.widget.LabelWidget;
-import com.lowdragmc.lowdraglib.gui.widget.Widget;
+import com.gregtechceu.gtceu.common.mui.GTGuiTextures;
 
 import net.minecraft.nbt.CompoundTag;
 import net.minecraft.network.chat.Component;
@@ -44,15 +37,34 @@
 import net.minecraftforge.event.entity.player.PlayerXpEvent;
 import net.minecraftforge.eventbus.api.SubscribeEvent;
 
+import brachy.modularui.api.drawable.IKey;
+import brachy.modularui.drawable.ItemDrawable;
+import brachy.modularui.factory.PlayerInventoryGuiData;
+import brachy.modularui.factory.UIFactories;
+import brachy.modularui.screen.ModularPanel;
+import brachy.modularui.screen.RichTooltip;
+import brachy.modularui.screen.UISettings;
+import brachy.modularui.value.sync.*;
+import brachy.modularui.widget.ParentWidget;
+import brachy.modularui.widgets.CycleButtonWidget;
+import brachy.modularui.widgets.PagedWidget;
+import brachy.modularui.widgets.SlotGroupWidget;
+import brachy.modularui.widgets.ToggleButton;
+import brachy.modularui.widgets.layout.Flow;
+import brachy.modularui.widgets.layout.Grid;
+import brachy.modularui.widgets.slot.ModularSlot;
+import brachy.modularui.widgets.slot.PhantomItemSlot;
+import brachy.modularui.widgets.textfield.TextFieldWidget;
 import com.tterrag.registrate.util.entry.ItemEntry;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
-import oshi.util.tuples.Triplet;
 import top.theillusivec4.curios.api.CuriosApi;
 
-import java.util.*;
+import java.util.EnumMap;
+import java.util.List;
+import java.util.Map;
 
-public class ItemMagnetBehavior implements IInteractionItem, IItemLifeCycle, IAddInformation, IItemUIFactory {
+public class ItemMagnetBehavior implements IInteractionItem, IItemLifeCycle, IAddInformation, IItemUIHolder {
 
     public static final String FILTER_TAG = "MagnetFilter";
     public static final String FILTER_ORDINAL_TAG = "FilterOrdinal";
@@ -67,56 +79,119 @@ public ItemMagnetBehavior(int range) {
     }
 
     @Override
-    public ModularUI createUI(HeldItemUIFactory.HeldItemHolder holder, Player entityPlayer) {
-        var held = holder.getHeld();
-        var tag = held.getOrCreateTag();
-        var selected = Filter.get(tag.getInt(FILTER_ORDINAL_TAG));
-        var widgets = new HashSet<Triplet<Filter, Widget, Widget>>();
-        var stacks = new HashMap<Filter, ItemStack>();
-        var ui = new ModularUI(176, 157, holder, entityPlayer)
-                .background(GuiTextures.BACKGROUND)
-                .widget(new EnumSelectorWidget<>(146, 5, 20, 20,
-                        Filter.values(), selected, (val) -> updateSelection(tag, val, widgets)))
-                .widget(UITemplate.bindPlayerInventory(entityPlayer.getInventory(), GuiTextures.SLOT, 7, 75, true));
-        for (var f : Filter.values()) {
-            var stack = f.getFilter(held);
-            stack.setTag(tag.getCompound(FILTER_TAG).copy());
-            stacks.put(f, stack);
-            var description = new LabelWidget(5, 5, stack.getDescriptionId());
-            var config = ItemFilter
-                    .loadFilter(stack)
-                    .openConfigurator((176 - 80) / 2, (60 - 55) / 2 + 15);
-            var visible = f == selected;
-            description.setVisible(visible);
-            config.setVisible(visible);
-            widgets.add(new Triplet<>(f, description, config));
-            ui.widget(description);
-            ui.widget(config);
+    public ModularPanel<?> buildUI(PlayerInventoryGuiData<?> data, PanelSyncManager syncManager, UISettings settings) {
+        ItemStack held = data.getUsedItemStack();
+        CompoundTag heldTag = held.getOrCreateTag();
+
+        Filter selectedFilter = Filter.get(heldTag.getInt(FILTER_ORDINAL_TAG));
+        Map<Filter, ItemStack> stacks = new EnumMap<>(Filter.class);
+        CompoundTag startFilterTag = heldTag.getCompound(FILTER_TAG).copy();
+        for (Filter filter : Filter.values()) {
+            ItemStack stack = filter.getFilter(held);
+            stack.setTag(startFilterTag.copy());
+            stacks.put(filter, stack);
         }
-        ui.registerCloseListener(() -> {
-            var selection = Filter.get(tag.getInt(FILTER_ORDINAL_TAG));
-            tag.put(FILTER_TAG, stacks.get(selection).getOrCreateTag());
+
+        EnumSyncValue<Filter> filterSync = new EnumSyncValue<>(Filter.class,
+                () -> Filter.get(data.getUsedItemStack().getOrCreateTag().getInt(FILTER_ORDINAL_TAG)),
+                filter -> data.getUsedItemStack().getOrCreateTag().putInt(FILTER_ORDINAL_TAG, filter.ordinal()));
+
+        PagedWidget<?> pages = new PagedWidget<>()
+                .left((176 - 80) / 2)
+                .top((60 - 55) / 2 + 15)
+                .size(80, 55)
+                .initialPage(selectedFilter.ordinal())
+                .addPage(createSimpleFilterPage((SimpleItemFilter) ItemFilter.loadFilter(stacks.get(Filter.SIMPLE))))
+                .addPage(createTagFilterPage((TagItemFilter) ItemFilter.loadFilter(stacks.get(Filter.TAG))));
+        pages.onUpdateListener(widget -> {
+            int selected = filterSync.getIntValue();
+            if (selected != widget.getCurrentPageIndex()) {
+                widget.setPage(selected);
+            }
         });
-        return ui;
-    }
 
-    private void updateSelection(CompoundTag tag, Filter filter, Collection<Triplet<Filter, Widget, Widget>> widgets) {
-        tag.putInt(FILTER_ORDINAL_TAG, filter.ordinal());
-        widgets.forEach(tri -> {
-            var visible = tri.getA() == filter;
-            tri.getB().setVisible(visible);
-            tri.getC().setVisible(visible);
+        syncManager.addCloseListener(player -> {
+            ItemStack stack = data.getUsedItemStack();
+            CompoundTag tag = stack.getOrCreateTag();
+            Filter selected = Filter.get(tag.getInt(FILTER_ORDINAL_TAG));
+            tag.put(FILTER_TAG, stacks.get(selected).getOrCreateTag().copy());
         });
+
+        return new ModularPanel<>("item_magnet")
+                .size(176, 157)
+                .background(GTGuiTextures.BACKGROUND)
+                .child(IKey.dynamic(() -> Component.translatable(filterSync.getValue().getTooltip()))
+                        .asWidget()
+                        .left(5)
+                        .top(5))
+                .child(new CycleButtonWidget()
+                        .left(146)
+                        .top(5)
+                        .size(20)
+                        .value(filterSync)
+                        .stateCount(Filter.values().length)
+                        .stateOverlay(Filter.SIMPLE, new ItemDrawable(GTItems.ITEM_FILTER.asItem()))
+                        .stateOverlay(Filter.TAG, new ItemDrawable(GTItems.TAG_FILTER.asItem()))
+                        .tooltipBuilder(r -> r.addLine(IKey.dynamic(
+                                () -> Component.translatable(filterSync.getValue().getTooltip())))))
+                .child(pages)
+                .child(SlotGroupWidget.playerInventory(false).left(7).top(75).disableSortButtons());
+    }
+
+    private ParentWidget<?> createSimpleFilterPage(SimpleItemFilter filter) {
+        SimpleItemFilter.FilterItemStackHandler handler = new SimpleItemFilter.FilterItemStackHandler(filter);
+
+        Grid filterGrid = new Grid()
+                .coverChildren()
+                .mapTo(3, 9, i -> new PhantomItemSlot()
+                        .size(16)
+                        .syncHandler(new PhantomItemSlotSyncHandler(new ModularSlot(handler, i)
+                                .changeListener((stack, amount, client, init) -> handler.setStackInSlot(i, stack))
+                                .ignoreMaxStackSize(true).accessibility(true, false))));
+
+        BooleanSyncValue blacklist = new BooleanSyncValue(filter::isBlackList, filter::setBlackList);
+
+        BooleanSyncValue ignoreNBT = new BooleanSyncValue(filter::isIgnoreNbt, filter::setIgnoreNbt);
+
+        Flow filterButtons = Flow.col()
+                .coverChildren()
+                .child(new ToggleButton().stateBackground(GTGuiTextures.BUTTON_BLACKLIST).value(blacklist))
+                .child(new ToggleButton().stateBackground(GTGuiTextures.BUTTON_IGNORE_NBT).value(ignoreNBT));
+
+        return new ParentWidget<>()
+                .size(80, 55)
+                .child(filterGrid.left(0).top(0))
+                .child(filterButtons.left(58).top(0));
+    }
+
+    private ParentWidget<?> createTagFilterPage(TagItemFilter filter) {
+        StringSyncValue filterString = new StringSyncValue(filter::getFilterString, filter::setFilterString);
+        RichTooltip infoTooltip = new RichTooltip().add("cover.tag_filter.info");
+
+        return new ParentWidget<>()
+                .size(80, 55)
+                .child(Flow.row()
+                        .coverChildren()
+                        .left(0)
+                        .top(18)
+                        .child(new TextFieldWidget()
+                                .width(62)
+                                .value(filterString))
+                        .child(GTGuiTextures.INFO.asWidget()
+                                .size(16)
+                                .tooltip(infoTooltip)));
     }
 
     @Override
     public InteractionResultHolder<ItemStack> use(Item item, Level world, @NotNull Player player,
                                                   InteractionHand hand) {
-        if (!player.level().isClientSide && player.isShiftKeyDown()) {
-            player.displayClientMessage(Component.translatable(toggleActive(player.getItemInHand(hand)) ?
-                    "behavior.item_magnet.enabled" : "behavior.item_magnet.disabled"), true);
-        } else {
-            IItemUIFactory.super.use(item, world, player, hand);
+        if (!player.level().isClientSide) {
+            if (player.isShiftKeyDown()) {
+                player.displayClientMessage(Component.translatable(toggleActive(player.getItemInHand(hand)) ?
+                        "behavior.item_magnet.enabled" : "behavior.item_magnet.disabled"), true);
+            } else {
+                UIFactories.playerInventory().openFromHand(player, hand);
+            }
         }
         return InteractionResultHolder.pass(player.getItemInHand(hand));
     }
@@ -287,7 +362,7 @@ public static boolean hasMagnetCurios(Player player) {
         }
     }
 
-    public enum Filter implements EnumSelectorWidget.SelectableEnum {
+    public enum Filter {
 
         SIMPLE(GTItems.ITEM_FILTER, "item_filter"),
         TAG(GTItems.TAG_FILTER, "item_tag_filter");
@@ -316,14 +391,8 @@ public static Filter get(int ordinal) {
             return Filter.values()[ordinal];
         }
 
-        @Override
         public @NotNull String getTooltip() {
             return item.asItem().getDescriptionId();
         }
-
-        @Override
-        public @NotNull IGuiTexture getIcon() {
-            return new ResourceTexture("gtceu:textures/item/" + texture + ".png");
-        }
     }
 }
diff --git a/src/main/java/com/gregtechceu/gtceu/common/item/behavior/PortableScannerBehavior.java b/src/main/java/com/gregtechceu/gtceu/common/item/behavior/PortableScannerBehavior.java
index 54db194be9a..fb965cdd1e9 100644
--- a/src/main/java/com/gregtechceu/gtceu/common/item/behavior/PortableScannerBehavior.java
+++ b/src/main/java/com/gregtechceu/gtceu/common/item/behavior/PortableScannerBehavior.java
@@ -28,6 +28,7 @@
 import net.minecraft.ChatFormatting;
 import net.minecraft.core.BlockPos;
 import net.minecraft.nbt.CompoundTag;
+import net.minecraft.nbt.NbtUtils;
 import net.minecraft.network.chat.Component;
 import net.minecraft.server.level.ServerLevel;
 import net.minecraft.server.level.ServerPlayer;
@@ -323,7 +324,7 @@ public int addScannerInfo(Player player, Level level, BlockPos pos, DisplayMode
                     if (recipeLogic.getStatus().equals(RecipeLogic.Status.WAITING)) {
                         list.add(Component.translatable("behavior.portable_scanner.divider"));
                         list.add(Component.translatable("gtceu.multiblock.waiting"));
-                        list.addAll(recipeLogic.getFancyTooltip());
+                        list.addAll(recipeLogic.getWaitingReasons());
                     } else if (recipe != null) {
                         list.add(Component.translatable("behavior.portable_scanner.divider"));
                         var EUt = RecipeHelper.getRealEUtWithIO(recipe);
@@ -480,7 +481,7 @@ else if (machine instanceof IDataInfoProvider)
     }
 
     private void nbtFormat(List<Component> comp, CompoundTag tag) {
-        comp.add(Component.literal(tag.toString()));
+        comp.add(NbtUtils.toPrettyComponent(tag));
     }
 
     @Override
diff --git a/src/main/java/com/gregtechceu/gtceu/common/item/modules/GuiModuleBehaviour.java b/src/main/java/com/gregtechceu/gtceu/common/item/modules/GuiModuleBehaviour.java
new file mode 100644
index 00000000000..a262c7410c8
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/common/item/modules/GuiModuleBehaviour.java
@@ -0,0 +1,44 @@
+package com.gregtechceu.gtceu.common.item.modules;
+
+import com.gregtechceu.gtceu.api.item.component.IMonitorModuleItem;
+import com.gregtechceu.gtceu.client.renderer.monitor.IMonitorRenderer;
+import com.gregtechceu.gtceu.client.renderer.monitor.MonitorGuiRenderer;
+import com.gregtechceu.gtceu.common.machine.multiblock.electric.CentralMonitorMachine;
+import com.gregtechceu.gtceu.common.machine.multiblock.electric.monitor.MonitorGroup;
+
+import net.minecraft.core.BlockPos;
+import net.minecraft.world.item.ItemStack;
+import net.minecraft.world.level.Level;
+
+import brachy.modularui.api.IPanelHandler;
+import brachy.modularui.api.drawable.IKey;
+import brachy.modularui.screen.ModularPanel;
+import brachy.modularui.value.sync.PanelSyncManager;
+import brachy.modularui.widgets.TextWidget;
+import com.mojang.datafixers.util.Pair;
+
+import java.util.HashMap;
+import java.util.Map;
+
+public class GuiModuleBehaviour implements IMonitorModuleItem {
+
+    private final Map<Pair<Level, BlockPos>, MonitorGuiRenderer> renderers = new HashMap<>();
+
+    @Override
+    public IMonitorRenderer getRenderer(ItemStack stack, CentralMonitorMachine machine, MonitorGroup group) {
+        return renderers.computeIfAbsent(
+                Pair.of(group.getTargetLevel(machine.getLevel()), group.getTarget(machine.getLevel())),
+                MonitorGuiRenderer::new);
+    }
+
+    @Override
+    public IPanelHandler createModularPanel(ItemStack stack, CentralMonitorMachine machine, MonitorGroup group,
+                                            PanelSyncManager syncManager) {
+        return syncManager.syncedPanel("gui_module_" + group.getName(), true,
+                (psm, handler) -> new ModularPanel<>("gui_module_info")
+                        .coverChildren()
+                        .child(new TextWidget<>(IKey.lang("gtceu.gui.central_monitor.gui_module_info"))
+                                .height(50)
+                                .width(200)));
+    }
+}
diff --git a/src/main/java/com/gregtechceu/gtceu/common/item/modules/ImageModuleBehaviour.java b/src/main/java/com/gregtechceu/gtceu/common/item/modules/ImageModuleBehaviour.java
index b21ee3a4750..5177be7dc76 100644
--- a/src/main/java/com/gregtechceu/gtceu/common/item/modules/ImageModuleBehaviour.java
+++ b/src/main/java/com/gregtechceu/gtceu/common/item/modules/ImageModuleBehaviour.java
@@ -1,44 +1,52 @@
 package com.gregtechceu.gtceu.common.item.modules;
 
-import com.gregtechceu.gtceu.api.gui.GuiTextures;
+import com.gregtechceu.gtceu.api.item.component.IAddInformation;
 import com.gregtechceu.gtceu.api.item.component.IMonitorModuleItem;
 import com.gregtechceu.gtceu.client.renderer.monitor.IMonitorRenderer;
 import com.gregtechceu.gtceu.client.renderer.monitor.MonitorImageRenderer;
 import com.gregtechceu.gtceu.common.machine.multiblock.electric.CentralMonitorMachine;
 import com.gregtechceu.gtceu.common.machine.multiblock.electric.monitor.MonitorGroup;
-import com.gregtechceu.gtceu.common.network.GTNetwork;
-import com.gregtechceu.gtceu.common.network.packets.SCPacketMonitorGroupNBTChange;
-
-import com.lowdragmc.lowdraglib.gui.widget.ButtonWidget;
-import com.lowdragmc.lowdraglib.gui.widget.TextFieldWidget;
-import com.lowdragmc.lowdraglib.gui.widget.Widget;
-import com.lowdragmc.lowdraglib.gui.widget.WidgetGroup;
 
+import net.minecraft.ChatFormatting;
+import net.minecraft.network.chat.Component;
 import net.minecraft.world.item.ItemStack;
+import net.minecraft.world.item.TooltipFlag;
+import net.minecraft.world.level.Level;
+
+import brachy.modularui.api.IPanelHandler;
+import brachy.modularui.api.drawable.IKey;
+import brachy.modularui.screen.ModularPanel;
+import brachy.modularui.value.sync.PanelSyncManager;
+import brachy.modularui.value.sync.SyncHandlers;
+import brachy.modularui.widgets.TextWidget;
+import brachy.modularui.widgets.layout.Flow;
+import brachy.modularui.widgets.textfield.TextFieldWidget;
+import org.jetbrains.annotations.Nullable;
+
+import java.util.List;
 
-public class ImageModuleBehaviour implements IMonitorModuleItem {
+public class ImageModuleBehaviour implements IMonitorModuleItem, IAddInformation {
 
     @Override
-    public IMonitorRenderer getRenderer(ItemStack stack) {
+    public IMonitorRenderer getRenderer(ItemStack stack, CentralMonitorMachine machine, MonitorGroup group) {
         return new MonitorImageRenderer(getUrl(stack));
     }
 
     @Override
-    public Widget createUIWidget(ItemStack stack, CentralMonitorMachine machine, MonitorGroup group) {
-        WidgetGroup builder = new WidgetGroup();
-        TextFieldWidget textField = new TextFieldWidget(0, 0, 100, 10, null, null);
-        textField.setCurrentString(getUrl(stack));
-
-        ButtonWidget saveButton = new ButtonWidget(-40, 22, 20, 20, click -> {
-            if (!click.isRemote) return;
-
-            setUrl(stack, textField.getCurrentString());
-            GTNetwork.sendToServer(new SCPacketMonitorGroupNBTChange(stack, group, machine));
-        });
-        saveButton.setButtonTexture(GuiTextures.BUTTON_CHECK);
-        builder.addWidget(textField);
-        builder.addWidget(saveButton);
-        return builder;
+    public IPanelHandler createModularPanel(ItemStack stack, CentralMonitorMachine machine, MonitorGroup group,
+                                            PanelSyncManager syncManager) {
+        return syncManager.syncedPanel("image_module_" + group.getName(), true,
+                (psm, handler) -> new ModularPanel<>("image_module_editor")
+                        .size(200, 50)
+                        .child(Flow.column()
+                                .marginTop(5)
+                                .center()
+                                .widthRel(1)
+                                .child(new TextWidget<>(IKey.lang("gtceu.gui.central_monitor.url")))
+                                .child(new TextFieldWidget()
+                                        .value(SyncHandlers.string(() -> getUrl(stack), s -> setUrl(stack, s)))
+                                        .center()
+                                        .widthRel(.8f))));
     }
 
     @Override
@@ -53,4 +61,11 @@ public String getUrl(ItemStack stack) {
     public void setUrl(ItemStack stack, String url) {
         stack.getOrCreateTag().putString("url", url);
     }
+
+    @Override
+    public void appendHoverText(ItemStack stack, @Nullable Level level, List<Component> tooltipComponents,
+                                TooltipFlag isAdvanced) {
+        tooltipComponents.add(Component.translatable("gtceu.item.tooltip.image_url", getUrl(stack))
+                .withStyle(ChatFormatting.DARK_AQUA));
+    }
 }
diff --git a/src/main/java/com/gregtechceu/gtceu/common/item/modules/TextModuleBehaviour.java b/src/main/java/com/gregtechceu/gtceu/common/item/modules/TextModuleBehaviour.java
index a4dfd2905eb..c9e35799317 100644
--- a/src/main/java/com/gregtechceu/gtceu/common/item/modules/TextModuleBehaviour.java
+++ b/src/main/java/com/gregtechceu/gtceu/common/item/modules/TextModuleBehaviour.java
@@ -1,6 +1,5 @@
 package com.gregtechceu.gtceu.common.item.modules;
 
-import com.gregtechceu.gtceu.api.gui.GuiTextures;
 import com.gregtechceu.gtceu.api.item.component.IAddInformation;
 import com.gregtechceu.gtceu.api.item.component.IMonitorModuleItem;
 import com.gregtechceu.gtceu.api.placeholder.MultiLineComponent;
@@ -10,46 +9,27 @@
 import com.gregtechceu.gtceu.client.renderer.monitor.MonitorTextRenderer;
 import com.gregtechceu.gtceu.common.machine.multiblock.electric.CentralMonitorMachine;
 import com.gregtechceu.gtceu.common.machine.multiblock.electric.monitor.MonitorGroup;
-import com.gregtechceu.gtceu.common.network.GTNetwork;
-import com.gregtechceu.gtceu.common.network.packets.SCPacketMonitorGroupNBTChange;
-
-import com.lowdragmc.lowdraglib.gui.widget.ButtonWidget;
-import com.lowdragmc.lowdraglib.gui.widget.TextFieldWidget;
-import com.lowdragmc.lowdraglib.gui.widget.Widget;
-import com.lowdragmc.lowdraglib.gui.widget.WidgetGroup;
-import com.lowdragmc.lowdraglib.gui.widget.codeeditor.CodeEditorWidget;
+import com.gregtechceu.gtceu.common.mui.GTGuiTextures;
 
 import net.minecraft.ChatFormatting;
-import net.minecraft.nbt.CompoundTag;
 import net.minecraft.nbt.ListTag;
 import net.minecraft.nbt.StringTag;
 import net.minecraft.nbt.Tag;
 import net.minecraft.network.chat.Component;
-import net.minecraft.util.Mth;
 import net.minecraft.world.item.ItemStack;
 import net.minecraft.world.item.TooltipFlag;
 import net.minecraft.world.level.Level;
 
+import brachy.modularui.api.IPanelHandler;
+import brachy.modularui.value.sync.*;
 import org.jetbrains.annotations.Nullable;
 
-import java.util.ArrayList;
 import java.util.List;
 import java.util.UUID;
-import java.util.function.Supplier;
 
 public class TextModuleBehaviour implements IMonitorModuleItem, IAddInformation {
 
-    private void updateText(ItemStack stack, PlaceholderContext ctx) {
-        if (!stack.getOrCreateTag().contains("placeholderUUID")) {
-            stack.getOrCreateTag().putUUID("placeholderUUID", UUID.randomUUID());
-        }
-        MultiLineComponent text = PlaceholderHandler.processPlaceholders(
-                getPlaceholderText(stack),
-                ctx);
-        stack.getOrCreateTag().put("text", text.toTag());
-    }
-
-    private PlaceholderContext makeContext(ItemStack stack, CentralMonitorMachine machine, MonitorGroup group) {
+    private PlaceholderContext getContext(ItemStack stack, CentralMonitorMachine machine, MonitorGroup group) {
         return new PlaceholderContext(
                 group.getTargetLevel(machine.getLevel()),
                 group.getTarget(machine.getLevel()),
@@ -58,74 +38,48 @@ private PlaceholderContext makeContext(ItemStack stack, CentralMonitorMachine ma
                 group.getTargetCover(machine.getLevel()),
                 group,
                 null,
-                stack.getOrCreateTag().contains("placeholderUUID") ? stack.getOrCreateTag().getUUID("placeholderUUID") :
-                        null);
+                stack.getOrCreateTag().getUUID("placeholderUUID"));
     }
 
-    @Override
-    public void tick(ItemStack stack, CentralMonitorMachine machine, MonitorGroup group) {
-        this.updateText(stack, makeContext(stack, machine, group));
+    private void updateText(ItemStack stack, CentralMonitorMachine machine, MonitorGroup group) {
+        if (!stack.getOrCreateTag().contains("placeholderUUID")) {
+            stack.getOrCreateTag().putUUID("placeholderUUID", UUID.randomUUID());
+        }
+        MultiLineComponent text = PlaceholderHandler.processPlaceholders(
+                getPlaceholderText(stack), getContext(stack, machine, group));
+        stack.getOrCreateTag().put("text",
+                text.withStyle(style -> style.withFont(GTGuiTextures.MONOCRAFT_FONT)).toTag());
     }
 
     @Override
-    public void tickInPlaceholder(ItemStack stack, PlaceholderContext context) {
-        this.updateText(stack, context);
+    public void tick(ItemStack stack, CentralMonitorMachine machine, MonitorGroup group) {
+        if (!isPaused(stack))
+            this.updateText(stack, machine, group);
     }
 
     @Override
-    public IMonitorRenderer getRenderer(ItemStack stack) {
+    public IMonitorRenderer getRenderer(ItemStack stack, CentralMonitorMachine machine, MonitorGroup group) {
         return new MonitorTextRenderer(
                 getText(stack),
                 Math.max(getScale(stack), .0001));
     }
 
     @Override
-    public Widget createUIWidget(ItemStack stack, CentralMonitorMachine machine, MonitorGroup group) {
-        WidgetGroup builder = new WidgetGroup();
-        CodeEditorWidget editor = new CodeEditorWidget(0, 0, 120, 80);
-        // editor.codeEditor.setLanguageDefinition(PlaceholderHandler.LANG_DEFINITION);
-        TextFieldWidget scaleInput = new TextFieldWidget(
-                -50, 47,
-                40, 10,
-                null,
-                null);
-        ButtonWidget saveButton = new ButtonWidget(-40, 22, 20, 20, click -> {
-            if (!click.isRemote) return;
-            ListTag listTag = new ListTag();
-            editor.getLines().forEach(line -> listTag.add(StringTag.valueOf(line.replaceAll("\r", ""))));
-            CompoundTag tag2 = stack.getOrCreateTag();
-            tag2.put("formatStringLines", listTag);
-            try {
-                tag2.putDouble("scale", Double.parseDouble(scaleInput.getCurrentString()));
-            } catch (NumberFormatException ignored) {}
-            stack.setTag(tag2);
-            GTNetwork.sendToServer(new SCPacketMonitorGroupNBTChange(stack, group, machine));
-        });
-        saveButton.setButtonTexture(GuiTextures.BUTTON_CHECK);
-        List<Boolean> tmp = new ArrayList<>();
-        Supplier<String> scaleInputSupplier = () -> {
-            if (tmp.isEmpty()) tmp.add(true);
-            else scaleInput.setTextSupplier(null);
-            if (!stack.getOrCreateTag().contains("scale")) {
-                stack.getOrCreateTag().putDouble("scale", 1);
-                GTNetwork.sendToServer(new SCPacketMonitorGroupNBTChange(stack, group, machine));
-                return "1";
-            }
-            return String.valueOf(Mth.clamp(stack.getOrCreateTag().getDouble("scale"), .0001, 1000));
-        };
-        scaleInput.setTextSupplier(scaleInputSupplier);
-        scaleInput.setHoverTooltips(Component.translatable("gtceu.gui.central_monitor.text_scale"));
-        ListTag tag = stack.getOrCreateTag().getList("formatStringLines", Tag.TAG_STRING);
-        List<String> formatStringLines = new ArrayList<>();
-        for (Tag line : tag) formatStringLines.add(line.getAsString());
-        editor.setLines(formatStringLines);
-        builder.addWidget(editor);
-        builder.addWidget(saveButton);
-        Widget placeholderReference = PlaceholderHandler.getPlaceholderHandlerUI("");
-        builder.addWidget(scaleInput);
-        placeholderReference.setSelfPosition(-100, -50);
-        builder.addWidget(placeholderReference);
-        return builder;
+    public IPanelHandler createModularPanel(ItemStack stack, CentralMonitorMachine machine, MonitorGroup group,
+                                            PanelSyncManager syncManager) {
+        PlaceholderContext ctx = getContext(stack, machine, group);
+        StringSyncValue code = SyncHandlers.string(
+                () -> getPlaceholderText(stack),
+                s -> setPlaceholderText(stack, s));
+        DoubleSyncValue scale = SyncHandlers.doubleNumber(
+                () -> getScale(stack),
+                s -> setScale(stack, s));
+        BooleanSyncValue pause = SyncHandlers.bool(() -> isPaused(stack), p -> setPaused(stack, p));
+        Runnable updateText = () -> updateText(stack, machine, group);
+        assert ctx.itemStackHandler() != null;
+        return PlaceholderHandler.createPlaceholderEditor("text_module_" + group.getName(), syncManager, ctx, code,
+                scale, null, pause,
+                updateText);
     }
 
     @Override
@@ -138,6 +92,8 @@ public MultiLineComponent getText(ItemStack stack) {
     }
 
     public double getScale(ItemStack stack) {
+        if (!stack.getOrCreateTag().contains("scale"))
+            return 1;
         return Math.max(stack.getOrCreateTag().getDouble("scale"), .0001);
     }
 
@@ -145,6 +101,16 @@ public void setScale(ItemStack stack, double scale) {
         stack.getOrCreateTag().putDouble("scale", scale);
     }
 
+    public void setPaused(ItemStack stack, boolean paused) {
+        stack.getOrCreateTag().putBoolean("paused", paused);
+    }
+
+    public boolean isPaused(ItemStack stack) {
+        if (stack.getOrCreateTag().contains("paused"))
+            return stack.getOrCreateTag().getBoolean("paused");
+        else return false;
+    }
+
     public void setPlaceholderText(ItemStack stack, String text) {
         ListTag listTag = new ListTag();
         for (String line : text.split("\n")) listTag.add(StringTag.valueOf(line.replaceAll("\r", "")));
diff --git a/src/main/java/com/gregtechceu/gtceu/common/item/tool/behavior/AOEConfigUIBehavior.java b/src/main/java/com/gregtechceu/gtceu/common/item/tool/behavior/AOEConfigUIBehavior.java
index 261f013aff3..1831f22d947 100644
--- a/src/main/java/com/gregtechceu/gtceu/common/item/tool/behavior/AOEConfigUIBehavior.java
+++ b/src/main/java/com/gregtechceu/gtceu/common/item/tool/behavior/AOEConfigUIBehavior.java
@@ -1,18 +1,24 @@
 package com.gregtechceu.gtceu.common.item.tool.behavior;
 
-import com.gregtechceu.gtceu.api.gui.GuiTextures;
 import com.gregtechceu.gtceu.api.item.tool.aoe.AoESymmetrical;
 import com.gregtechceu.gtceu.api.item.tool.behavior.IToolUIBehavior;
 
-import com.lowdragmc.lowdraglib.gui.factory.HeldItemUIFactory;
-import com.lowdragmc.lowdraglib.gui.modular.ModularUI;
-import com.lowdragmc.lowdraglib.gui.texture.TextTexture;
-import com.lowdragmc.lowdraglib.gui.widget.ButtonWidget;
-import com.lowdragmc.lowdraglib.gui.widget.LabelWidget;
-
+import net.minecraft.nbt.CompoundTag;
+import net.minecraft.network.chat.Component;
 import net.minecraft.world.InteractionHand;
 import net.minecraft.world.entity.player.Player;
+import net.minecraft.world.item.ItemStack;
 
+import brachy.modularui.api.drawable.IKey;
+import brachy.modularui.drawable.GuiTextures;
+import brachy.modularui.factory.PlayerInventoryGuiData;
+import brachy.modularui.screen.ModularPanel;
+import brachy.modularui.screen.UISettings;
+import brachy.modularui.value.sync.InteractionSyncHandler;
+import brachy.modularui.value.sync.PanelSyncManager;
+import brachy.modularui.widgets.ButtonWidget;
+import brachy.modularui.widgets.TextWidget;
+import brachy.modularui.widgets.layout.Flow;
 import org.jetbrains.annotations.NotNull;
 
 import static com.gregtechceu.gtceu.api.item.tool.ToolHelper.getBehaviorsTag;
@@ -22,50 +28,147 @@ public class AOEConfigUIBehavior implements IToolUIBehavior {
 
     public static final AOEConfigUIBehavior INSTANCE = new AOEConfigUIBehavior();
 
+    // @Override
+    // public boolean openUI(@NotNull Player player, @NotNull InteractionHand hand) {
+    // return player.isShiftKeyDown() && !getMaxAoEDefinition(player.getItemInHand(hand)).isZero();
+    // }
+    //
+    // @Override
+    // public ModularUI createUI(Player player, HeldItemUIFactory.HeldItemHolder holder) {
+    // var tag = getBehaviorsTag(holder.getHeld());
+    // var defaultDefinition = getMaxAoEDefinition(holder.getHeld());
+    // return new ModularUI(120, 80, holder, player).background(GuiTextures.BACKGROUND)
+    // .widget(new LabelWidget(6, 10, "item.gtceu.tool.aoe.columns"))
+    // .widget(new LabelWidget(49, 10, "item.gtceu.tool.aoe.rows"))
+    // .widget(new LabelWidget(79, 10, "item.gtceu.tool.aoe.layers"))
+    // .widget(new ButtonWidget(15, 24, 20, 20, new TextTexture("+"), (data) -> {
+    // AoESymmetrical.increaseColumn(tag, defaultDefinition);
+    // holder.markAsDirty();
+    // }))
+    // .widget(new ButtonWidget(15, 44, 20, 20, new TextTexture("-"), (data) -> {
+    // AoESymmetrical.decreaseColumn(tag, defaultDefinition);
+    // holder.markAsDirty();
+    // }))
+    // .widget(new ButtonWidget(50, 24, 20, 20, new TextTexture("+"), (data) -> {
+    // AoESymmetrical.increaseRow(tag, defaultDefinition);
+    // holder.markAsDirty();
+    // }))
+    // .widget(new ButtonWidget(50, 44, 20, 20, new TextTexture("-"), (data) -> {
+    // AoESymmetrical.decreaseRow(tag, defaultDefinition);
+    // holder.markAsDirty();
+    // }))
+    // .widget(new ButtonWidget(85, 24, 20, 20, new TextTexture("+"), (data) -> {
+    // AoESymmetrical.increaseLayer(tag, defaultDefinition);
+    // holder.markAsDirty();
+    // }))
+    // .widget(new ButtonWidget(85, 44, 20, 20, new TextTexture("-"), (data) -> {
+    // AoESymmetrical.decreaseLayer(tag, defaultDefinition);
+    // holder.markAsDirty();
+    // }))
+    // .widget(new LabelWidget(23, 65,
+    // () -> Integer.toString(1 +
+    // 2 * AoESymmetrical.getColumn(getBehaviorsTag(holder.getHeld()), defaultDefinition))))
+    // .widget(new LabelWidget(58, 65,
+    // () -> Integer.toString(
+    // 1 + 2 * AoESymmetrical.getRow(getBehaviorsTag(holder.getHeld()), defaultDefinition))))
+    // .widget(new LabelWidget(93, 65, () -> Integer
+    // .toString(1 + AoESymmetrical.getLayer(getBehaviorsTag(holder.getHeld()), defaultDefinition))));
+    // }
+
     @Override
-    public boolean openUI(@NotNull Player player, @NotNull InteractionHand hand) {
+    public boolean shouldOpenUI(@NotNull Player player, @NotNull InteractionHand hand) {
         return player.isShiftKeyDown() && !getMaxAoEDefinition(player.getItemInHand(hand)).isZero();
     }
 
     @Override
-    public ModularUI createUI(Player player, HeldItemUIFactory.HeldItemHolder holder) {
-        var tag = getBehaviorsTag(holder.getHeld());
-        var defaultDefinition = getMaxAoEDefinition(holder.getHeld());
-        return new ModularUI(120, 80, holder, player).background(GuiTextures.BACKGROUND)
-                .widget(new LabelWidget(6, 10, "item.gtceu.tool.aoe.columns"))
-                .widget(new LabelWidget(49, 10, "item.gtceu.tool.aoe.rows"))
-                .widget(new LabelWidget(79, 10, "item.gtceu.tool.aoe.layers"))
-                .widget(new ButtonWidget(15, 24, 20, 20, new TextTexture("+"), (data) -> {
-                    AoESymmetrical.increaseColumn(tag, defaultDefinition);
-                    holder.markAsDirty();
-                }))
-                .widget(new ButtonWidget(15, 44, 20, 20, new TextTexture("-"), (data) -> {
-                    AoESymmetrical.decreaseColumn(tag, defaultDefinition);
-                    holder.markAsDirty();
-                }))
-                .widget(new ButtonWidget(50, 24, 20, 20, new TextTexture("+"), (data) -> {
-                    AoESymmetrical.increaseRow(tag, defaultDefinition);
-                    holder.markAsDirty();
-                }))
-                .widget(new ButtonWidget(50, 44, 20, 20, new TextTexture("-"), (data) -> {
-                    AoESymmetrical.decreaseRow(tag, defaultDefinition);
-                    holder.markAsDirty();
-                }))
-                .widget(new ButtonWidget(85, 24, 20, 20, new TextTexture("+"), (data) -> {
-                    AoESymmetrical.increaseLayer(tag, defaultDefinition);
-                    holder.markAsDirty();
-                }))
-                .widget(new ButtonWidget(85, 44, 20, 20, new TextTexture("-"), (data) -> {
-                    AoESymmetrical.decreaseLayer(tag, defaultDefinition);
-                    holder.markAsDirty();
-                }))
-                .widget(new LabelWidget(23, 65,
-                        () -> Integer.toString(1 +
-                                2 * AoESymmetrical.getColumn(getBehaviorsTag(holder.getHeld()), defaultDefinition))))
-                .widget(new LabelWidget(58, 65,
-                        () -> Integer.toString(
-                                1 + 2 * AoESymmetrical.getRow(getBehaviorsTag(holder.getHeld()), defaultDefinition))))
-                .widget(new LabelWidget(93, 65, () -> Integer
-                        .toString(1 + AoESymmetrical.getLayer(getBehaviorsTag(holder.getHeld()), defaultDefinition))));
+    public ModularPanel<?> buildUI(PlayerInventoryGuiData<?> data, PanelSyncManager syncManager, UISettings settings) {
+        ItemStack held = data.getUsedItemStack();
+        CompoundTag tag = getBehaviorsTag(held);
+        AoESymmetrical defaultDefinition = getMaxAoEDefinition(held);
+        InteractionSyncHandler minusCols = new InteractionSyncHandler();
+        minusCols.setOnMousePressed(data1 -> AoESymmetrical.decreaseColumn(tag, defaultDefinition));
+        InteractionSyncHandler plusCols = new InteractionSyncHandler();
+        plusCols.setOnMousePressed(data1 -> AoESymmetrical.increaseColumn(tag, defaultDefinition));
+        InteractionSyncHandler minusRows = new InteractionSyncHandler();
+        minusRows.setOnMousePressed(data1 -> AoESymmetrical.decreaseRow(tag, defaultDefinition));
+        InteractionSyncHandler plusRows = new InteractionSyncHandler();
+        plusRows.setOnMousePressed(data1 -> AoESymmetrical.increaseRow(tag, defaultDefinition));
+        InteractionSyncHandler minusLayers = new InteractionSyncHandler();
+        minusLayers.setOnMousePressed(data1 -> AoESymmetrical.decreaseLayer(tag, defaultDefinition));
+        InteractionSyncHandler plusLayers = new InteractionSyncHandler();
+        plusLayers.setOnMousePressed(data1 -> AoESymmetrical.increaseLayer(tag, defaultDefinition));
+        return new ModularPanel<>("aoe_config")
+                .coverChildren()
+                .child(Flow.row()
+                        .coverChildren()
+                        .childPadding(5)
+                        .verticalCenter()
+                        .margin(20, 5)
+                        .child(Flow.column()
+                                .childPadding(6)
+                                .coverChildren()
+                                .child(IKey.lang("item.gtceu.tool.aoe.columns").asWidget())
+                                .child(IKey.lang("item.gtceu.tool.aoe.rows").asWidget())
+                                .child(IKey.lang("item.gtceu.tool.aoe.layers").asWidget()))
+                        .child(Flow.column()
+                                .childPadding(2)
+                                .coverChildren()
+                                .child(Flow.row()
+                                        .coverChildren()
+                                        .childPadding(2)
+                                        .child(new ButtonWidget<>()
+                                                .size(12)
+                                                .background(GuiTextures.MC_BUTTON,
+                                                        GuiTextures.REMOVE.asIcon().size(10))
+                                                .hoverBackground(GuiTextures.MC_BUTTON_HOVERED,
+                                                        GuiTextures.REMOVE.asIcon().size(10))
+                                                .syncHandler(minusCols))
+                                        .child(new TextWidget<>(IKey.dynamic(() -> Component.literal(Integer.toString(
+                                                2 * AoESymmetrical.getColumn(tag, defaultDefinition) + 1)))))
+                                        .child(new ButtonWidget<>()
+                                                .size(12)
+                                                .background(GuiTextures.MC_BUTTON,
+                                                        GuiTextures.ADD.asIcon().size(10))
+                                                .hoverBackground(GuiTextures.MC_BUTTON_HOVERED,
+                                                        GuiTextures.ADD.asIcon().size(10))
+                                                .syncHandler(plusCols)))
+                                .child(Flow.row()
+                                        .coverChildren()
+                                        .childPadding(2)
+                                        .child(new ButtonWidget<>()
+                                                .size(12)
+                                                .background(GuiTextures.MC_BUTTON,
+                                                        GuiTextures.REMOVE.asIcon().size(10))
+                                                .hoverBackground(GuiTextures.MC_BUTTON_HOVERED,
+                                                        GuiTextures.REMOVE.asIcon().size(10))
+                                                .syncHandler(minusRows))
+                                        .child(new TextWidget<>(IKey.dynamic(() -> Component.literal(Integer.toString(
+                                                2 * AoESymmetrical.getRow(tag, defaultDefinition) + 1)))))
+                                        .child(new ButtonWidget<>()
+                                                .size(12)
+                                                .background(GuiTextures.MC_BUTTON,
+                                                        GuiTextures.ADD.asIcon().size(10))
+                                                .hoverBackground(GuiTextures.MC_BUTTON_HOVERED,
+                                                        GuiTextures.ADD.asIcon().size(10))
+                                                .syncHandler(plusRows)))
+                                .child(Flow.row()
+                                        .coverChildren()
+                                        .childPadding(2)
+                                        .child(new ButtonWidget<>()
+                                                .size(12)
+                                                .background(GuiTextures.MC_BUTTON,
+                                                        GuiTextures.REMOVE.asIcon().size(10))
+                                                .hoverBackground(GuiTextures.MC_BUTTON_HOVERED,
+                                                        GuiTextures.REMOVE.asIcon().size(10))
+                                                .syncHandler(minusLayers))
+                                        .child(new TextWidget<>(IKey.dynamic(() -> Component.literal(Integer.toString(
+                                                2 * AoESymmetrical.getLayer(tag, defaultDefinition) + 1)))))
+                                        .child(new ButtonWidget<>()
+                                                .size(12)
+                                                .background(GuiTextures.MC_BUTTON,
+                                                        GuiTextures.ADD.asIcon().size(10))
+                                                .hoverBackground(GuiTextures.MC_BUTTON_HOVERED,
+                                                        GuiTextures.ADD.asIcon().size(10))
+                                                .syncHandler(plusLayers)))));
     }
 }
diff --git a/src/main/java/com/gregtechceu/gtceu/common/machine/electric/BatteryBufferMachine.java b/src/main/java/com/gregtechceu/gtceu/common/machine/electric/BatteryBufferMachine.java
index 3097ca8cbb1..c5a80189c4b 100644
--- a/src/main/java/com/gregtechceu/gtceu/common/machine/electric/BatteryBufferMachine.java
+++ b/src/main/java/com/gregtechceu/gtceu/common/machine/electric/BatteryBufferMachine.java
@@ -7,25 +7,31 @@
 import com.gregtechceu.gtceu.api.capability.IElectricItem;
 import com.gregtechceu.gtceu.api.capability.IMonitorComponent;
 import com.gregtechceu.gtceu.api.capability.compat.FeCompat;
-import com.gregtechceu.gtceu.api.gui.GuiTextures;
-import com.gregtechceu.gtceu.api.gui.widget.SlotWidget;
 import com.gregtechceu.gtceu.api.machine.TieredEnergyMachine;
-import com.gregtechceu.gtceu.api.machine.feature.IFancyUIMachine;
+import com.gregtechceu.gtceu.api.machine.feature.IMuiMachine;
+import com.gregtechceu.gtceu.api.machine.mui.MachineUIPanel;
 import com.gregtechceu.gtceu.api.machine.trait.NotifiableEnergyContainer;
 import com.gregtechceu.gtceu.api.sync_system.annotations.SaveField;
 import com.gregtechceu.gtceu.api.transfer.item.CustomItemStackHandler;
+import com.gregtechceu.gtceu.common.mui.GTGuiTextures;
+import com.gregtechceu.gtceu.common.mui.GTMuiMachineUtil;
 import com.gregtechceu.gtceu.config.ConfigHolder;
+import com.gregtechceu.gtceu.utils.GTStringUtils;
 import com.gregtechceu.gtceu.utils.GTUtil;
 
-import com.lowdragmc.lowdraglib.gui.texture.GuiTextureGroup;
-import com.lowdragmc.lowdraglib.gui.texture.IGuiTexture;
-import com.lowdragmc.lowdraglib.gui.widget.Widget;
-import com.lowdragmc.lowdraglib.gui.widget.WidgetGroup;
-import com.lowdragmc.lowdraglib.utils.Position;
-
 import net.minecraft.core.Direction;
+import net.minecraft.network.chat.Component;
 import net.minecraftforge.energy.IEnergyStorage;
 
+import brachy.modularui.api.drawable.IDrawable;
+import brachy.modularui.api.drawable.IKey;
+import brachy.modularui.factory.PosGuiData;
+import brachy.modularui.screen.UISettings;
+import brachy.modularui.value.sync.DoubleSyncValue;
+import brachy.modularui.value.sync.PanelSyncManager;
+import brachy.modularui.widget.ParentWidget;
+import brachy.modularui.widgets.ProgressWidget;
+import brachy.modularui.widgets.layout.Flow;
 import lombok.Getter;
 import org.jetbrains.annotations.Nullable;
 
@@ -33,7 +39,7 @@
 import java.util.List;
 
 public class BatteryBufferMachine extends TieredEnergyMachine
-                                  implements IControllable, IFancyUIMachine, IMonitorComponent {
+                                  implements IControllable, IMonitorComponent, IMuiMachine {
 
     public static final long AMPS_PER_BATTERY = 2L;
 
@@ -84,40 +90,43 @@ public int tintColor(int index) {
     // ********** GUI ***********//
     //////////////////////////////////////
 
+    // TODO add EIO widget
     @Override
-    public Widget createUIWidget() {
-        int rowSize = (int) Math.sqrt(inventorySize);
-        int colSize = rowSize;
-        if (inventorySize == 8) {
-            rowSize = 4;
-            colSize = 2;
-        }
-        var template = new WidgetGroup(0, 0, 18 * rowSize + 8, 18 * colSize + 8);
-        template.setBackground(GuiTextures.BACKGROUND_INVERSE);
-        int index = 0;
-        for (int y = 0; y < colSize; y++) {
-            for (int x = 0; x < rowSize; x++) {
-                template.addWidget(new SlotWidget(batteryInventory, index++, 4 + x * 18, 4 + y * 18, true, true)
-                        .setBackgroundTexture(new GuiTextureGroup(GuiTextures.SLOT, GuiTextures.BATTERY_OVERLAY)));
-            }
-        }
+    public void buildMainUI(ParentWidget<?> mainWidget, PosGuiData guiData, PanelSyncManager syncManager,
+                            UISettings settings) {
+        String[] matrix;
+        if (inventorySize == 8) matrix = new String[] { "BBBB", "BBBB" };
+        else matrix = GTMuiMachineUtil.createSquareMatrix(inventorySize, 'B');
+
+        DoubleSyncValue energyPercentage = syncManager.getOrCreateSyncHandler("energyPercentage", DoubleSyncValue.class,
+                () -> new DoubleSyncValue(this::getEnergyPercentage));
+
+        var flow = Flow.row().width(MachineUIPanel.DEFAULT_CONTENT_WIDTH).height(90);
+
+        flow.child(new ProgressWidget()
+                .texture(GTGuiTextures.PROGRESS_BAR_BOILER_EMPTY_STEEL,
+                        GTGuiTextures.PROGRESS_BAR_BOILER_HEAT, 60)
+                .direction(ProgressWidget.Direction.UP)
+                .value(energyPercentage)
+                .marginLeft(5)
+                .size(18, 60)
+                .addTooltipLine(IKey.dynamic(() -> Component.literal(
+                        "%s/%s EU".formatted(
+                                GTStringUtils.formatInt(energyContainer.getEnergyStored()),
+                                GTStringUtils.formatInt(energyContainer.getEnergyCapacity()))))))
+                .child(GTMuiMachineUtil.createSlotGroupFromInventory(
+                        batteryInventory, "batteries",
+                        inventorySize, 'B',
+                        slot -> slot.background(GTGuiTextures.SLOT, GTGuiTextures.CHARGER_OVERLAY),
+                        syncManager,
+                        matrix)
+                        .center());
+
+        mainWidget.child(flow);
+    }
 
-        var editableUI = createEnergyBar();
-        var energyBar = editableUI.createDefault();
-
-        var group = new WidgetGroup(0, 0,
-                Math.max(energyBar.getSize().width + template.getSize().width + 4 + 8, 172),
-                Math.max(template.getSize().height + 8, energyBar.getSize().height + 8));
-        var size = group.getSize();
-        energyBar.setSelfPosition(new Position(3, (size.height - energyBar.getSize().height) / 2));
-        template.setSelfPosition(new Position(
-                (size.width - energyBar.getSize().width - 4 - template.getSize().width) / 2 + 2 +
-                        energyBar.getSize().width + 2,
-                (size.height - template.getSize().height) / 2));
-        group.addWidget(energyBar);
-        group.addWidget(template);
-        editableUI.setupUI(group, this);
-        return group;
+    private double getEnergyPercentage() {
+        return (double) this.energyContainer.getEnergyStored() / this.energyContainer.getEnergyCapacity();
     }
 
     //////////////////////////////////////
@@ -189,8 +198,8 @@ public void onMachineDestroyed() {
     }
 
     @Override
-    public IGuiTexture getComponentIcon() {
-        return GuiTextures.BUTTON_CHECK; // temporary
+    public IDrawable getIcon() {
+        return GTGuiTextures.BATTERY_OVERLAY;
     }
 
     protected static class EnergyBatteryTrait extends NotifiableEnergyContainer {
@@ -265,7 +274,7 @@ public void serverTick() {
                 }
 
                 if (changed) {
-                    getMachine().markAsDirty();
+                    getMachine().markAsChanged();
                     checkOutputSubscription();
                 }
 
@@ -324,7 +333,7 @@ public long acceptEnergyFromNetwork(@Nullable Direction side, long voltage, long
                 }
 
                 if (changed) {
-                    getMachine().markAsDirty();
+                    getMachine().markAsChanged();
                     checkOutputSubscription();
                 }
 
diff --git a/src/main/java/com/gregtechceu/gtceu/common/machine/electric/BlockBreakerMachine.java b/src/main/java/com/gregtechceu/gtceu/common/machine/electric/BlockBreakerMachine.java
index 090fe634517..20a314d9bf7 100644
--- a/src/main/java/com/gregtechceu/gtceu/common/machine/electric/BlockBreakerMachine.java
+++ b/src/main/java/com/gregtechceu/gtceu/common/machine/electric/BlockBreakerMachine.java
@@ -5,31 +5,22 @@
 import com.gregtechceu.gtceu.api.capability.GTCapabilityHelper;
 import com.gregtechceu.gtceu.api.capability.IControllable;
 import com.gregtechceu.gtceu.api.capability.recipe.IO;
-import com.gregtechceu.gtceu.api.gui.GuiTextures;
-import com.gregtechceu.gtceu.api.gui.WidgetUtils;
-import com.gregtechceu.gtceu.api.gui.editor.EditableMachineUI;
-import com.gregtechceu.gtceu.api.gui.editor.EditableUI;
-import com.gregtechceu.gtceu.api.gui.widget.SlotWidget;
 import com.gregtechceu.gtceu.api.machine.TickableSubscription;
 import com.gregtechceu.gtceu.api.machine.TieredEnergyMachine;
-import com.gregtechceu.gtceu.api.machine.feature.IFancyUIMachine;
+import com.gregtechceu.gtceu.api.machine.feature.IHasBatterySlot;
+import com.gregtechceu.gtceu.api.machine.feature.IMuiMachine;
+import com.gregtechceu.gtceu.api.machine.mui.MachineUIPanel;
 import com.gregtechceu.gtceu.api.machine.trait.NotifiableItemStackHandler;
 import com.gregtechceu.gtceu.api.sync_system.annotations.SaveField;
 import com.gregtechceu.gtceu.api.sync_system.annotations.SyncToClient;
 import com.gregtechceu.gtceu.api.transfer.item.CustomItemStackHandler;
 import com.gregtechceu.gtceu.common.machine.trait.AutoOutputTrait;
+import com.gregtechceu.gtceu.common.mui.GTMuiMachineUtil;
 import com.gregtechceu.gtceu.config.ConfigHolder;
-import com.gregtechceu.gtceu.data.lang.LangHandler;
 import com.gregtechceu.gtceu.utils.ISubscription;
 
-import com.lowdragmc.lowdraglib.gui.widget.WidgetGroup;
-import com.lowdragmc.lowdraglib.utils.Position;
-
 import net.minecraft.MethodsReturnNonnullByDefault;
-import net.minecraft.Util;
 import net.minecraft.core.BlockPos;
-import net.minecraft.network.chat.MutableComponent;
-import net.minecraft.resources.ResourceLocation;
 import net.minecraft.server.TickTask;
 import net.minecraft.server.level.ServerLevel;
 import net.minecraft.world.item.ItemStack;
@@ -37,18 +28,22 @@
 import net.minecraftforge.api.distmarker.Dist;
 import net.minecraftforge.api.distmarker.OnlyIn;
 
+import brachy.modularui.factory.PosGuiData;
+import brachy.modularui.screen.UISettings;
+import brachy.modularui.value.sync.PanelSyncManager;
+import brachy.modularui.widget.ParentWidget;
+import brachy.modularui.widgets.layout.Flow;
 import lombok.Getter;
 import org.jetbrains.annotations.Nullable;
 
 import java.util.List;
-import java.util.function.BiFunction;
 
 import javax.annotation.ParametersAreNonnullByDefault;
 
 @ParametersAreNonnullByDefault
 @MethodsReturnNonnullByDefault
 public class BlockBreakerMachine extends TieredEnergyMachine
-                                 implements IFancyUIMachine, IControllable {
+                                 implements IMuiMachine, IControllable, IHasBatterySlot {
 
     @SaveField
     protected final NotifiableItemStackHandler cache;
@@ -272,77 +267,17 @@ public void setWorkingEnabled(boolean workingEnabled) {
     //////////////////////////////////////
     // ********** GUI ***********//
     //////////////////////////////////////
-    public static BiFunction<ResourceLocation, Integer, EditableMachineUI> EDITABLE_UI_CREATOR = Util
-            .memoize((path, inventorySize) -> new EditableMachineUI("misc", path, () -> {
-                var template = createTemplate(inventorySize).createDefault();
-                var energyBar = createEnergyBar().createDefault();
-                var batterySlot = createBatterySlot().createDefault();
-                var energyGroup = new WidgetGroup(0, 0, energyBar.getSize().width, energyBar.getSize().height + 20);
-                batterySlot.setSelfPosition(
-                        new Position((energyBar.getSize().width - 18) / 2, energyBar.getSize().height + 1));
-                energyGroup.addWidget(energyBar);
-                energyGroup.addWidget(batterySlot);
-                var group = new WidgetGroup(0, 0,
-                        Math.max(energyGroup.getSize().width + template.getSize().width + 4 + 8, 172),
-                        Math.max(template.getSize().height + 8, energyGroup.getSize().height + 8));
-                var size = group.getSize();
-                energyGroup.setSelfPosition(new Position(3, (size.height - energyGroup.getSize().height) / 2));
-
-                template.setSelfPosition(new Position(
-                        (size.width - 4 - template.getSize().width) / 2 + 4,
-                        (size.height - template.getSize().height) / 2));
-
-                group.addWidget(energyGroup);
-                group.addWidget(template);
-                return group;
-            }, (template, machine) -> {
-                if (machine instanceof BlockBreakerMachine blockBreakerMachine) {
-                    createTemplate(inventorySize).setupUI(template, blockBreakerMachine);
-                    createEnergyBar().setupUI(template, blockBreakerMachine);
-                    createBatterySlot().setupUI(template, blockBreakerMachine);
-                }
-            }));
-
-    protected static EditableUI<SlotWidget, BlockBreakerMachine> createBatterySlot() {
-        return new EditableUI<>("battery_slot", SlotWidget.class, () -> {
-            var slotWidget = new SlotWidget();
-            slotWidget.setBackground(GuiTextures.SLOT, GuiTextures.CHARGER_OVERLAY);
-            return slotWidget;
-        }, (slotWidget, machine) -> {
-            slotWidget.setHandlerSlot(machine.chargerInventory, 0);
-            slotWidget.setCanPutItems(true);
-            slotWidget.setCanTakeItems(true);
-            slotWidget.setHoverTooltips(LangHandler.getMultiLang("gtceu.gui.charger_slot.tooltip",
-                    GTValues.VNF[machine.getTier()], GTValues.VNF[machine.getTier()]).toArray(new MutableComponent[0]));
-        });
-    }
 
-    protected static EditableUI<WidgetGroup, BlockBreakerMachine> createTemplate(int inventorySize) {
-        return new EditableUI<>("functional_container", WidgetGroup.class, () -> {
-            int rowSize = (int) Math.sqrt(inventorySize);
-            WidgetGroup main = new WidgetGroup(0, 0, rowSize * 18 + 8, rowSize * 18 + 8);
-            for (int y = 0; y < rowSize; y++) {
-                for (int x = 0; x < rowSize; x++) {
-                    int index = y * rowSize + x;
-                    SlotWidget slotWidget = new SlotWidget();
-                    slotWidget.initTemplate();
-                    slotWidget.setSelfPosition(new Position(4 + x * 18, 4 + y * 18));
-                    slotWidget.setBackground(GuiTextures.SLOT);
-                    slotWidget.setId("slot_" + index);
-                    main.addWidget(slotWidget);
-                }
-            }
-            main.setBackground(GuiTextures.BACKGROUND_INVERSE);
-            return main;
-        }, (group, machine) -> {
-            WidgetUtils.widgetByIdForEach(group, "^slot_[0-9]+$", SlotWidget.class, slot -> {
-                var index = WidgetUtils.widgetIdIndex(slot);
-                if (index >= 0 && index < machine.cache.getSlots()) {
-                    slot.setHandlerSlot(machine.cache, index);
-                    slot.setCanTakeItems(true);
-                    slot.setCanPutItems(false);
-                }
-            });
-        });
+    // TODO: Needs EIO type side selection widget when that's done
+    @Override
+    public void buildMainUI(ParentWidget<?> mainWidget, PosGuiData guiData, PanelSyncManager syncManager,
+                            UISettings settings) {
+        var slotHeight = (int) Math.sqrt(inventorySize);
+        mainWidget
+                .child(Flow.col()
+                        .size(MachineUIPanel.DEFAULT_CONTENT_WIDTH, 18 * slotHeight)
+                        .margin(0, 10)
+                        .child(GTMuiMachineUtil.createSquareSlotGroupFromInventory(this.cache, "output_cache",
+                                syncManager)));
     }
 }
diff --git a/src/main/java/com/gregtechceu/gtceu/common/machine/electric/ChargerMachine.java b/src/main/java/com/gregtechceu/gtceu/common/machine/electric/ChargerMachine.java
index e7d0334edb4..4acebee6ac4 100644
--- a/src/main/java/com/gregtechceu/gtceu/common/machine/electric/ChargerMachine.java
+++ b/src/main/java/com/gregtechceu/gtceu/common/machine/electric/ChargerMachine.java
@@ -4,42 +4,51 @@
 import com.gregtechceu.gtceu.api.blockentity.BlockEntityCreationInfo;
 import com.gregtechceu.gtceu.api.capability.*;
 import com.gregtechceu.gtceu.api.capability.compat.FeCompat;
-import com.gregtechceu.gtceu.api.gui.GuiTextures;
-import com.gregtechceu.gtceu.api.gui.widget.SlotWidget;
 import com.gregtechceu.gtceu.api.machine.TieredEnergyMachine;
-import com.gregtechceu.gtceu.api.machine.feature.IFancyUIMachine;
+import com.gregtechceu.gtceu.api.machine.feature.IMuiMachine;
+import com.gregtechceu.gtceu.api.machine.mui.MachineUIPanel;
 import com.gregtechceu.gtceu.api.machine.property.GTMachineModelProperties;
 import com.gregtechceu.gtceu.api.machine.trait.NotifiableEnergyContainer;
 import com.gregtechceu.gtceu.api.sync_system.annotations.RerenderOnChanged;
 import com.gregtechceu.gtceu.api.sync_system.annotations.SaveField;
 import com.gregtechceu.gtceu.api.sync_system.annotations.SyncToClient;
 import com.gregtechceu.gtceu.api.transfer.item.CustomItemStackHandler;
+import com.gregtechceu.gtceu.common.mui.GTGuiTextures;
+import com.gregtechceu.gtceu.common.mui.GTMuiMachineUtil;
 import com.gregtechceu.gtceu.config.ConfigHolder;
+import com.gregtechceu.gtceu.utils.GTStringUtils;
 import com.gregtechceu.gtceu.utils.GTUtil;
 
-import com.lowdragmc.lowdraglib.gui.texture.GuiTextureGroup;
-import com.lowdragmc.lowdraglib.gui.widget.Widget;
-import com.lowdragmc.lowdraglib.gui.widget.WidgetGroup;
-import com.lowdragmc.lowdraglib.utils.Position;
-
 import net.minecraft.MethodsReturnNonnullByDefault;
 import net.minecraft.core.Direction;
+import net.minecraft.network.chat.Component;
 import net.minecraft.util.StringRepresentable;
+import net.minecraft.world.item.ItemStack;
 import net.minecraft.world.level.block.state.properties.EnumProperty;
 import net.minecraftforge.energy.IEnergyStorage;
 
+import brachy.modularui.api.drawable.IKey;
+import brachy.modularui.factory.PosGuiData;
+import brachy.modularui.screen.UISettings;
+import brachy.modularui.value.sync.DoubleSyncValue;
+import brachy.modularui.value.sync.PanelSyncManager;
+import brachy.modularui.widget.ParentWidget;
+import brachy.modularui.widgets.ProgressWidget;
+import brachy.modularui.widgets.layout.Flow;
 import lombok.Getter;
 import lombok.Setter;
 import org.jetbrains.annotations.Nullable;
 
 import java.util.ArrayList;
+import java.util.HashSet;
 import java.util.List;
+import java.util.Set;
 
 import javax.annotation.ParametersAreNonnullByDefault;
 
 @ParametersAreNonnullByDefault
 @MethodsReturnNonnullByDefault
-public class ChargerMachine extends TieredEnergyMachine implements IControllable, IFancyUIMachine {
+public class ChargerMachine extends TieredEnergyMachine implements IControllable, IMuiMachine {
 
     public static final long AMPS_PER_ITEM = 4L;
 
@@ -68,6 +77,8 @@ public enum State implements StringRepresentable {
     @Getter
     @SaveField
     protected final CustomItemStackHandler chargerInventory;
+    @Getter
+    protected final Set<ItemStack> linkedItems = new HashSet<>();
 
     @Getter
     @SyncToClient
@@ -119,39 +130,41 @@ public void onMachineDestroyed() {
     //////////////////////////////////////
 
     @Override
-    public Widget createUIWidget() {
-        int rowSize = (int) Math.sqrt(inventorySize);
-        int colSize = rowSize;
-        if (inventorySize == 8) {
-            rowSize = 4;
-            colSize = 2;
-        }
-        var template = new WidgetGroup(0, 0, 18 * rowSize + 8, 18 * colSize + 8);
-        template.setBackground(GuiTextures.BACKGROUND_INVERSE);
-        int index = 0;
-        for (int y = 0; y < colSize; y++) {
-            for (int x = 0; x < rowSize; x++) {
-                template.addWidget(new SlotWidget(chargerInventory, index++, 4 + x * 18, 4 + y * 18, true, true)
-                        .setBackgroundTexture(new GuiTextureGroup(GuiTextures.SLOT, GuiTextures.CHARGER_OVERLAY)));
-            }
-        }
+    public void buildMainUI(ParentWidget<?> mainWidget, PosGuiData guiData, PanelSyncManager syncManager,
+                            UISettings settings) {
+        String[] matrix;
+        if (inventorySize == 8) matrix = new String[] { "BBBB", "BBBB" };
+        else matrix = GTMuiMachineUtil.createSquareMatrix(inventorySize, 'B');
+
+        DoubleSyncValue energyPercentage = syncManager.getOrCreateSyncHandler("energyPercentage", DoubleSyncValue.class,
+                () -> new DoubleSyncValue(this::getEnergyPercentage));
+
+        var flow = Flow.row().width(MachineUIPanel.DEFAULT_CONTENT_WIDTH).height(90);
+
+        flow.child(new ProgressWidget()
+                .texture(GTGuiTextures.PROGRESS_BAR_BOILER_EMPTY_STEEL,
+                        GTGuiTextures.PROGRESS_BAR_BOILER_HEAT, 60)
+                .direction(ProgressWidget.Direction.UP)
+                .value(energyPercentage)
+                .marginLeft(5)
+                .size(18, 60)
+                .addTooltipLine(IKey.dynamic(() -> Component.literal(
+                        "%s/%s EU".formatted(
+                                GTStringUtils.formatInt(energyContainer.getEnergyStored()),
+                                GTStringUtils.formatInt(energyContainer.getEnergyCapacity()))))))
+                .child(GTMuiMachineUtil.createSlotGroupFromInventory(
+                        chargerInventory, "batteries",
+                        inventorySize, 'B',
+                        slot -> slot.background(GTGuiTextures.SLOT, GTGuiTextures.CHARGER_OVERLAY),
+                        syncManager,
+                        matrix)
+                        .center());
+
+        mainWidget.child(flow);
+    }
 
-        var editableUI = createEnergyBar();
-        var energyBar = editableUI.createDefault();
-
-        var group = new WidgetGroup(0, 0,
-                Math.max(energyBar.getSize().width + template.getSize().width + 4 + 8, 172),
-                Math.max(template.getSize().height + 8, energyBar.getSize().height + 8));
-        var size = group.getSize();
-        energyBar.setSelfPosition(new Position(3, (size.height - energyBar.getSize().height) / 2));
-        template.setSelfPosition(new Position(
-                (size.width - energyBar.getSize().width - 4 - template.getSize().width) / 2 + 2 +
-                        energyBar.getSize().width + 2,
-                (size.height - template.getSize().height) / 2));
-        group.addWidget(energyBar);
-        group.addWidget(template);
-        editableUI.setupUI(group, this);
-        return group;
+    private double getEnergyPercentage() {
+        return (double) this.energyContainer.getEnergyStored() / this.energyContainer.getEnergyCapacity();
     }
 
     //////////////////////////////////////
@@ -176,6 +189,22 @@ private List<Object> getNonFullElectricItem() {
                 }
             }
         }
+        for (ItemStack electricItemStack : linkedItems) {
+            var electricItem = GTCapabilityHelper.getElectricItem(electricItemStack);
+            if (electricItem != null) {
+                if (electricItem.getCharge() < electricItem.getMaxCharge()) {
+                    electricItems.add(electricItem);
+                }
+            } else if (ConfigHolder.INSTANCE.compat.energy.nativeEUToFE) {
+                var energyStorage = GTCapabilityHelper.getForgeEnergyItem(electricItemStack);
+                if (energyStorage != null) {
+                    if (energyStorage.getEnergyStored() < energyStorage.getMaxEnergyStored()) {
+                        electricItems.add(energyStorage);
+                    }
+                }
+            }
+        }
+        linkedItems.clear();
         return electricItems;
     }
 
@@ -253,7 +282,7 @@ public long acceptEnergyFromNetwork(@Nullable Direction side, long voltage, long
                 }
 
                 if (changed) {
-                    getMachine().markAsDirty();
+                    getMachine().markAsChanged();
                     getMachine().changeState(State.RUNNING);
                 }
 
@@ -280,6 +309,18 @@ public long getEnergyCapacity() {
                     }
                 }
             }
+            for (ItemStack electricItemStack : getMachine().linkedItems) {
+                var electricItem = GTCapabilityHelper.getElectricItem(electricItemStack);
+                if (electricItem != null) {
+                    energyCapacity += electricItem.getMaxCharge();
+                } else if (ConfigHolder.INSTANCE.compat.energy.nativeEUToFE) {
+                    var energyStorage = GTCapabilityHelper.getForgeEnergyItem(electricItemStack);
+                    if (energyStorage != null) {
+                        energyCapacity += FeCompat.toEu(energyStorage.getMaxEnergyStored(),
+                                FeCompat.ratio(false));
+                    }
+                }
+            }
 
             if (energyCapacity == 0) {
                 getMachine().changeState(State.IDLE);
@@ -304,6 +345,18 @@ public long getEnergyStored() {
                     }
                 }
             }
+            for (ItemStack electricItemStack : getMachine().linkedItems) {
+                var electricItem = GTCapabilityHelper.getElectricItem(electricItemStack);
+                if (electricItem != null) {
+                    energyStored += electricItem.getCharge();
+                } else if (ConfigHolder.INSTANCE.compat.energy.nativeEUToFE) {
+                    var energyStorage = GTCapabilityHelper.getForgeEnergyItem(electricItemStack);
+                    if (energyStorage != null) {
+                        energyStored += FeCompat.toEu(energyStorage.getEnergyStored(),
+                                FeCompat.ratio(false));
+                    }
+                }
+            }
 
             var capacity = getEnergyCapacity();
 
diff --git a/src/main/java/com/gregtechceu/gtceu/common/machine/electric/ConverterMachine.java b/src/main/java/com/gregtechceu/gtceu/common/machine/electric/ConverterMachine.java
index c694d2048e7..e50d7a9157d 100644
--- a/src/main/java/com/gregtechceu/gtceu/common/machine/electric/ConverterMachine.java
+++ b/src/main/java/com/gregtechceu/gtceu/common/machine/electric/ConverterMachine.java
@@ -3,15 +3,13 @@
 import com.gregtechceu.gtceu.api.GTValues;
 import com.gregtechceu.gtceu.api.blockentity.BlockEntityCreationInfo;
 import com.gregtechceu.gtceu.api.capability.compat.FeCompat;
-import com.gregtechceu.gtceu.api.gui.GuiTextures;
 import com.gregtechceu.gtceu.api.item.tool.GTToolType;
 import com.gregtechceu.gtceu.api.machine.TieredEnergyMachine;
 import com.gregtechceu.gtceu.api.machine.property.GTMachineModelProperties;
 import com.gregtechceu.gtceu.common.machine.trait.ConverterTrait;
+import com.gregtechceu.gtceu.common.mui.GTGuiTextures;
 import com.gregtechceu.gtceu.utils.ExtendedUseOnContext;
 
-import com.lowdragmc.lowdraglib.gui.texture.ResourceTexture;
-
 import net.minecraft.MethodsReturnNonnullByDefault;
 import net.minecraft.core.BlockPos;
 import net.minecraft.core.Direction;
@@ -21,6 +19,7 @@
 import net.minecraft.world.level.block.state.BlockState;
 import net.minecraft.world.level.block.state.properties.BooleanProperty;
 
+import brachy.modularui.drawable.UITexture;
 import org.jetbrains.annotations.Nullable;
 
 import java.util.Set;
@@ -94,10 +93,11 @@ public boolean isFacingValid(Direction facing) {
     }
 
     @Override
-    public @Nullable ResourceTexture sideTips(Player player, BlockPos pos, BlockState state, Set<GTToolType> toolTypes,
-                                              Direction side) {
+    public @Nullable UITexture sideTips(Player player, BlockPos pos, BlockState state, Set<GTToolType> toolTypes,
+                                        Direction side) {
         if (toolTypes.contains(GTToolType.SOFT_MALLET)) {
-            return this.isFeToEu() ? GuiTextures.TOOL_SWITCH_CONVERTER_NATIVE : GuiTextures.TOOL_SWITCH_CONVERTER_EU;
+            return this.isFeToEu() ? GTGuiTextures.TOOL_SWITCH_CONVERTER_NATIVE :
+                    GTGuiTextures.TOOL_SWITCH_CONVERTER_EU;
         }
         return super.sideTips(player, pos, state, toolTypes, side);
     }
diff --git a/src/main/java/com/gregtechceu/gtceu/common/machine/electric/FisherMachine.java b/src/main/java/com/gregtechceu/gtceu/common/machine/electric/FisherMachine.java
index f949a63cb72..9d3ab527598 100644
--- a/src/main/java/com/gregtechceu/gtceu/common/machine/electric/FisherMachine.java
+++ b/src/main/java/com/gregtechceu/gtceu/common/machine/electric/FisherMachine.java
@@ -5,34 +5,25 @@
 import com.gregtechceu.gtceu.api.capability.GTCapabilityHelper;
 import com.gregtechceu.gtceu.api.capability.IWorkable;
 import com.gregtechceu.gtceu.api.capability.recipe.IO;
-import com.gregtechceu.gtceu.api.gui.GuiTextures;
-import com.gregtechceu.gtceu.api.gui.WidgetUtils;
-import com.gregtechceu.gtceu.api.gui.editor.EditableMachineUI;
-import com.gregtechceu.gtceu.api.gui.editor.EditableUI;
-import com.gregtechceu.gtceu.api.gui.widget.SlotWidget;
-import com.gregtechceu.gtceu.api.gui.widget.ToggleButtonWidget;
 import com.gregtechceu.gtceu.api.machine.TickableSubscription;
 import com.gregtechceu.gtceu.api.machine.TieredEnergyMachine;
-import com.gregtechceu.gtceu.api.machine.feature.IFancyUIMachine;
+import com.gregtechceu.gtceu.api.machine.feature.IMuiMachine;
+import com.gregtechceu.gtceu.api.machine.mui.MachineUIPanelBuilder;
 import com.gregtechceu.gtceu.api.machine.trait.NotifiableItemStackHandler;
 import com.gregtechceu.gtceu.api.sync_system.annotations.SaveField;
 import com.gregtechceu.gtceu.api.sync_system.annotations.SyncToClient;
 import com.gregtechceu.gtceu.api.transfer.item.CustomItemStackHandler;
 import com.gregtechceu.gtceu.common.machine.trait.AutoOutputTrait;
+import com.gregtechceu.gtceu.common.mui.GTGuiTextures;
+import com.gregtechceu.gtceu.common.mui.GTMuiMachineUtil;
+import com.gregtechceu.gtceu.common.mui.GTMuiWidgets;
 import com.gregtechceu.gtceu.config.ConfigHolder;
 import com.gregtechceu.gtceu.data.lang.LangHandler;
 import com.gregtechceu.gtceu.utils.ISubscription;
 
-import com.lowdragmc.lowdraglib.gui.texture.ItemStackTexture;
-import com.lowdragmc.lowdraglib.gui.widget.WidgetGroup;
-import com.lowdragmc.lowdraglib.utils.Position;
-
 import net.minecraft.MethodsReturnNonnullByDefault;
-import net.minecraft.Util;
 import net.minecraft.core.BlockPos;
 import net.minecraft.core.NonNullList;
-import net.minecraft.network.chat.MutableComponent;
-import net.minecraft.resources.ResourceLocation;
 import net.minecraft.server.level.ServerLevel;
 import net.minecraft.world.entity.EntityType;
 import net.minecraft.world.entity.projectile.FishingHook;
@@ -46,18 +37,29 @@
 import net.minecraft.world.level.storage.loot.parameters.LootContextParams;
 import net.minecraft.world.phys.Vec3;
 
+import brachy.modularui.drawable.ItemDrawable;
+import brachy.modularui.factory.PosGuiData;
+import brachy.modularui.screen.UISettings;
+import brachy.modularui.utils.Alignment;
+import brachy.modularui.value.BoolValue;
+import brachy.modularui.value.sync.DoubleSyncValue;
+import brachy.modularui.value.sync.PanelSyncManager;
+import brachy.modularui.widget.ParentWidget;
+import brachy.modularui.widgets.ProgressWidget;
+import brachy.modularui.widgets.ToggleButton;
+import brachy.modularui.widgets.layout.Flow;
+import brachy.modularui.widgets.slot.ItemSlot;
+import brachy.modularui.widgets.slot.ModularSlot;
 import lombok.Getter;
 import lombok.Setter;
 import org.jetbrains.annotations.Nullable;
 
-import java.util.function.BiFunction;
-
 import javax.annotation.ParametersAreNonnullByDefault;
 
 @ParametersAreNonnullByDefault
 @MethodsReturnNonnullByDefault
 public class FisherMachine extends TieredEnergyMachine
-                           implements IFancyUIMachine, IWorkable {
+                           implements IMuiMachine, IWorkable {
 
     @SaveField
     protected final NotifiableItemStackHandler cache;
@@ -282,111 +284,43 @@ protected void chargeBattery() {
     // ********** GUI ***********//
     //////////////////////////////////////
 
-    public static BiFunction<ResourceLocation, Integer, EditableMachineUI> EDITABLE_UI_CREATOR = Util
-            .memoize((path, inventorySize) -> new EditableMachineUI("misc", path, () -> {
-                var template = createTemplate(inventorySize).createDefault();
-                var energyBar = createEnergyBar().createDefault();
-                var batterySlot = createBatterySlot().createDefault();
-                var energyGroup = new WidgetGroup(0, 0, energyBar.getSize().width, energyBar.getSize().height + 20);
-                batterySlot.setSelfPosition(
-                        new Position((energyBar.getSize().width - 18) / 2, energyBar.getSize().height + 1));
-                energyGroup.addWidget(energyBar);
-                energyGroup.addWidget(batterySlot);
-                var group = new WidgetGroup(0, 0,
-                        Math.max(energyGroup.getSize().width + template.getSize().width + 4 + 8, 172),
-                        Math.max(template.getSize().height + 8, energyGroup.getSize().height + 8));
-                var size = group.getSize();
-                energyGroup.setSelfPosition(new Position(3, (size.height - energyGroup.getSize().height) / 2));
-
-                template.setSelfPosition(new Position(
-                        (size.width - energyGroup.getSize().width - 4 - template.getSize().width) / 2 + 2 +
-                                energyGroup.getSize().width + 2,
-                        (size.height - template.getSize().height) / 2));
-
-                group.addWidget(energyGroup);
-                group.addWidget(template);
-                return group;
-            }, (template, machine) -> {
-                if (machine instanceof FisherMachine fisherMachine) {
-                    createTemplate(inventorySize).setupUI(template, fisherMachine);
-                    createEnergyBar().setupUI(template, fisherMachine);
-                    createBatterySlot().setupUI(template, fisherMachine);
-                    createJunkButton().setupUI(template, fisherMachine);
-                }
-            }));
-
-    protected static EditableUI<SlotWidget, FisherMachine> createBatterySlot() {
-        return new EditableUI<>("battery_slot", SlotWidget.class, () -> {
-            var slotWidget = new SlotWidget();
-            slotWidget.setBackground(GuiTextures.SLOT, GuiTextures.CHARGER_OVERLAY);
-            return slotWidget;
-        }, (slotWidget, machine) -> {
-            slotWidget.setHandlerSlot(machine.chargerInventory, 0);
-            slotWidget.setCanPutItems(true);
-            slotWidget.setCanTakeItems(true);
-            slotWidget.setHoverTooltips(LangHandler.getMultiLang("gtceu.gui.charger_slot.tooltip",
-                    GTValues.VNF[machine.getTier()], GTValues.VNF[machine.getTier()]).toArray(new MutableComponent[0]));
-        });
-    }
-
-    protected static EditableUI<ToggleButtonWidget, FisherMachine> createJunkButton() {
-        return new EditableUI<>("junk_button", ToggleButtonWidget.class, () -> {
-            var toggleButtonWidget = new ToggleButtonWidget(10, 20, 18, 18,
-                    new ItemStackTexture(Items.NAME_TAG).scale(0.9F), () -> false, b -> {});
-            toggleButtonWidget.setShouldUseBaseBackground();
-            return toggleButtonWidget;
-        }, (toggleButtonWidget, machine) -> {
-            toggleButtonWidget.setSupplier(machine::isJunkEnabled);
-            toggleButtonWidget.setOnPressCallback((data, bool) -> machine.setJunkEnabled(bool));
-            toggleButtonWidget.setHoverTooltips(LangHandler.getMultiLang("gtceu.gui.fisher_mode.tooltip",
-                    GTValues.VNF[machine.getTier()], GTValues.VNF[machine.getTier()]).toArray(new MutableComponent[0]));
-        });
+    @Override
+    public MachineUIPanelBuilder getPanelBuilder(PosGuiData data, PanelSyncManager syncManager, UISettings settings) {
+        return MachineUIPanelBuilder.defaultPanelBuilder(this)
+                .rightConfigurators(configuratorFlow -> configuratorFlow
+                        .child(new ToggleButton()
+                                .value(new BoolValue.Dynamic(this::isJunkEnabled, this::setJunkEnabled))
+                                .overlay(new ItemDrawable(Items.NAME_TAG))
+                                .tooltipAutoUpdate(true)
+                                .tooltipBuilder((r) -> {
+                                    var lines = LangHandler.getMultiLang("gtceu.gui.fisher_mode.tooltip",
+                                            GTValues.VNF[getTier()], GTValues.VNF[getTier()]);
+                                    for (var line : lines) {
+                                        r.addLine(line);
+                                    }
+                                })));
     }
 
-    protected static EditableUI<WidgetGroup, FisherMachine> createTemplate(int inventorySize) {
-        return new EditableUI<>("functional_container", WidgetGroup.class, () -> {
-            int rowSize = (int) Math.sqrt(inventorySize);
-            WidgetGroup main = new WidgetGroup(0, 0, rowSize * 18 + 8 + 20, rowSize * 18 + 8);
-
-            for (int y = 0; y < rowSize; y++) {
-                for (int x = 0; x < rowSize; x++) {
-                    int index = y * rowSize + x;
-                    SlotWidget slotWidget = new SlotWidget();
-                    slotWidget.initTemplate();
-                    slotWidget.setSelfPosition(new Position(24 + x * 18, 4 + y * 18));
-                    slotWidget.setBackground(GuiTextures.SLOT);
-                    slotWidget.setId("slot_" + index);
-                    main.addWidget(slotWidget);
-                }
-            }
-
-            SlotWidget baitSlotWidget = new SlotWidget();
-            baitSlotWidget.initTemplate();
-            baitSlotWidget
-                    .setSelfPosition(new Position(4, (main.getSize().height - baitSlotWidget.getSize().height) / 2));
-            baitSlotWidget.setBackground(GuiTextures.SLOT, GuiTextures.STRING_SLOT_OVERLAY);
-            baitSlotWidget.setId("bait_slot");
-            main.addWidget(baitSlotWidget);
-            var junkButton = createJunkButton().createDefault();
-            junkButton.setSelfPosition(new Position(4, (main.getSize().height - junkButton.getSize().height) - 4));
-            junkButton.setId("junk_button");
-            main.addWidget(junkButton);
-            main.setBackground(GuiTextures.BACKGROUND_INVERSE);
-            return main;
-        }, (group, machine) -> {
-            WidgetUtils.widgetByIdForEach(group, "^slot_[0-9]+$", SlotWidget.class, slot -> {
-                var index = WidgetUtils.widgetIdIndex(slot);
-                if (index >= 0 && index < machine.cache.getSlots()) {
-                    slot.setHandlerSlot(machine.cache, index);
-                    slot.setCanTakeItems(true);
-                    slot.setCanPutItems(false);
-                }
-            });
-            WidgetUtils.widgetByIdForEach(group, "^bait_slot$", SlotWidget.class, slot -> {
-                slot.setHandlerSlot(machine.baitHandler.storage, 0);
-                slot.setCanTakeItems(true);
-                slot.setCanPutItems(true);
-            });
-        });
+    @Override
+    public void buildMainUI(ParentWidget<?> mainWidget, PosGuiData guiData, PanelSyncManager syncManager,
+                            UISettings settings) {
+        var outputItemGrid = GTMuiWidgets.createGrid(cache.getSize(), (int) Math.sqrt(cache.getSize()), true, 'i');
+
+        DoubleSyncValue progressPercent = syncManager.getOrCreateSyncHandler("progressPercent", DoubleSyncValue.class,
+                () -> new DoubleSyncValue(() -> progress / (double) maxProgress));
+
+        mainWidget.child(Flow.row()
+                .coverChildren()
+                .center()
+                .margin(0, 15)
+                .crossAxisAlignment(Alignment.CrossAxis.CENTER)
+                .child(new ItemSlot().slot(new ModularSlot(baitHandler, 0))
+                        .background(GTGuiTextures.SLOT, GTGuiTextures.STRING_SLOT_OVERLAY).marginRight(2))
+                .child(new ProgressWidget()
+                        .texture(GTGuiTextures.PROGRESS_BAR_ARROW, 16)
+                        .value(progressPercent))
+                .child(GTMuiMachineUtil.createSlotGroupFromInventory(cache,
+                        "output_item_inv", cache.getSize(), 'i',
+                        syncManager, outputItemGrid).marginLeft(2)));
     }
 }
diff --git a/src/main/java/com/gregtechceu/gtceu/common/machine/electric/HullMachine.java b/src/main/java/com/gregtechceu/gtceu/common/machine/electric/HullMachine.java
index 1cd99cd3cfe..e291effaf1b 100644
--- a/src/main/java/com/gregtechceu/gtceu/common/machine/electric/HullMachine.java
+++ b/src/main/java/com/gregtechceu/gtceu/common/machine/electric/HullMachine.java
@@ -4,7 +4,6 @@
 import com.gregtechceu.gtceu.api.GTValues;
 import com.gregtechceu.gtceu.api.blockentity.BlockEntityCreationInfo;
 import com.gregtechceu.gtceu.api.capability.IMonitorComponent;
-import com.gregtechceu.gtceu.api.gui.GuiTextures;
 import com.gregtechceu.gtceu.api.machine.multiblock.part.TieredPartMachine;
 import com.gregtechceu.gtceu.api.machine.trait.NotifiableEnergyContainer;
 import com.gregtechceu.gtceu.api.sync_system.ClassSyncData;
@@ -12,8 +11,6 @@
 import com.gregtechceu.gtceu.api.sync_system.data_transformers.ValueTransformer;
 import com.gregtechceu.gtceu.integration.ae2.machine.trait.GridNodeHostTrait;
 
-import com.lowdragmc.lowdraglib.gui.texture.IGuiTexture;
-
 import net.minecraft.MethodsReturnNonnullByDefault;
 import net.minecraft.core.Direction;
 import net.minecraft.nbt.CompoundTag;
@@ -21,6 +18,8 @@
 import net.minecraft.server.TickTask;
 import net.minecraft.server.level.ServerLevel;
 
+import brachy.modularui.api.drawable.IDrawable;
+import brachy.modularui.drawable.GuiTextures;
 import org.jetbrains.annotations.Nullable;
 
 import javax.annotation.ParametersAreNonnullByDefault;
@@ -119,7 +118,7 @@ public int tintColor(int index) {
     }
 
     @Override
-    public IGuiTexture getComponentIcon() {
-        return GuiTextures.BUTTON_CHECK; // temporary (until there's a texture that is not fully 16x16 for this)
+    public IDrawable getIcon() {
+        return GuiTextures.CROSS;
     }
 }
diff --git a/src/main/java/com/gregtechceu/gtceu/common/machine/electric/ItemCollectorMachine.java b/src/main/java/com/gregtechceu/gtceu/common/machine/electric/ItemCollectorMachine.java
index 1249ebb53f0..9611069ff22 100644
--- a/src/main/java/com/gregtechceu/gtceu/common/machine/electric/ItemCollectorMachine.java
+++ b/src/main/java/com/gregtechceu/gtceu/common/machine/electric/ItemCollectorMachine.java
@@ -1,20 +1,14 @@
 package com.gregtechceu.gtceu.common.machine.electric;
 
-import com.gregtechceu.gtceu.api.GTValues;
 import com.gregtechceu.gtceu.api.blockentity.BlockEntityCreationInfo;
 import com.gregtechceu.gtceu.api.capability.GTCapabilityHelper;
 import com.gregtechceu.gtceu.api.capability.IWorkable;
 import com.gregtechceu.gtceu.api.capability.recipe.IO;
 import com.gregtechceu.gtceu.api.cover.filter.ItemFilter;
-import com.gregtechceu.gtceu.api.gui.GuiTextures;
-import com.gregtechceu.gtceu.api.gui.WidgetUtils;
-import com.gregtechceu.gtceu.api.gui.editor.EditableMachineUI;
-import com.gregtechceu.gtceu.api.gui.editor.EditableUI;
-import com.gregtechceu.gtceu.api.gui.widget.IntInputWidget;
-import com.gregtechceu.gtceu.api.gui.widget.SlotWidget;
 import com.gregtechceu.gtceu.api.machine.TickableSubscription;
 import com.gregtechceu.gtceu.api.machine.TieredEnergyMachine;
-import com.gregtechceu.gtceu.api.machine.feature.IFancyUIMachine;
+import com.gregtechceu.gtceu.api.machine.feature.IMuiMachine;
+import com.gregtechceu.gtceu.api.machine.mui.MachineUIPanel;
 import com.gregtechceu.gtceu.api.machine.property.GTMachineModelProperties;
 import com.gregtechceu.gtceu.api.machine.trait.NotifiableItemStackHandler;
 import com.gregtechceu.gtceu.api.sync_system.annotations.RerenderOnChanged;
@@ -23,18 +17,13 @@
 import com.gregtechceu.gtceu.api.transfer.item.CustomItemStackHandler;
 import com.gregtechceu.gtceu.common.data.GTItems;
 import com.gregtechceu.gtceu.common.machine.trait.AutoOutputTrait;
+import com.gregtechceu.gtceu.common.mui.GTGuiTextures;
+import com.gregtechceu.gtceu.common.mui.GTMuiMachineUtil;
 import com.gregtechceu.gtceu.config.ConfigHolder;
-import com.gregtechceu.gtceu.data.lang.LangHandler;
 import com.gregtechceu.gtceu.utils.ISubscription;
 
-import com.lowdragmc.lowdraglib.gui.widget.WidgetGroup;
-import com.lowdragmc.lowdraglib.utils.Position;
-
 import net.minecraft.MethodsReturnNonnullByDefault;
-import net.minecraft.Util;
 import net.minecraft.core.BlockPos;
-import net.minecraft.network.chat.MutableComponent;
-import net.minecraft.resources.ResourceLocation;
 import net.minecraft.server.TickTask;
 import net.minecraft.server.level.ServerLevel;
 import net.minecraft.util.Mth;
@@ -44,18 +33,28 @@
 import net.minecraft.world.phys.AABB;
 import net.minecraft.world.phys.Vec3;
 
+import brachy.modularui.api.drawable.IKey;
+import brachy.modularui.factory.PosGuiData;
+import brachy.modularui.screen.UISettings;
+import brachy.modularui.utils.Alignment;
+import brachy.modularui.value.sync.PanelSyncManager;
+import brachy.modularui.value.sync.SyncHandlers;
+import brachy.modularui.widget.ParentWidget;
+import brachy.modularui.widgets.TextWidget;
+import brachy.modularui.widgets.layout.Flow;
+import brachy.modularui.widgets.slot.ItemSlot;
+import brachy.modularui.widgets.textfield.TextFieldWidget;
 import lombok.Getter;
 import org.jetbrains.annotations.Nullable;
 
 import java.util.List;
-import java.util.function.BiFunction;
 
 import javax.annotation.ParametersAreNonnullByDefault;
 
 @ParametersAreNonnullByDefault
 @MethodsReturnNonnullByDefault
 public class ItemCollectorMachine extends TieredEnergyMachine
-                                  implements IFancyUIMachine, IWorkable {
+                                  implements IMuiMachine, IWorkable {
 
     @Getter
     private static final int[] INVENTORY_SIZES = { 4, 9, 16, 25, 25 };
@@ -307,102 +306,33 @@ public void setWorkingEnabled(boolean workingEnabled) {
     }
 
     //////////////////////////////////////
-    // ********** GUI ***********//
+    // ******* GUI ********//
     //////////////////////////////////////
-
-    public static BiFunction<ResourceLocation, Integer, EditableMachineUI> EDITABLE_UI_CREATOR = Util
-            .memoize((path, inventorySize) -> new EditableMachineUI("misc", path, () -> {
-                var template = createTemplate(inventorySize).createDefault();
-                var energyBar = createEnergyBar().createDefault();
-                var batterySlot = createBatterySlot().createDefault();
-
-                var energyGroup = new WidgetGroup(0, 0, energyBar.getSize().width, energyBar.getSize().height + 20);
-                batterySlot.setSelfPosition(
-                        new Position((energyBar.getSize().width - 18) / 2, energyBar.getSize().height + 1));
-                energyGroup.addWidget(energyBar);
-                energyGroup.addWidget(batterySlot);
-                var group = new WidgetGroup(0, 0,
-                        Math.max(energyGroup.getSize().width + template.getSize().width + 4 + 8, 172),
-                        Math.max(template.getSize().height + 8 + 30, energyGroup.getSize().height + 8));
-                var size = group.getSize();
-                energyGroup.setSelfPosition(new Position(3, (size.height - energyGroup.getSize().height) / 2));
-
-                template.setSelfPosition(new Position(
-                        (size.width - energyGroup.getSize().width - 4 - template.getSize().width) / 2 + 2 +
-                                energyGroup.getSize().width + 2,
-                        (size.height - template.getSize().height) / 2 + 15));
-
-                group.addWidget(energyGroup);
-                group.addWidget(template);
-                return group;
-            }, (template, machine) -> {
-                if (machine instanceof ItemCollectorMachine itemCollectorMachine) {
-                    createTemplate(inventorySize).setupUI(template, itemCollectorMachine);
-                    createEnergyBar().setupUI(template, itemCollectorMachine);
-                    createBatterySlot().setupUI(template, itemCollectorMachine);
-                    var rangeSelector = new IntInputWidget((template.getSize().width - 80) / 2, 5, 80, 20,
-                            itemCollectorMachine::getRange, itemCollectorMachine::setRange);
-                    rangeSelector.setMin(1);
-                    rangeSelector.setMax(itemCollectorMachine.maxRange);
-                    template.addWidget(rangeSelector);
-                }
-            }));
-
-    protected static EditableUI<SlotWidget, ItemCollectorMachine> createBatterySlot() {
-        return new EditableUI<>("battery_slot", SlotWidget.class, () -> {
-            var slotWidget = new SlotWidget();
-            slotWidget.setBackground(GuiTextures.SLOT, GuiTextures.CHARGER_OVERLAY);
-            return slotWidget;
-        }, (slotWidget, machine) -> {
-            slotWidget.setHandlerSlot(machine.chargerInventory, 0);
-            slotWidget.setCanPutItems(true);
-            slotWidget.setCanTakeItems(true);
-            slotWidget.setHoverTooltips(LangHandler.getMultiLang("gtceu.gui.charger_slot.tooltip",
-                    GTValues.VNF[machine.getTier()], GTValues.VNF[machine.getTier()]).toArray(new MutableComponent[0]));
-        });
-    }
-
-    protected static EditableUI<WidgetGroup, ItemCollectorMachine> createTemplate(int inventorySize) {
-        return new EditableUI<>("functional_container", WidgetGroup.class, () -> {
-            int rowSize = (int) Math.sqrt(inventorySize);
-            WidgetGroup main = new WidgetGroup(0, 0, rowSize * 18 + 8 + 25, rowSize * 18 + 8);
-
-            for (int y = 0; y < rowSize; y++) {
-                for (int x = 0; x < rowSize; x++) {
-                    int index = y * rowSize + x;
-                    SlotWidget slotWidget = new SlotWidget();
-                    slotWidget.initTemplate();
-                    slotWidget.setSelfPosition(new Position(24 + x * 18, 4 + y * 18));
-                    slotWidget.setBackground(GuiTextures.SLOT);
-                    slotWidget.setId("slot_" + index);
-                    main.addWidget(slotWidget);
-                }
-            }
-
-            SlotWidget filterSlotWidget = new SlotWidget();
-            filterSlotWidget.initTemplate();
-            filterSlotWidget
-                    .setSelfPosition(new Position(4, (main.getSize().height - filterSlotWidget.getSize().height) / 2));
-            filterSlotWidget.setBackground(GuiTextures.SLOT, GuiTextures.FILTER_SLOT_OVERLAY);
-            filterSlotWidget.setId("filter_slot");
-            main.addWidget(filterSlotWidget);
-            main.setBackground(GuiTextures.BACKGROUND_INVERSE);
-            return main;
-        }, (group, machine) -> {
-            WidgetUtils.widgetByIdForEach(group, "^slot_[0-9]+$", SlotWidget.class, slot -> {
-                var index = WidgetUtils.widgetIdIndex(slot);
-                if (index >= 0 && index < machine.output.getSlots()) {
-                    slot.setHandlerSlot(machine.output, index);
-                    slot.setCanTakeItems(true);
-                    slot.setCanPutItems(false);
-                }
-            });
-            WidgetUtils.widgetByIdForEach(group, "^filter_slot$", SlotWidget.class, slot -> {
-                slot.setHandlerSlot(machine.filterInventory, 0);
-                slot.setCanTakeItems(true);
-                slot.setCanPutItems(true);
-            });
-
-        });
+    // TODO(Onion): fix the gui stuff for this
+    @Override
+    public void buildMainUI(ParentWidget<?> mainWidget, PosGuiData guiData, PanelSyncManager syncManager,
+                            UISettings settings) {
+        mainWidget.child(Flow.column()
+                .size(MachineUIPanel.DEFAULT_CONTENT_WIDTH, 150)
+                .crossAxisAlignment(Alignment.CrossAxis.START)
+                .child(Flow.row()
+                        .coverChildren()
+                        .childPadding(2)
+                        .margin(5)
+                        .horizontalCenter()
+                        .child(new TextWidget<>(IKey.lang("gtceu.gui.item_collector.range")))
+                        .child(new TextFieldWidget()
+                                .setNumbers(1, maxRange)
+                                .value(SyncHandlers.intNumber(this::getRange, this::setRange))))
+                .child(Flow.row()
+                        .coverChildrenHeight()
+                        .widthRel(1)
+                        .child(new ItemSlot()
+                                .slot(filterInventory, 0)
+                                .background(GTGuiTextures.SLOT, GTGuiTextures.FILTER_SLOT_OVERLAY)
+                                .margin(7))
+                        .child(GTMuiMachineUtil
+                                .createSquareSlotGroupFromInventory(output, "main_inv", syncManager)
+                                .horizontalCenter())));
     }
 }
diff --git a/src/main/java/com/gregtechceu/gtceu/common/machine/electric/MinerMachine.java b/src/main/java/com/gregtechceu/gtceu/common/machine/electric/MinerMachine.java
index d4f8b9ed913..47096dc5cef 100644
--- a/src/main/java/com/gregtechceu/gtceu/common/machine/electric/MinerMachine.java
+++ b/src/main/java/com/gregtechceu/gtceu/common/machine/electric/MinerMachine.java
@@ -5,41 +5,37 @@
 import com.gregtechceu.gtceu.api.capability.GTCapabilityHelper;
 import com.gregtechceu.gtceu.api.capability.IControllable;
 import com.gregtechceu.gtceu.api.capability.IMiner;
-import com.gregtechceu.gtceu.api.gui.GuiTextures;
-import com.gregtechceu.gtceu.api.gui.WidgetUtils;
-import com.gregtechceu.gtceu.api.gui.editor.EditableMachineUI;
-import com.gregtechceu.gtceu.api.gui.editor.EditableUI;
-import com.gregtechceu.gtceu.api.gui.widget.SlotWidget;
 import com.gregtechceu.gtceu.api.machine.TickableSubscription;
 import com.gregtechceu.gtceu.api.machine.WorkableTieredMachine;
 import com.gregtechceu.gtceu.api.machine.feature.IDataInfoProvider;
-import com.gregtechceu.gtceu.api.machine.feature.IFancyUIMachine;
+import com.gregtechceu.gtceu.api.machine.feature.IMuiMachine;
 import com.gregtechceu.gtceu.api.sync_system.annotations.SaveField;
 import com.gregtechceu.gtceu.api.sync_system.annotations.SyncToClient;
 import com.gregtechceu.gtceu.api.transfer.item.CustomItemStackHandler;
 import com.gregtechceu.gtceu.common.item.behavior.PortableScannerBehavior;
 import com.gregtechceu.gtceu.common.machine.trait.AutoOutputTrait;
 import com.gregtechceu.gtceu.common.machine.trait.miner.MinerLogic;
+import com.gregtechceu.gtceu.common.mui.GTGuiTextures;
+import com.gregtechceu.gtceu.common.mui.GTMuiMachineUtil;
 import com.gregtechceu.gtceu.config.ConfigHolder;
-import com.gregtechceu.gtceu.data.lang.LangHandler;
 import com.gregtechceu.gtceu.utils.ExtendedUseOnContext;
 import com.gregtechceu.gtceu.utils.ISubscription;
 
-import com.lowdragmc.lowdraglib.gui.widget.ComponentPanelWidget;
-import com.lowdragmc.lowdraglib.gui.widget.DraggableScrollableWidgetGroup;
-import com.lowdragmc.lowdraglib.gui.widget.WidgetGroup;
-import com.lowdragmc.lowdraglib.utils.Position;
-import com.lowdragmc.lowdraglib.utils.Size;
-
 import net.minecraft.ChatFormatting;
-import net.minecraft.Util;
 import net.minecraft.core.Direction;
 import net.minecraft.network.chat.Component;
-import net.minecraft.network.chat.MutableComponent;
 import net.minecraft.network.chat.Style;
-import net.minecraft.resources.ResourceLocation;
 import net.minecraft.world.InteractionResult;
 
+import brachy.modularui.api.drawable.IKey;
+import brachy.modularui.factory.PosGuiData;
+import brachy.modularui.screen.UISettings;
+import brachy.modularui.utils.Alignment;
+import brachy.modularui.utils.Color;
+import brachy.modularui.value.sync.PanelSyncManager;
+import brachy.modularui.widget.ParentWidget;
+import brachy.modularui.widgets.TextWidget;
+import brachy.modularui.widgets.layout.Flow;
 import com.mojang.blaze3d.MethodsReturnNonnullByDefault;
 import lombok.Getter;
 import org.jetbrains.annotations.NotNull;
@@ -48,14 +44,13 @@
 import java.util.ArrayList;
 import java.util.Collections;
 import java.util.List;
-import java.util.function.BiFunction;
 
 import javax.annotation.ParametersAreNonnullByDefault;
 
 @ParametersAreNonnullByDefault
 @MethodsReturnNonnullByDefault
 public class MinerMachine extends WorkableTieredMachine
-                          implements IControllable, IFancyUIMachine, IDataInfoProvider, IMiner {
+                          implements IControllable, IMuiMachine, IDataInfoProvider, IMiner {
 
     @Getter
     @SaveField
@@ -141,107 +136,15 @@ protected void chargeBattery() {
         }
     }
 
-    //////////////////////////////////////
-    // *********** GUI ***********//
-    //////////////////////////////////////
-
-    public static BiFunction<ResourceLocation, Integer, EditableMachineUI> EDITABLE_UI_CREATOR = Util
-            .memoize((path, inventorySize) -> new EditableMachineUI("misc", path, () -> {
-                WidgetGroup template = createTemplate(inventorySize).createDefault();
-                SlotWidget batterySlot = createBatterySlot().createDefault();
-                batterySlot.setSelfPosition(new Position(100, 10));
-                WidgetGroup group = new WidgetGroup(0, 0, Math.max(template.getSize().width + 12, 172),
-                        template.getSize().height + 8);
-                Size size = group.getSize();
-
-                template.setSelfPosition(new Position(
-                        (size.width - 4 - template.getSize().width) / 2 + 4,
-                        (size.height - template.getSize().height) / 2));
-
-                group.addWidget(template);
-                group.addWidget(batterySlot);
-                return group;
-            }, (template, machine) -> {
-                if (machine instanceof MinerMachine minerMachine) {
-                    createTemplate(inventorySize).setupUI(template, minerMachine);
-                    createEnergyBar().setupUI(template, minerMachine);
-                    createBatterySlot().setupUI(template, minerMachine);
-                }
-            }));
-
-    protected static EditableUI<WidgetGroup, MinerMachine> createTemplate(int inventorySize) {
-        return new EditableUI<>("miner", WidgetGroup.class, () -> {
-            int rowSize = (int) Math.sqrt(inventorySize);
-            int width = rowSize * 18 + 120;
-            int height = Math.max(rowSize * 18, 80);
-            WidgetGroup group = new WidgetGroup(0, 0, width, height);
-
-            WidgetGroup slots = new WidgetGroup(120, (height - rowSize * 18) / 2, rowSize * 18, rowSize * 18);
-            for (int y = 0; y < rowSize; y++) {
-                for (int x = 0; x < rowSize; x++) {
-                    int index = y * rowSize + x;
-                    var slot = new SlotWidget();
-                    slot.initTemplate();
-                    slot.setSelfPosition(new Position(x * 18, y * 18));
-                    slot.setBackground(GuiTextures.SLOT);
-                    slot.setId("slot_" + index);
-                    slots.addWidget(slot);
-                }
-            }
-
-            var componentPanel = new ComponentPanelWidget(4, 5, list -> {});
-            componentPanel.setMaxWidthLimit(110);
-            componentPanel.setId("component_panel");
-
-            var container = new WidgetGroup(0, 0, 117, height);
-            container.addWidget(new DraggableScrollableWidgetGroup(4, 4, container.getSize().width - 8,
-                    container.getSize().height - 8)
-                    .setBackground(GuiTextures.DISPLAY)
-                    .addWidget(componentPanel));
-            container.setBackground(GuiTextures.BACKGROUND_INVERSE);
-            group.addWidget(container);
-            group.addWidget(slots);
-            return group;
-        }, (group, machine) -> {
-            WidgetUtils.widgetByIdForEach(group, "^slot_[0-9]+$", SlotWidget.class, slot -> {
-                var index = WidgetUtils.widgetIdIndex(slot);
-                if (index >= 0 && index < machine.exportItems.getSlots()) {
-                    slot.setHandlerSlot(machine.exportItems, index);
-                    slot.setCanTakeItems(true);
-                    slot.setCanPutItems(false);
-                }
-            });
-            WidgetUtils.widgetByIdForEach(group, "^component_panel$", ComponentPanelWidget.class,
-                    panel -> panel.textSupplier(machine::addDisplayText));
-        });
-    }
-
-    /**
-     * Create an energy bar widget.
-     */
-    protected static EditableUI<SlotWidget, MinerMachine> createBatterySlot() {
-        return new EditableUI<>("battery_slot", SlotWidget.class, () -> {
-            var slotWidget = new SlotWidget();
-            slotWidget.setBackground(GuiTextures.SLOT, GuiTextures.CHARGER_OVERLAY);
-            return slotWidget;
-        }, (slotWidget, machine) -> {
-            slotWidget.setHandlerSlot(machine.chargerInventory, 0);
-            slotWidget.setCanPutItems(true);
-            slotWidget.setCanTakeItems(true);
-            slotWidget.setHoverTooltips(LangHandler.getMultiLang("gtceu.gui.charger_slot.tooltip",
-                    GTValues.VNF[machine.getTier()], GTValues.VNF[machine.getTier()]).toArray(new MutableComponent[0]));
-        });
-    }
-
     private void addDisplayText(List<Component> textList) {
         int workingArea = IMiner.getWorkingArea(getRecipeLogic().getCurrentRadius());
         textList.add(recipeLogic.getCustomProgressLine());
-        textList.add(Component.translatable("gtceu.machine.miner.startx", getRecipeLogic().getX()).append(" ")
-                .append(Component.translatable("gtceu.machine.miner.minex", getRecipeLogic().getMineX())));
-        textList.add(Component.translatable("gtceu.machine.miner.starty", getRecipeLogic().getY()).append(" ")
-                .append(Component.translatable("gtceu.machine.miner.miney", getRecipeLogic().getMineY())));
-        textList.add(Component.translatable("gtceu.machine.miner.startz", getRecipeLogic().getZ()).append(" ")
-                .append(Component.translatable("gtceu.machine.miner.minez", getRecipeLogic().getMineZ())));
+        textList.add(
+                Component.translatable("gtceu.machine.miner.x", getRecipeLogic().getX(), getRecipeLogic().getMineX()));
+        textList.add(
+                Component.translatable("gtceu.machine.miner.y", getRecipeLogic().getY(), getRecipeLogic().getMineY()));
+        textList.add(
+                Component.translatable("gtceu.machine.miner.x", getRecipeLogic().getZ(), getRecipeLogic().getMineZ()));
         textList.add(Component.translatable("gtceu.universal.tooltip.working_area", workingArea, workingArea));
         if (getRecipeLogic().isDone())
             textList.add(Component.translatable("gtceu.multiblock.large_miner.done")
@@ -308,4 +211,32 @@ public List<Component> getDataInfo(PortableScannerBehavior.DisplayMode mode) {
         }
         return new ArrayList<>();
     }
+
+    // TODO(Onion): fix the gui stuff for this
+
+    @Override
+    public void buildMainUI(ParentWidget<?> mainWidget, PosGuiData guiData, PanelSyncManager syncManager,
+                            UISettings settings) {
+        mainWidget
+                .child(Flow.row()
+                        .width(220)
+                        .coverChildrenHeight()
+                        .margin(5)
+                        .childPadding(5)
+                        .child(Flow.column()
+                                .crossAxisAlignment(Alignment.CrossAxis.START)
+                                .padding(5)
+                                .background(GTGuiTextures.DISPLAY)
+                                .widthRel(.6f)
+                                .child(new TextWidget<>(IKey.dynamic(() -> {
+                                    List<Component> text = new ArrayList<>();
+                                    addDisplayText(text);
+                                    return text.stream()
+                                            .map(Component::copy)
+                                            .reduce((a, b) -> a.append("\n").append(b))
+                                            .orElse(Component.empty());
+                                })).color(Color.WHITE.main)))
+                        .child(GTMuiMachineUtil.createSquareSlotGroupFromInventory(exportItems, "export_inv",
+                                syncManager)));
+    }
 }
diff --git a/src/main/java/com/gregtechceu/gtceu/common/machine/electric/PumpMachine.java b/src/main/java/com/gregtechceu/gtceu/common/machine/electric/PumpMachine.java
index a949cd084b3..4036ee1730d 100644
--- a/src/main/java/com/gregtechceu/gtceu/common/machine/electric/PumpMachine.java
+++ b/src/main/java/com/gregtechceu/gtceu/common/machine/electric/PumpMachine.java
@@ -3,30 +3,25 @@
 import com.gregtechceu.gtceu.api.GTValues;
 import com.gregtechceu.gtceu.api.blockentity.BlockEntityCreationInfo;
 import com.gregtechceu.gtceu.api.capability.recipe.IO;
-import com.gregtechceu.gtceu.api.gui.GuiTextures;
-import com.gregtechceu.gtceu.api.gui.UITemplate;
-import com.gregtechceu.gtceu.api.gui.widget.TankWidget;
-import com.gregtechceu.gtceu.api.gui.widget.ToggleButtonWidget;
 import com.gregtechceu.gtceu.api.machine.TieredEnergyMachine;
-import com.gregtechceu.gtceu.api.machine.feature.IUIMachine;
+import com.gregtechceu.gtceu.api.machine.feature.IMuiMachine;
 import com.gregtechceu.gtceu.api.machine.trait.NotifiableFluidTank;
 import com.gregtechceu.gtceu.api.sync_system.annotations.SaveField;
 import com.gregtechceu.gtceu.api.sync_system.annotations.SyncToClient;
 import com.gregtechceu.gtceu.common.data.GTBlocks;
 import com.gregtechceu.gtceu.common.machine.trait.AutoOutputTrait;
-
-import com.lowdragmc.lowdraglib.gui.modular.ModularUI;
-import com.lowdragmc.lowdraglib.gui.widget.ImageWidget;
-import com.lowdragmc.lowdraglib.gui.widget.LabelWidget;
+import com.gregtechceu.gtceu.common.mui.GTGuiTextures;
+import com.gregtechceu.gtceu.common.mui.GTMuiWidgets;
+import com.gregtechceu.gtceu.utils.FormattingUtil;
 
 import net.minecraft.MethodsReturnNonnullByDefault;
 import net.minecraft.Util;
 import net.minecraft.core.BlockPos;
 import net.minecraft.core.Direction;
 import net.minecraft.core.Vec3i;
+import net.minecraft.network.chat.Component;
 import net.minecraft.server.level.ServerLevel;
 import net.minecraft.util.RandomSource;
-import net.minecraft.world.entity.player.Player;
 import net.minecraft.world.level.Level;
 import net.minecraft.world.level.block.Blocks;
 import net.minecraft.world.level.block.LiquidBlock;
@@ -37,6 +32,14 @@
 import net.minecraftforge.fluids.capability.IFluidHandler.FluidAction;
 import net.minecraftforge.fluids.capability.wrappers.BucketPickupHandlerWrapper;
 
+import brachy.modularui.api.drawable.IKey;
+import brachy.modularui.api.widget.IWidget;
+import brachy.modularui.factory.PosGuiData;
+import brachy.modularui.screen.UISettings;
+import brachy.modularui.value.sync.*;
+import brachy.modularui.widget.ParentWidget;
+import brachy.modularui.widgets.layout.Flow;
+import brachy.modularui.widgets.slot.FluidSlot;
 import it.unimi.dsi.fastutil.objects.ObjectArrayList;
 import it.unimi.dsi.fastutil.objects.ObjectOpenHashSet;
 import lombok.Getter;
@@ -53,7 +56,7 @@
 
 @ParametersAreNonnullByDefault
 @MethodsReturnNonnullByDefault
-public class PumpMachine extends TieredEnergyMachine implements IUIMachine {
+public class PumpMachine extends TieredEnergyMachine implements IMuiMachine {
 
     public static final int BASE_PUMP_RADIUS = 16;
     public static final int EXTRA_PUMP_RADIUS = 4;
@@ -529,22 +532,42 @@ private int getPumpingCycleLength() {
     //////////////////////////////////////
     // ********** Gui ***********//
     //////////////////////////////////////
+
     @Override
-    public ModularUI createUI(Player entityPlayer) {
-        return new ModularUI(176, 166, this, entityPlayer)
-                .background(GuiTextures.BACKGROUND)
-                .widget(new ImageWidget(7, 16, 81, 55, GuiTextures.DISPLAY))
-                .widget(new LabelWidget(11, 20, "gtceu.gui.fluid_amount"))
-                .widget(new LabelWidget(11, 30, () -> cache.getFluidInTank(0).getAmount() + "").setTextColor(-1)
-                        .setDropShadow(true))
-                .widget(new LabelWidget(6, 6, getBlockState().getBlock().getDescriptionId()))
-                .widget(new TankWidget(cache.getStorages()[0], 90, 35, true, true)
-                        .setBackground(GuiTextures.FLUID_SLOT))
-                .widget(new ToggleButtonWidget(7, 53, 18, 18,
-                        GuiTextures.BUTTON_FLUID_OUTPUT, this.autoOutput::isAutoOutputFluids,
-                        this.autoOutput::setAllowAutoOutputFluids)
-                        .setShouldUseBaseBackground()
-                        .setTooltipText("gtceu.gui.fluid_auto_output.tooltip"))
-                .widget(UITemplate.bindPlayerInventory(entityPlayer.getInventory(), GuiTextures.SLOT, 7, 84, true));
+    public void buildMainUI(ParentWidget<?> mainWidget, PosGuiData guiData, PanelSyncManager syncManager,
+                            UISettings settings) {
+        IntSyncValue bucketSyncer = new IntSyncValue(() -> cache.getFluidInTank(0).getAmount(), (ignored) -> {});
+        syncManager.syncValue("bucket_amount", bucketSyncer);
+
+        mainWidget
+                // Box that has the display texture BG +
+                // the buttons / text / etc
+                .child(new ParentWidget<>()
+                        .background(GTGuiTextures.DISPLAY)
+                        .size(90, 63)
+                        .center()
+                        .child(IKey.lang("gtceu.gui.fluid_amount").asWidget()
+                                .color(0xffffff)
+                                .margin(8, 0, 8, 0))
+                        .child(IKey.dynamic(
+                                () -> Component.literal(
+                                        FormattingUtil.formatBuckets(bucketSyncer.getIntValue())))
+                                .asWidget()
+                                .color(0xffffff)
+                                .margin(8, 0, 20, 0))
+                        .child(Flow.row()
+                                .margin(4, 0, 41, 0)
+                                .coverChildren()
+                                .child(GTMuiWidgets.createAutoOutputFluidButton(autoOutput)))
+                        .child(Flow.column()
+                                .margin(68, 0, 23, 0)
+                                .coverChildren()
+                                .child(createFluidSlot(syncManager))));
+    }
+
+    private IWidget createFluidSlot(PanelSyncManager syncManager) {
+        syncManager.syncValue("fluid_slot",
+                SyncHandlers.fluidSlot(cache.getStorages()[0]).controlsAmount(false));
+        return new FluidSlot().syncHandler("fluid_slot", 0).background(GTGuiTextures.FLUID_SLOT);
     }
 }
diff --git a/src/main/java/com/gregtechceu/gtceu/common/machine/electric/WorldAcceleratorMachine.java b/src/main/java/com/gregtechceu/gtceu/common/machine/electric/WorldAcceleratorMachine.java
index d8857403a90..b1293bd1c90 100644
--- a/src/main/java/com/gregtechceu/gtceu/common/machine/electric/WorldAcceleratorMachine.java
+++ b/src/main/java/com/gregtechceu/gtceu/common/machine/electric/WorldAcceleratorMachine.java
@@ -5,7 +5,6 @@
 import com.gregtechceu.gtceu.api.blockentity.BlockEntityCreationInfo;
 import com.gregtechceu.gtceu.api.blockentity.PipeBlockEntity;
 import com.gregtechceu.gtceu.api.capability.IControllable;
-import com.gregtechceu.gtceu.api.gui.GuiTextures;
 import com.gregtechceu.gtceu.api.item.tool.GTToolType;
 import com.gregtechceu.gtceu.api.machine.MetaMachine;
 import com.gregtechceu.gtceu.api.machine.TickableSubscription;
@@ -15,12 +14,11 @@
 import com.gregtechceu.gtceu.api.sync_system.annotations.RerenderOnChanged;
 import com.gregtechceu.gtceu.api.sync_system.annotations.SaveField;
 import com.gregtechceu.gtceu.api.sync_system.annotations.SyncToClient;
+import com.gregtechceu.gtceu.common.mui.GTGuiTextures;
 import com.gregtechceu.gtceu.config.ConfigHolder;
 import com.gregtechceu.gtceu.utils.ExtendedUseOnContext;
 import com.gregtechceu.gtceu.utils.GTUtil;
 
-import com.lowdragmc.lowdraglib.gui.texture.ResourceTexture;
-
 import net.minecraft.MethodsReturnNonnullByDefault;
 import net.minecraft.core.BlockPos;
 import net.minecraft.core.Direction;
@@ -34,6 +32,7 @@
 import net.minecraft.world.level.block.state.BlockState;
 import net.minecraft.world.level.block.state.properties.BooleanProperty;
 
+import brachy.modularui.drawable.UITexture;
 import it.unimi.dsi.fastutil.objects.Object2BooleanFunction;
 import it.unimi.dsi.fastutil.objects.Object2BooleanOpenHashMap;
 import it.unimi.dsi.fastutil.objects.Object2ObjectOpenHashMap;
@@ -218,10 +217,10 @@ public void setWorkingEnabled(boolean workingEnabled) {
     }
 
     @Override
-    public @Nullable ResourceTexture sideTips(Player player, BlockPos pos, BlockState state, Set<GTToolType> toolTypes,
-                                              Direction side) {
+    public @Nullable UITexture sideTips(Player player, BlockPos pos, BlockState state, Set<GTToolType> toolTypes,
+                                        Direction side) {
         if (toolTypes.contains(GTToolType.SOFT_MALLET)) {
-            return isWorkingEnabled ? GuiTextures.TOOL_PAUSE : GuiTextures.TOOL_START;
+            return isWorkingEnabled ? GTGuiTextures.TOOL_PAUSE : GTGuiTextures.TOOL_START;
         }
         return super.sideTips(player, pos, state, toolTypes, side);
     }
diff --git a/src/main/java/com/gregtechceu/gtceu/common/machine/muimachine/TestMuiMachine.java b/src/main/java/com/gregtechceu/gtceu/common/machine/muimachine/TestMuiMachine.java
new file mode 100644
index 00000000000..4c7c6a3c69f
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/common/machine/muimachine/TestMuiMachine.java
@@ -0,0 +1,738 @@
+package com.gregtechceu.gtceu.common.machine.muimachine;
+
+import com.gregtechceu.gtceu.api.blockentity.BlockEntityCreationInfo;
+import com.gregtechceu.gtceu.api.machine.MetaMachine;
+import com.gregtechceu.gtceu.api.machine.TickableSubscription;
+import com.gregtechceu.gtceu.api.machine.feature.IMuiMachine;
+import com.gregtechceu.gtceu.common.data.GTMaterials;
+import com.gregtechceu.gtceu.common.mui.GTGuiTextures;
+
+import net.minecraft.network.FriendlyByteBuf;
+import net.minecraft.network.chat.Component;
+import net.minecraft.world.entity.EntityType;
+import net.minecraft.world.entity.animal.Fox;
+import net.minecraft.world.item.Item;
+import net.minecraft.world.item.ItemStack;
+import net.minecraft.world.item.Items;
+import net.minecraft.world.level.block.Blocks;
+import net.minecraftforge.common.capabilities.ForgeCapabilities;
+import net.minecraftforge.fluids.capability.templates.FluidTank;
+import net.minecraftforge.items.IItemHandlerModifiable;
+import net.minecraftforge.items.ItemStackHandler;
+import net.minecraftforge.registries.ForgeRegistries;
+
+import brachy.modularui.api.IPanelHandler;
+import brachy.modularui.api.drawable.IKey;
+import brachy.modularui.api.widget.IWidget;
+import brachy.modularui.client.schemarenderer.BlockHighlight;
+import brachy.modularui.drawable.*;
+import brachy.modularui.drawable.text.AnimatedText;
+import brachy.modularui.factory.GuiData;
+import brachy.modularui.factory.PosGuiData;
+import brachy.modularui.schema.ArraySchema;
+import brachy.modularui.screen.ModularPanel;
+import brachy.modularui.screen.RichTooltip;
+import brachy.modularui.screen.UISettings;
+import brachy.modularui.screen.viewport.ModularGuiContext;
+import brachy.modularui.theme.WidgetThemeEntry;
+import brachy.modularui.utils.Alignment;
+import brachy.modularui.utils.Color;
+import brachy.modularui.utils.Interpolation;
+import brachy.modularui.value.BoolValue;
+import brachy.modularui.value.IntValue;
+import brachy.modularui.value.StringValue;
+import brachy.modularui.value.sync.*;
+import brachy.modularui.value.sync.ItemSlotSyncHandler;
+import brachy.modularui.widget.EmptyWidget;
+import brachy.modularui.widget.ParentWidget;
+import brachy.modularui.widgets.*;
+import brachy.modularui.widgets.layout.Flow;
+import brachy.modularui.widgets.slot.*;
+import brachy.modularui.widgets.textfield.TextFieldWidget;
+import it.unimi.dsi.fastutil.objects.Object2IntMap;
+import it.unimi.dsi.fastutil.objects.Object2IntOpenHashMap;
+import it.unimi.dsi.fastutil.objects.Object2ObjectOpenHashMap;
+import org.jetbrains.annotations.NotNull;
+
+import java.util.*;
+import java.util.concurrent.atomic.AtomicInteger;
+import java.util.concurrent.atomic.AtomicReference;
+import java.util.function.DoubleUnaryOperator;
+
+public class TestMuiMachine extends MetaMachine implements IMuiMachine {
+
+    private static final Object2IntMap<Item> handlerSizeMap = new Object2IntOpenHashMap<>() {
+
+        {
+            put(Items.DIAMOND, 9);
+            put(Items.EMERALD, 9);
+            put(Items.GOLD_INGOT, 7);
+            put(Items.IRON_INGOT, 6);
+            put(Items.CLAY_BALL, 2);
+            defaultReturnValue(3);
+        }
+    };
+
+    private final FluidTank fluidTank = new FluidTank(10000);
+    private final FluidTank fluidTankPhantom = new FluidTank(500000);
+    private long time = 0;
+    private int val, val2 = 0;
+    private String value = "";
+    private int intValue = 1234567;
+    private double doubleValue = 1;
+    private final int duration = 80;
+    private int progress = 0;
+    private int cycleState = 0;
+    private List<Integer> serverInts = new ArrayList<>();
+    private ItemStack displayItem = new ItemStack(Items.DIAMOND);
+    private final IItemHandlerModifiable inventory = new ItemStackHandler(2) {
+
+        @Override
+        public int getSlotLimit(int slot) {
+            return slot == 0 ? Integer.MAX_VALUE : 64;
+        }
+    };
+    private final ItemStackHandler bigInventory = new ItemStackHandler(9);
+
+    private final ItemStackHandler mixerItems = new ItemStackHandler(4);
+    private final ItemStackHandler smallInv = new ItemStackHandler(4);
+    private final FluidTank mixerFluids1 = new FluidTank(16000);
+    private final FluidTank mixerFluids2 = new FluidTank(16000);
+    private final ItemStackHandler craftingInventory = new ItemStackHandler(10);
+    private final ItemStackHandler storageInventory0 = new ItemStackHandler(1);
+    private final Map<Item, ItemStackHandler> stackHandlerMap = new Object2ObjectOpenHashMap<>();
+
+    private int num = 2;
+
+    private TickableSubscription sub;
+
+    public TestMuiMachine(BlockEntityCreationInfo info) {
+        super(info);
+        sub = subscribeServerTick(this::tick);
+    }
+
+    @Override
+    public void buildMainUI(ParentWidget<?> mainWidget, PosGuiData guiData, PanelSyncManager syncManager,
+                            UISettings settings) {
+        // settings.customContainer(() -> new CraftingModularContainer(3, 3, this.craftingInventory));
+        // settings.customGui(() -> TestGuiContainer::new);
+
+        syncManager.registerSlotGroup("item_inv", 3);
+        syncManager.registerSlotGroup("mixer_items", 2);
+
+        syncManager.syncValue("mixer_fluids", 0, SyncHandlers.fluidSlot(this.mixerFluids1));
+        syncManager.syncValue("mixer_fluids", 1, SyncHandlers.fluidSlot(this.mixerFluids2));
+        IntSyncValue cycleStateValue = new IntSyncValue(() -> this.cycleState, val -> this.cycleState = val);
+        syncManager.getHyperVisor().syncValue("cycle_state", cycleStateValue);
+        syncManager.syncValue("display_item", GenericSyncValue.forItem(() -> this.displayItem, null));
+        GenericListSyncHandler<Integer> numberListSyncHandler = GenericListSyncHandler.<Integer>builder()
+                .getter(() -> this.serverInts)
+                .setter(v -> this.serverInts = v)
+                .serializer(FriendlyByteBuf::writeInt)
+                .deserializer(FriendlyByteBuf::readInt)
+                .immutableCopy()
+                .build();
+        syncManager.syncValue("number_list", numberListSyncHandler);
+        syncManager.bindPlayerInventory(guiData.getPlayer());
+
+        DynamicSyncHandler dynamicSyncHandler = new DynamicSyncHandler()
+                .widgetProvider((syncManager1, packet) -> {
+                    ItemStack itemStack = packet.readItem();
+                    if (itemStack.isEmpty()) return new EmptyWidget();
+                    Item item = itemStack.getItem();
+                    ItemStackHandler handler = stackHandlerMap.computeIfAbsent(item,
+                            k -> new ItemStackHandler(handlerSizeMap.getInt(k)));
+                    String name = item.getName(itemStack).toString();
+                    Flow flow = Flow.row();
+                    for (int i = 0; i < handler.getSlots(); i++) {
+                        int finalI = i;
+                        flow.child(new ItemSlot()
+                                .syncHandler(syncManager1.getOrCreateSyncHandler(name, i, ItemSlotSyncHandler.class,
+                                        () -> new ItemSlotSyncHandler(new ModularSlot(handler, finalI)))));
+                    }
+                    return flow;
+                });
+
+        DynamicLinkedSyncHandler<GenericListSyncHandler<Integer>> dynamicLinkedSyncHandler = new DynamicLinkedSyncHandler<>(
+                numberListSyncHandler)
+                .widgetProvider((syncManager1, value1) -> {
+                    List<Integer> vals = value1.getValue();
+                    return Flow.col()
+                            .widthRel(1f)
+                            .coverChildrenHeight()
+                            .children(vals.size(), i -> IKey.str(String.valueOf(vals.get(i))).asWidget().padding(2))
+                            .name("synced number col");
+                });
+
+        // disable spotless on the menu layout code so it won't insert random line breaks
+        // spotless:off
+        Rectangle colorPickerBackground = new Rectangle().color(Color.RED.main);
+        ModularPanel<?> panel = new ModularPanel<>("test_tile");
+        IPanelHandler panelSyncHandler = syncManager.syncedPanel("other_panel", true, this::openSecondWindow);
+        IPanelHandler colorPicker = IPanelHandler.simple(panel,
+                (mainPanel, player) -> new ColorPickerDialog("color_picker", colorPickerBackground.getColor(), true)
+                         .draggable(true)
+                         .relative(mainWidget.getPanel())
+                         .top(0)
+                         .rightRel(1f),
+                true);
+        PagedWidget.Controller tabController = new PagedWidget.Controller();
+        mainWidget.resizer()                        // returns object which is responsible for sizing
+                .size(176, 220);       // set a static size for the main panel
+
+        DoubleSyncValue progressPercent = syncManager.getOrCreateSyncHandler("progressPercent", DoubleSyncValue.class, () ->
+                new DoubleSyncValue(() -> (this.progress / (double) this.duration)));
+
+        var babyFop = new Fox(EntityType.FOX, guiData.getLevel());
+        babyFop.setAge(-1);
+        panel.child(Flow.row()
+                .name("Tab row")
+                .coverChildren()
+                .topRel(0f, 4, 1f)
+                .child(new PageButton(0, tabController)
+                        .tab(GTGuiTextures.TAB_TOP, -1)
+                        .overlay(new EntityDrawable<>(babyFop).followMouse()))
+                .child(new PageButton(1, tabController)
+                        .tab(GTGuiTextures.TAB_TOP, 0)
+                        .overlay(new ItemDrawable(Items.OAK_SAPLING).asIcon()))
+                .child(new PageButton(2, tabController)
+                        .tab(GTGuiTextures.TAB_TOP, 0)
+                        .overlay(new ItemDrawable(Items.COMPASS).asIcon()))
+                .child(new PageButton(3, tabController)
+                        .tab(GTGuiTextures.TAB_TOP, 0)
+                        .overlay(new ItemDrawable(Blocks.CHEST).asIcon()))
+                .child(new PageButton(4, tabController)
+                        .tab(GTGuiTextures.TAB_TOP, 0)
+                        .overlay(new ItemDrawable(Items.ENDER_EYE).asIcon())))
+
+                .child(new Expandable()
+                        .name("expandable")
+                        .top(0)
+                        .leftRelOffset(1f, 1)
+                        .background(GTGuiTextures.BACKGROUND)
+                        .excludeAreaInRecipeViewer()
+                        .stencilTransform((r, expanded) -> {
+                            r.width = Math.max(20, r.width - 5);
+                            r.height = Math.max(20, r.height - 5);
+                        })
+                        .animationDuration(500)
+                        .interpolation(Interpolation.BOUNCE_OUT)
+                        .collapsedView(new ItemDrawable(Blocks.CRAFTING_TABLE).asIcon().asWidget().size(20).pos(0, 0))
+                        .expandedView(new ParentWidget<>()
+                                .name("crafting tab")
+                                .coverChildren()
+                                .child(new ItemDrawable(Blocks.CRAFTING_TABLE).asIcon().asWidget().size(20).pos(0, 0))
+                                .child(SlotGroupWidget.builder()
+                                        .row("III  D")
+                                        .row("III  O")
+                                        .row("III   ")
+                                        .key('I', i -> new ItemSlot().slot(new ModularSlot(this.craftingInventory, i))
+                                                .addTooltipLine("This slot is empty"))
+                                        .key('O', new ItemSlot().slot(new ModularCraftingSlot(this.craftingInventory, 9)))
+                                        .key('D', new ItemDisplayWidget().syncHandler("display_item"))
+                                        .build()
+                                        .margin(5, 5, 20, 5).name("crafting"))))
+
+                .child(Flow.column()
+                        .name("main col")
+                        .sizeRel(1f)
+                        .paddingBottom(7)
+                        .child(new ParentWidget<>()
+                                .expanded()
+                                .widthRel(1f)
+                                .child(new PagedWidget<>()
+                                        .name("root parent")
+                                        .sizeRel(1f)
+                                        .controller(tabController)
+                                        .addPage(new ParentWidget<>()
+                                                .name("page 1 parent")
+                                                .sizeRel(1f, 1f)
+                                                .padding(7, 0)
+                                                .child(Flow.row()
+                                                        .name("buttons, slots and more tests")
+                                                        .height(137)
+                                                        .coverChildrenWidth()
+                                                        .posRel(Alignment.CenterLeft)
+                                                        // .padding(7)
+                                                        .child(Flow.col()
+                                                                .name("buttons and slots test")
+                                                                .coverChildren()
+                                                                .marginRight(8)
+                                                                // .flex(flex -> flex.height(0.5f))
+                                                                // .widthRel(0.5f)
+                                                                .crossAxisAlignment(Alignment.CrossAxis.CENTER)
+                                                                .child(new ButtonWidget<>()
+                                                                        .size(60, 18)
+                                                                        .overlay(IKey.dynamic(() -> Component.literal("Button " + this.val))))
+                                                                .child(new FluidSlot()
+                                                                        .margin(2)
+                                                                        .syncHandler(SyncHandlers.fluidSlot(this.fluidTank)))
+                                                                .child(new ButtonWidget<>()
+                                                                        .size(60, 18)
+                                                                        .tooltip(tooltip -> {
+                                                                            tooltip.showUpTimer(10);
+                                                                            tooltip.addLine(IKey.str("Test Line g"));
+                                                                            tooltip.addLine(IKey.str("An image inside of a tooltip:"));
+                                                                            tooltip.addLine(GuiTextures.MUI_LOGO
+                                                                                    .asIcon().size(50)
+                                                                                    .alignment(Alignment.TopCenter));
+                                                                            tooltip.addLine(IKey.str("And here a circle:"));
+                                                                            tooltip.addLine(new Circle()
+                                                                                    .setColor(Color.RED.darker(2), Color.RED.brighter(2))
+                                                                                    .asIcon()
+                                                                                    .size(20))
+                                                                                    .addLine(new ItemDrawable(Items.DIAMOND).asIcon())
+                                                                                    .pos(RichTooltip.Pos.LEFT);
+                                                                        })
+                                                                        .onMousePressed((mouseX, mouseY, mouseButton) -> {
+                                                                            // panel.getScreen().close(true);
+                                                                            // panel.getScreen().openDialog("dialog",
+                                                                            // this::buildDialog,
+                                                                            // ModularUI.LOGGER::info);
+                                                                            // openSecondWindow(context).openIn(panel.getScreen());
+                                                                            panelSyncHandler.openPanel();
+                                                                            return true;
+                                                                        })
+                                                                        // .flex(flex -> flex.left(3)) // ?
+                                                                        .overlay(IKey.str("Button 2")))
+                                                                .child(new TextFieldWidget()
+                                                                        .size(60, 18)
+                                                                        .setTextAlignment(Alignment.CenterRight)
+                                                                        .value(SyncHandlers.string(() -> this.value,
+                                                                                val -> this.value = val))
+                                                                        .margin(0, 2)
+                                                                        .hintText(Component.literal("hint")))
+                                                                .child(new TextFieldWidget()
+                                                                        .size(60, 18)
+                                                                        .paddingTop(1)
+                                                                        .value(SyncHandlers.doubleNumber(
+                                                                                () -> this.doubleValue,
+                                                                                val -> this.doubleValue = val))
+                                                                        .setNumbersDouble(DoubleUnaryOperator.identity())
+                                                                        .hintText(Component.literal("number")))
+                                                                // .child(IKey.str("Test
+                                                                // string").asWidget().padding(2).name("test
+                                                                // string"))
+                                                                .child(new ScrollingTextWidget(
+                                                                        IKey.str("Very very long test string"))
+                                                                        .widthRel(1f).height(16))
+                                                        // .child(IKey.EMPTY.asWidget().name("Empty IKey"))
+                                                        )
+                                                        .child(Flow.col()
+                                                                .name("button and slots test 2")
+                                                                .coverChildren()
+                                                                // .widthRel(0.5f)
+                                                                .crossAxisAlignment(Alignment.CrossAxis.CENTER)
+                                                                .child(new ProgressWidget()
+                                                                        .value(progressPercent)
+                                                                        .texture(GTGuiTextures.PROGRESS_BAR_ARROW, 20))
+                                                                .child(new ProgressWidget()
+                                                                        .value(progressPercent)
+                                                                        .texture(GTGuiTextures.PROGRESS_BAR_MIXER, 20)
+                                                                        .direction(
+                                                                                ProgressWidget.Direction.CIRCULAR_CW))
+                                                                .child(Flow.row().coverChildrenWidth().height(22)
+                                                                        .child(new ToggleButton()
+                                                                                .value(new BoolValue.Dynamic(
+                                                                                        () -> cycleStateValue.getIntValue() == 0,
+                                                                                        val -> cycleStateValue.setIntValue(0)))
+                                                                                .overlay(GTGuiTextures.CYCLE_BUTTON
+                                                                                        .getSubArea(0, 0, 1, 1 / 3f)))
+                                                                        .child(new ToggleButton()
+                                                                                .value(new BoolValue.Dynamic(
+                                                                                        () -> cycleStateValue.getIntValue() == 1,
+                                                                                        val -> cycleStateValue.setIntValue(1)))
+                                                                                .overlay(GTGuiTextures.CYCLE_BUTTON
+                                                                                        .getSubArea(0, 1 / 3f, 1,
+                                                                                                2 / 3f)))
+                                                                        .child(new ToggleButton()
+                                                                                .value(new BoolValue.Dynamic(
+                                                                                        () -> cycleStateValue.getIntValue() == 2,
+                                                                                        val -> cycleStateValue.setIntValue(2)))
+                                                                                .overlay(GTGuiTextures.CYCLE_BUTTON
+                                                                                        .getSubArea(0, 2 / 3f, 1, 1))))
+                                                                /*
+                                                                 * .child(new CycleButtonWidget()
+                                                                 * .length(3)
+                                                                 * .texture(GTGuiTextures.CYCLE_BUTTON)
+                                                                 * .addTooltip(0, "State 1")
+                                                                 * .addTooltip(1, "State 2")
+                                                                 * .addTooltip(2, "State 3")
+                                                                 * .background(GTGuiTextures.BUTTON)
+                                                                 * .value(SyncHandlers.intNumber(() -> this.cycleState,
+                                                                 * val -> this.cycleState = val)))
+                                                                 */
+                                                                .child(new ItemSlot()
+                                                                        .slot(SyncHandlers.itemSlot(this.inventory, 0)
+                                                                                .ignoreMaxStackSize(true)
+                                                                                .singletonSlotGroup()))
+                                                                .child(new FluidSlot()
+                                                                        .margin(2)
+                                                                        .width(30)
+                                                                        .alwaysShowFull(false)
+                                                                        .syncHandler(SyncHandlers
+                                                                                .fluidSlot(this.fluidTankPhantom)
+                                                                                .phantom(true)))
+                                                                .child(Flow.col()
+                                                                        .name("button and slots test 3")
+                                                                        .coverChildren()
+                                                                        .child(new TextFieldWidget()
+                                                                                .size(60, 20)
+                                                                                .value(SyncHandlers.intNumber(
+                                                                                        () -> this.intValue,
+                                                                                        val -> this.intValue = val))
+                                                                                .setNumbers(0, 9999999)
+                                                                                .hintText(Component
+                                                                                        .literal("integer")))))))
+                                        .addPage(Flow.col()
+                                                .name("Slots test page")
+                                                .coverChildren()
+                                                // .height(120)
+                                                .padding(7)
+                                                .leftRel(0.5f)
+                                                .mainAxisAlignment(Alignment.MainAxis.START)
+                                                .childPadding(2)
+                                                // .child(SlotGroupWidget.playerInventory().left(0))
+                                                .child(SlotGroupWidget.builder()
+                                                        .matrix("III", "III", "III")
+                                                        .key('I', index -> {
+                                                            // 4 is the middle slot with a negative priority -> shift
+                                                            // click prioritises middle slot
+                                                            if (index == 4) {
+                                                                return new ItemSlot().slot(
+                                                                        SyncHandlers.itemSlot(this.bigInventory, index)
+                                                                                .singletonSlotGroup(-100));
+                                                            }
+                                                            return new ItemSlot().slot(
+                                                                    SyncHandlers.itemSlot(this.bigInventory, index)
+                                                                            .slotGroup("item_inv"));
+                                                        })
+                                                        .build().name("9 slot inv")
+                                                        .placeSortButtonsTopRightVertical()
+                                                // .marginBottom(2)
+                                                )
+                                                .child(SlotGroupWidget.builder()
+                                                        .row("FII")
+                                                        .row("FII")
+                                                        .key('F',
+                                                                index -> new FluidSlot().syncHandler("mixer_fluids",
+                                                                        index))
+                                                        .key('I',
+                                                                index -> ItemSlot.create(index >= 2)
+                                                                        .slot(new ModularSlot(this.mixerItems, index)
+                                                                                .slotGroup("mixer_items")
+                                                                                .filter(stack -> !stack.getCapability(
+                                                                                        ForgeCapabilities.ITEM_HANDLER)
+                                                                                        .isPresent())))
+                                                        .build().name("mixer inv")
+                                                        .disableSortButtons())
+                                                .child(Flow.row()
+                                                        .coverChildrenHeight()
+                                                        .child(new CycleButtonWidget()
+                                                                .size(20, 20)
+                                                                .stateCount(3)
+                                                                .stateOverlay(GTGuiTextures.CYCLE_BUTTON)
+                                                                .value(new IntSyncValue(() -> this.val2, val -> this.val2 = val))
+                                                                .margin(8, 0))
+                                                        .child(IKey.str("Hello World").asWidget().height(18)))
+                                                .child(new SpecialButton(
+                                                        IKey.str("A very long string that looks cool when animated")
+                                                                .withAnimation())
+                                                        .height(14)
+                                                        .widthRel(1f))
+                                        /*
+                                         * GuiTextures.LOGO.asIcon()
+                                         * .size(80, 80)
+                                         * .asWidget()
+                                         * .flex(flex -> flex.width(1f).height(1f))
+                                         */)
+                                        .addPage(new ParentWidget<>()
+                                                .name("page 3 parent")
+                                                .sizeRel(1f, 1f)
+                                                .padding(7)
+                                                // .child(SlotGroupWidget.playerInventory())
+                                                .child(new SliderWidget()
+                                                        .widthRel(1f).bottom(50).height(16) // test overwriting of units
+                                                        .top(7)
+                                                        .stopper(0, 10, 20, 30, 40, 50, 60, 70, 80, 90, 100)
+                                                        .background(GTGuiTextures.FLUID_SLOT))
+                                                .child(new ButtonWidget<>()
+                                                        .name("color picker button")
+                                                        .top(25)
+                                                        .background(colorPickerBackground)
+                                                        .disableHoverBackground()
+                                                        .onMousePressed((mouseX, mouseY, mouseButton) -> {
+                                                            colorPicker.openPanel();
+                                                            return true;
+                                                        }))
+                                                .child(new ListWidget<>()
+                                                        .name("test config list")
+                                                        .widthRel(1f).top(50).bottom(2)
+                                                        /*
+                                                         * .child(new Rectangle().setColor(0xFF606060).asWidget()
+                                                         * .top(1)
+                                                         * .left(32)
+                                                         * .size(1, 40))
+                                                         */
+                                                        .child(Flow.row()
+                                                                .name("test config 1")
+                                                                .widthRel(1f).coverChildrenHeight()
+                                                                .crossAxisAlignment(Alignment.CrossAxis.CENTER)
+                                                                .childPadding(2)
+                                                                .child(new CycleButtonWidget()
+                                                                        .value(new BoolValue(false))
+                                                                        .stateOverlay(GuiTextures.CHECK_BOX)
+                                                                        .size(14, 14)
+                                                                        .margin(8, 4))
+                                                                .child(IKey.str("Boolean config").asWidget().height(14)))
+                                                        .child(Flow.row()
+                                                                .name("test config 2")
+                                                                .widthRel(1f).height(14)
+                                                                .childPadding(2)
+                                                                .child(new TextFieldWidget()
+                                                                        .value(new IntValue.Dynamic(() -> this.num, val -> this.num = val))
+                                                                        .disableHoverBackground()
+                                                                        .setNumbers(1, Short.MAX_VALUE)
+                                                                        .setTextAlignment(Alignment.Center)
+                                                                        .background(new Rectangle().color(0xFFb1b1b1))
+                                                                        .setTextColor(IKey.TEXT_COLOR)
+                                                                        .size(20, 14))
+                                                                .child(IKey.str("Number config").asWidget()
+                                                                        .height(14)))
+                                                        .child(IKey.str("Config title").asWidget()
+                                                                .color(0xFF404040)
+                                                                .alignment(Alignment.CenterLeft)
+                                                                .left(5).height(14)
+                                                                .tooltip(tooltip -> tooltip.showUpTimer(10)
+                                                                        .addLine(IKey.str("Config title tooltip"))))
+                                                        .child(Flow.row()
+                                                                .name("test config 3")
+                                                                .widthRel(1f).height(14)
+                                                                .childPadding(2)
+                                                                .child(new CycleButtonWidget()
+                                                                        .value(new BoolValue(false))
+                                                                        .stateOverlay(GuiTextures.CHECK_BOX)
+                                                                        .size(14, 14))
+                                                                .child(IKey.str("Boolean config 3").asWidget().height(14)))))
+                                        .addPage(new ParentWidget<>()
+                                                .name("page 4 storage")
+                                                .sizeRel(1f)
+                                                .child(Flow.col()
+                                                        .name("page 4 col, dynamic widgets")
+                                                        .padding(7)
+                                                        .child(new ItemSlot()
+                                                                .slot(new ModularSlot(this.storageInventory0, 0)
+                                                                        .changeListener(((newItem, onlyAmountChanged, client, init) -> {
+                                                                            if (client && !onlyAmountChanged) {
+                                                                                dynamicSyncHandler.notifyUpdate(
+                                                                                        packet -> packet.writeItem(newItem));
+                                                                            }
+                                                                        }))))
+                                                        .child(new DynamicSyncedWidget<>()
+                                                                .widthRel(1f)
+                                                                .syncHandler(dynamicSyncHandler))
+                                                /*.child(new DynamicSyncedWidget<>()
+                                                        .widthRel(1f)
+                                                        .coverChildrenHeight()
+                                                        .syncHandler(dynamicLinkedSyncHandler))*/))
+                                        .addPage(createSchemaPage(guiData))))
+                        .child(SlotGroupWidget.playerInventory(false)));
+        /*
+         * panel.child(new ButtonWidget<>()
+         * .flex(flex -> flex.size(60, 20)
+         * .top(7)
+         * .left(0.5f))
+         * .background(GuiTextures.BUTTON, IKey.dynamic(() -> "Button " + this.val)))
+         * .child(SlotGroup.playerInventory())
+         * .child(new FluidSlot().flex(flex -> flex
+         * .top(30)
+         * .left(0.5f))
+         * .setSynced("fluid_slot"));
+         */
+        // spotless:on
+    }
+
+    private IWidget createSchemaPage(GuiData data) {
+        ParentWidget<?> page = new ParentWidget<>();
+        page.name("Page 5 schema");
+        page.sizeRel(1f);
+        page.child(IKey.str("Schema").asWidget());
+
+        if (getLevel().isClientSide()) {
+            page.child(new SchemaWidget(
+                    new SchemaRenderer(ArraySchema.of(data.getPlayer(), 20))
+                            .highlightRenderer(
+                                    new BlockHighlight(Color.withAlpha(Color.GREEN.brighter(1), 0.9f), 1 / 32f))
+            /* .isometric(true) */)
+                    .pos(20, 20)
+                    .size(100, 100));
+        }
+
+        return page;
+    }
+
+    public ModularPanel<?> openSecondWindow(PanelSyncManager syncManager, IPanelHandler syncHandler) {
+        ModularPanel<?> panel = new Dialog<>("second_window")
+                .disablePanelsBelow(false)
+                .closeOnOutOfBoundsClick(false)
+                .draggable(true)
+                .size(100, 100)
+                .resizeableOnDrag(true);
+        SlotGroup slotGroup = new SlotGroup("small_inv", 2);
+        IntSyncValue timeSync = new IntSyncValue(() -> (int) java.lang.System.currentTimeMillis());
+        syncManager.syncValue(123456, timeSync);
+        syncManager.registerSlotGroup(slotGroup);
+        AtomicInteger number = new AtomicInteger(0);
+        syncManager.syncValue("int_value", new IntSyncValue(number::get, number::set));
+        IPanelHandler panelSyncHandler = syncManager.syncedPanel("other_panel_2", true,
+                (syncManager1, syncHandler1) -> openThirdWindow(syncManager1, syncHandler1, number));
+        IntSyncValue num = syncManager.getHyperVisor().findSyncHandler("cycle_state", IntSyncValue.class);
+        panel.child(ButtonWidget.panelCloseButton())
+                .child(new ButtonWidget<>()
+                        .size(10).top(14).right(4)
+                        .overlay((new FluidDrawable().setFluid(GTMaterials.Iron.getFluid(200))), IKey.str("3"))
+                        .size(50, 50)
+                        .onMousePressed((mouseX, mouseY, mouseButton) -> {
+                            panelSyncHandler.openPanel();
+                            return true;
+                        }))
+                .child(IKey.str("2nd Panel")
+                        .asWidget()
+                        .pos(5, 5))
+                .child(SlotGroupWidget.builder()
+                        .row("II")
+                        .row("II")
+                        .key('I', i -> new ItemSlot().slot(new ModularSlot(smallInv, i).slotGroup(slotGroup)))
+                        .build()
+                        .center())
+                .child(new CycleButtonWidget()
+                        .size(16).pos(5, 5 + 11)
+                        .value(num)
+                        .stateOverlay(0, IKey.str("1"))
+                        .stateOverlay(1, IKey.str("2"))
+                        .stateOverlay(2, IKey.str("3"))
+                        .addTooltipLine(IKey.str("Hyper Visor test")))
+                .child(new ButtonWidget<>()
+                        .bottom(5)
+                        .right(5)
+                        .tooltip(richTooltip -> richTooltip.textColor(Color.RED.main).add("WARNING! Very Dangerous"))
+                        .onMousePressed((mouseX, mouseY, mouseButton) -> {
+                            if (!panelSyncHandler.isPanelOpen()) {
+                                panelSyncHandler.deleteCachedPanel();
+                                number.incrementAndGet();
+                            }
+                            return true;
+                        }));
+        return panel;
+    }
+
+    public ModularPanel<?> openThirdWindow(PanelSyncManager syncManager, IPanelHandler syncHandler,
+                                           AtomicInteger integer) {
+        ModularPanel<?> panel = new Dialog<>("third_window")
+                .disablePanelsBelow(false)
+                .closeOnOutOfBoundsClick(false)
+                .draggable(true)
+                .size(50, 50);
+        panel.child(ButtonWidget.panelCloseButton())
+                .child(IKey.str("3rd Panel: " + integer.get())
+                        .asWidget()
+                        .pos(5, 17));
+        return panel;
+    }
+
+    public void buildDialog(Dialog<String, ?> dialog) {
+        AtomicReference<String> value = new AtomicReference<>("");
+        dialog.draggable(true);
+        dialog.child(new TextFieldWidget()
+                .resizer(flex -> flex.size(100, 20).center())
+                .value(new StringValue.Dynamic(value::get, value::set)))
+                .child(new ButtonWidget<>()
+                        .resizer(flex -> flex.size(8, 8).top(5).right(5))
+                        .overlay(IKey.str("x"))
+                        .onMousePressed((x, y, mouseButton) -> {
+                            dialog.closeWith(value.get());
+                            return true;
+                        }));
+    }
+
+    @Override
+    public void clientTick() {
+        if (this.time++ % 20 == 0) {
+            this.val++;
+        }
+        if (++this.progress == this.duration) {
+            this.progress = 0;
+        }
+    }
+
+    public @NotNull ModularPanel<?> buildSearchTest(ModularGuiContext context) {
+        List<String> items = Arrays.asList("Chicken", "Jockey", "Flint", "Steel", "Steve", "Diamond", "Ingot", "Iron",
+                "Armor", "Greg");
+        StringValue searchValue = new StringValue("");
+        return ModularPanel.defaultPanel("search", 100, 150)
+                .child(Flow.column()
+                        .padding(5)
+                        .child(new TextFieldWidget()
+                                .value(searchValue)
+                                .height(16)
+                                .widthRel(1f))
+                        .child(new ListWidget<>()
+                                .collapseDisabledChildren()
+                                .expanded()
+                                .widthRel(1f)
+                                .children(items.size(), i -> new TextWidget<>(IKey.str(items.get(i)))
+                                        .alignment(Alignment.Center)
+                                        .color(Color.WHITE.main)
+                                        .widthRel(1f)
+                                        .height(16)
+                                        .background(GuiTextures.MC_BUTTON)
+                                        .setEnabledIf(w -> items.get(i).toLowerCase()
+                                                .contains(searchValue.getStringValue())))));
+    }
+
+    public void tick() {
+        if (this.time++ % 20 == 0) {
+            if (++this.val2 == 3) this.val2 = 0;
+            Collection<Item> vals = ForgeRegistries.ITEMS.getValues();
+            Item item = vals.stream().skip(new Random().nextInt(vals.size())).findFirst().orElse(Items.DIAMOND);
+            this.displayItem = new ItemStack(item, 26735987);
+
+            Random rnd = new Random();
+            this.serverInts.clear();
+            for (int i = 0; i < 5; i++) {
+                this.serverInts.add(rnd.nextInt(100));
+            }
+        }
+        if (++this.progress == this.duration) {
+            this.progress = 0;
+        }
+    }
+
+    private static class SpecialButton extends ButtonWidget<SpecialButton> {
+
+        private final AnimatedText animatedKey;
+
+        private SpecialButton(AnimatedText animatedKey) {
+            this.animatedKey = animatedKey.stopAnimation().forward(true);
+            this.animatedKey.reset();
+        }
+
+        @Override
+        public void draw(ModularGuiContext context, WidgetThemeEntry<?> widgetTheme) {
+            this.animatedKey.draw(context, 0, 0, getArea().w(), getArea().h(),
+                    getActiveWidgetTheme(widgetTheme, isHovering()));
+        }
+
+        @Override
+        public void onMouseStartHover() {
+            super.onMouseStartHover();
+            this.animatedKey.startAnimation().forward(true);
+        }
+
+        @Override
+        public void onMouseEndHover() {
+            super.onMouseEndHover();
+            this.animatedKey.forward(false);
+        }
+    }
+}
diff --git a/src/main/java/com/gregtechceu/gtceu/common/machine/muimachine/TestMuiMachine2.java b/src/main/java/com/gregtechceu/gtceu/common/machine/muimachine/TestMuiMachine2.java
new file mode 100644
index 00000000000..6f8a7d0152f
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/common/machine/muimachine/TestMuiMachine2.java
@@ -0,0 +1,98 @@
+package com.gregtechceu.gtceu.common.machine.muimachine;
+
+import com.gregtechceu.gtceu.api.blockentity.BlockEntityCreationInfo;
+import com.gregtechceu.gtceu.api.machine.MetaMachine;
+import com.gregtechceu.gtceu.api.machine.TickableSubscription;
+import com.gregtechceu.gtceu.api.machine.feature.IMuiMachine;
+import com.gregtechceu.gtceu.api.sync_system.annotations.SyncToClient;
+
+import net.minecraft.network.chat.Component;
+import net.minecraft.util.Mth;
+
+import brachy.modularui.api.drawable.IKey;
+import brachy.modularui.drawable.Rectangle;
+import brachy.modularui.drawable.graph.GraphDrawable;
+import brachy.modularui.factory.PosGuiData;
+import brachy.modularui.screen.ModularPanel;
+import brachy.modularui.screen.UISettings;
+import brachy.modularui.utils.Alignment;
+import brachy.modularui.utils.Color;
+import brachy.modularui.utils.math.DAM;
+import brachy.modularui.value.sync.IntSyncValue;
+import brachy.modularui.value.sync.PanelSyncManager;
+import brachy.modularui.widget.ParentWidget;
+import brachy.modularui.widgets.ButtonWidget;
+import brachy.modularui.widgets.layout.Flow;
+import org.jetbrains.annotations.NotNull;
+
+public class TestMuiMachine2 extends MetaMachine implements IMuiMachine {
+
+    private TickableSubscription sub;
+
+    public TestMuiMachine2(BlockEntityCreationInfo info) {
+        super(info);
+        sub = subscribeServerTick(this::tick);
+    }
+
+    @SyncToClient
+    private int val = 0;
+
+    @Override
+    public void buildMainUI(ParentWidget<?> mainWidget, PosGuiData guiData, PanelSyncManager syncManager,
+                            UISettings settings) {
+        IntSyncValue valSync = new IntSyncValue(() -> this.val, (v) -> {});
+        syncManager.syncValue("valSync", valSync);
+
+        double[] x = DAM.linspace(-25, 25, 200);
+        double[] y = DAM.div(DAM.sin(x, null), x, null);
+        double[] y2 = DAM.cos(x, null);
+
+        // return buildAspectRatioUI();
+
+        mainWidget
+                .child(new ButtonWidget<>()
+                        .size(60, 18)
+                        .overlay(IKey.dynamic(() -> Component
+                                .literal("Button " + val))))
+                .child(new GraphDrawable()
+                        .yLim(-1.2f, 1.2f)
+                        .xTickFinder(Mth.HALF_PI, 1)
+                        .yTickFinder(0.2f, 1)
+                        .plot(x, y)
+                        .plot(x, y2)
+                        .graphAspectRatio(16 / 9f)
+                        .asWidget().top(50).size(200, 200));
+    }
+
+    public static @NotNull ModularPanel<?> buildAspectRatioUI() {
+        return new ModularPanel<>("aspect_ratio")
+                .coverChildren()
+                .padding(10)
+                .child(Flow.row()
+                        .childPadding(10)
+                        .coverChildren()
+                        .child(new Rectangle().color(Color.BLUE_ACCENT.main)
+                                .asIcon().aspectRatio(4f / 3)
+                                .asWidget().size(80)
+                                .overlay(IKey.str("4:3 Free")))
+                        .child(new Rectangle().color(Color.RED_ACCENT.main)
+                                .asIcon().aspectRatio(4f / 3).width(70)
+                                .asWidget().size(80)
+                                .overlay(IKey.str("4:3 | width = 70")))
+                        .child(new Rectangle().color(Color.LIGHT_GREEN.main)
+                                .asIcon().aspectRatio(4f / 3).height(45).alignment(Alignment.BottomRight)
+                                .asWidget().size(80)
+                                .overlay(IKey.str("4:3 | height = 45\nBottom Right"))))
+                .overlay();
+    }
+
+    @Override
+    public void clientTick() {
+        super.clientTick();
+    }
+
+    public void tick() {
+        val++;
+        syncDataHolder.markClientSyncFieldDirty("val");
+    }
+}
diff --git a/src/main/java/com/gregtechceu/gtceu/common/machine/multiblock/electric/ActiveTransformerMachine.java b/src/main/java/com/gregtechceu/gtceu/common/machine/multiblock/electric/ActiveTransformerMachine.java
index 4b7054160a0..b8ecb60456f 100644
--- a/src/main/java/com/gregtechceu/gtceu/common/machine/multiblock/electric/ActiveTransformerMachine.java
+++ b/src/main/java/com/gregtechceu/gtceu/common/machine/multiblock/electric/ActiveTransformerMachine.java
@@ -5,12 +5,8 @@
 import com.gregtechceu.gtceu.api.capability.IEnergyContainer;
 import com.gregtechceu.gtceu.api.capability.recipe.EURecipeCapability;
 import com.gregtechceu.gtceu.api.capability.recipe.IO;
-import com.gregtechceu.gtceu.api.gui.GuiTextures;
-import com.gregtechceu.gtceu.api.gui.fancy.FancyMachineUIWidget;
 import com.gregtechceu.gtceu.api.machine.ConditionalSubscriptionHandler;
 import com.gregtechceu.gtceu.api.machine.MetaMachine;
-import com.gregtechceu.gtceu.api.machine.feature.IFancyUIMachine;
-import com.gregtechceu.gtceu.api.machine.feature.multiblock.IDisplayUIMachine;
 import com.gregtechceu.gtceu.api.machine.feature.multiblock.IMultiPart;
 import com.gregtechceu.gtceu.api.machine.multiblock.PartAbility;
 import com.gregtechceu.gtceu.api.machine.multiblock.WorkableElectricMultiblockMachine;
@@ -21,14 +17,18 @@
 import com.gregtechceu.gtceu.utils.FormattingUtil;
 import com.gregtechceu.gtceu.utils.GTUtil;
 
-import com.lowdragmc.lowdraglib.gui.modular.ModularUI;
-import com.lowdragmc.lowdraglib.gui.widget.*;
-
+import net.minecraft.ChatFormatting;
 import net.minecraft.MethodsReturnNonnullByDefault;
 import net.minecraft.network.chat.Component;
-import net.minecraft.world.entity.player.Player;
+import net.minecraft.network.chat.HoverEvent;
+import net.minecraft.network.chat.Style;
 import net.minecraft.world.level.block.Block;
 
+import brachy.modularui.api.drawable.IKey;
+import brachy.modularui.api.widget.IWidget;
+import brachy.modularui.value.sync.BooleanSyncValue;
+import brachy.modularui.value.sync.LongSyncValue;
+import brachy.modularui.value.sync.PanelSyncManager;
 import it.unimi.dsi.fastutil.longs.Long2ObjectMap;
 import it.unimi.dsi.fastutil.longs.Long2ObjectMaps;
 import org.jetbrains.annotations.NotNull;
@@ -44,7 +44,7 @@
 @ParametersAreNonnullByDefault
 @MethodsReturnNonnullByDefault
 public class ActiveTransformerMachine extends WorkableElectricMultiblockMachine
-                                      implements IControllable, IFancyUIMachine, IDisplayUIMachine {
+                                      implements IControllable {
 
     private IEnergyContainer powerOutput;
     private IEnergyContainer powerInput;
@@ -168,54 +168,97 @@ public static TraceabilityPredicate getHatchPredicates() {
                 .or(abilities(PartAbility.OUTPUT_LASER).setPreviewCount(1));
     }
 
-    @Override
-    public void addDisplayText(List<Component> textList) {
-        // super.addDisplayText(textList); idek what it does stop doing what you do for a minute pls
-        // Assume That the Structure is ALWAYS formed, and has at least 1 In and 1 Out, there is never a case where this
-        // does not occur.
-        if (isFormed()) {
-            if (!isWorkingEnabled()) {
-                textList.add(Component.translatable("gtceu.multiblock.work_paused"));
-            } else if (isActive()) {
-                textList.add(Component.translatable("gtceu.multiblock.running"));
-                textList.add(Component
-                        .translatable("gtceu.multiblock.active_transformer.max_input",
-                                FormattingUtil.formatNumbers(
-                                        Math.abs(powerInput.getInputVoltage() * powerInput.getInputAmperage()))));
-                textList.add(Component
-                        .translatable("gtceu.multiblock.active_transformer.max_output",
-                                FormattingUtil.formatNumbers(
-                                        Math.abs(powerOutput.getOutputVoltage() * powerOutput.getOutputAmperage()))));
-                textList.add(Component
-                        .translatable("gtceu.multiblock.active_transformer.average_in",
-                                FormattingUtil.formatNumbers(Math.abs(powerInput.getInputPerSec() / 20))));
-                textList.add(Component
-                        .translatable("gtceu.multiblock.active_transformer.average_out",
-                                FormattingUtil.formatNumbers(Math.abs(powerOutput.getOutputPerSec() / 20))));
-                if (!ConfigHolder.INSTANCE.machines.harmlessActiveTransformers) {
-                    textList.add(Component
-                            .translatable("gtceu.multiblock.active_transformer.danger_enabled"));
-                }
-            } else {
-                textList.add(Component.translatable("gtceu.multiblock.idling"));
-            }
-        }
-    }
-
-    @Override
-    public @NotNull Widget createUIWidget() {
-        var group = new WidgetGroup(0, 0, 182 + 8, 117 + 8);
-        group.addWidget(new DraggableScrollableWidgetGroup(4, 4, 182, 117).setBackground(getScreenTexture())
-                .addWidget(new LabelWidget(4, 5, self().getBlockState().getBlock().getDescriptionId()))
-                .addWidget(new ComponentPanelWidget(4, 17, this::addDisplayText)
-                        .setMaxWidthLimit(150)
-                        .clickHandler(this::handleDisplayClick)));
-        group.setBackground(GuiTextures.BACKGROUND_INVERSE);
-        return group;
-    }
-
-    @Override
-    public @NotNull ModularUI createUI(@NotNull Player entityPlayer) {
-        return new ModularUI(198, 208, this, entityPlayer).widget(new FancyMachineUIWidget(this, 198, 208));
+    public List<IWidget> getWidgetsForDisplay(PanelSyncManager syncManager) {
+        List<IWidget> widgets = new ArrayList<>();
+
+        BooleanSyncValue isFormed = syncManager.getOrCreateSyncHandler("isFormed", BooleanSyncValue.class,
+                () -> new BooleanSyncValue(this::isFormed));
+        BooleanSyncValue workingEnabled = syncManager.getOrCreateSyncHandler("workingEnabled", BooleanSyncValue.class,
+                () -> new BooleanSyncValue(this.recipeLogic::isWorkingEnabled, this.recipeLogic::setWorkingEnabled));
+        BooleanSyncValue active = syncManager.getOrCreateSyncHandler("isActive", BooleanSyncValue.class,
+                () -> new BooleanSyncValue(this.recipeLogic::isActive));
+
+        // Machine specific sync handlers
+        // These will not be called anywhere else, so we can create them directly instead of using
+        // getOrCreateSyncHandler
+
+        LongSyncValue inputVoltage = new LongSyncValue(this.powerInput::getInputVoltage);
+        syncManager.syncValue("inputVoltage", inputVoltage);
+
+        LongSyncValue outputVoltage = new LongSyncValue(this.powerOutput::getOutputVoltage);
+        syncManager.syncValue("outputVoltage", outputVoltage);
+
+        LongSyncValue inputAmperage = new LongSyncValue(this.powerInput::getInputAmperage);
+        syncManager.syncValue("inputAmperage", inputAmperage);
+
+        LongSyncValue outputAmperage = new LongSyncValue(this.powerOutput::getOutputAmperage);
+        syncManager.syncValue("outputAmperage", outputAmperage);
+
+        LongSyncValue inputPerSec = new LongSyncValue(this.powerInput::getInputPerSec);
+        syncManager.syncValue("inputPerSec", inputPerSec);
+
+        LongSyncValue outputPerSec = new LongSyncValue(this.powerOutput::getOutputPerSec);
+        syncManager.syncValue("outputPerSec", outputPerSec);
+
+        widgets.add(IKey.lang(Component.translatable("gtceu.multiblock.work_paused"))
+                .asWidget()
+                .setEnabledIf((widget) -> isFormed.getBoolValue() && !workingEnabled.getBoolValue()));
+
+        widgets.add(IKey.lang(Component.translatable("gtceu.multiblock.running"))
+                .asWidget()
+                .setEnabledIf(
+                        (widget) -> isFormed.getBoolValue() && workingEnabled.getBoolValue() && active.getBoolValue()));
+
+        widgets.add(IKey.dynamic(() -> Component
+                .translatable("gtceu.multiblock.active_transformer.max_input",
+                        FormattingUtil.formatNumbers(
+                                Math.abs(inputVoltage.getLongValue() * inputAmperage.getLongValue()))))
+                .asWidget()
+                .setEnabledIf(
+                        (widget) -> isFormed.getBoolValue() && workingEnabled.getBoolValue() && active.getBoolValue()));
+
+        widgets.add(IKey.dynamic(() -> Component
+                .translatable("gtceu.multiblock.active_transformer.max_output",
+                        FormattingUtil.formatNumbers(
+                                Math.abs(outputVoltage.getLongValue() * outputAmperage.getLongValue()))))
+                .asWidget()
+                .setEnabledIf(
+                        (widget) -> isFormed.getBoolValue() && workingEnabled.getBoolValue() && active.getBoolValue()));
+
+        widgets.add(IKey.dynamic(() -> Component
+                .translatable("gtceu.multiblock.active_transformer.average_in",
+                        FormattingUtil.formatNumbers(Math.abs(inputPerSec.getLongValue() / 20))))
+                .asWidget()
+                .setEnabledIf(
+                        (widget) -> isFormed.getBoolValue() && workingEnabled.getBoolValue() && active.getBoolValue()));
+
+        widgets.add(IKey.dynamic(() -> Component
+                .translatable("gtceu.multiblock.active_transformer.average_out",
+                        FormattingUtil.formatNumbers(Math.abs(outputPerSec.getLongValue() / 20))))
+                .asWidget()
+                .setEnabledIf(
+                        (widget) -> isFormed.getBoolValue() && workingEnabled.getBoolValue() && active.getBoolValue()));
+
+        widgets.add(IKey.lang(Component.translatable("gtceu.multiblock.active_transformer.danger_enabled"))
+                .asWidget()
+                .setEnabledIf((widget) -> isFormed.getBoolValue() && workingEnabled.getBoolValue() &&
+                        active.getBoolValue() && !ConfigHolder.INSTANCE.machines.harmlessActiveTransformers));
+
+        widgets.add(IKey.lang(Component.translatable("gtceu.multiblock.idling"))
+                .asWidget()
+                .setEnabledIf((widget) -> isFormed.getBoolValue() && workingEnabled.getBoolValue() &&
+                        !active.getBoolValue()));
+
+        widgets.add(IKey.dynamic(() -> {
+            Component tooltip = Component.translatable("gtceu.multiblock.invalid_structure.tooltip")
+                    .withStyle(ChatFormatting.GRAY);
+            return Component.translatable("gtceu.multiblock.invalid_structure")
+                    .withStyle(Style.EMPTY.withColor(ChatFormatting.RED)
+                            .withHoverEvent(new HoverEvent(HoverEvent.Action.SHOW_TEXT, tooltip)));
+        })
+                .asWidget()
+                .setEnabledIf((widget) -> !isFormed.getBoolValue()));
+
+        return widgets;
     }
 }
diff --git a/src/main/java/com/gregtechceu/gtceu/common/machine/multiblock/electric/BedrockOreMinerMachine.java b/src/main/java/com/gregtechceu/gtceu/common/machine/multiblock/electric/BedrockOreMinerMachine.java
index d9a18b67000..f46f9cfc7ef 100644
--- a/src/main/java/com/gregtechceu/gtceu/common/machine/multiblock/electric/BedrockOreMinerMachine.java
+++ b/src/main/java/com/gregtechceu/gtceu/common/machine/multiblock/electric/BedrockOreMinerMachine.java
@@ -7,7 +7,6 @@
 import com.gregtechceu.gtceu.api.capability.recipe.EURecipeCapability;
 import com.gregtechceu.gtceu.api.capability.recipe.IO;
 import com.gregtechceu.gtceu.api.data.tag.TagPrefix;
-import com.gregtechceu.gtceu.api.data.worldgen.bedrockore.WeightedMaterial;
 import com.gregtechceu.gtceu.api.machine.feature.ITieredMachine;
 import com.gregtechceu.gtceu.api.machine.multiblock.WorkableElectricMultiblockMachine;
 import com.gregtechceu.gtceu.api.misc.EnergyContainerList;
@@ -15,21 +14,14 @@
 import com.gregtechceu.gtceu.common.data.GTMaterialBlocks;
 import com.gregtechceu.gtceu.common.data.GTMaterials;
 import com.gregtechceu.gtceu.common.machine.trait.BedrockOreMinerLogic;
-import com.gregtechceu.gtceu.utils.FormattingUtil;
 import com.gregtechceu.gtceu.utils.GTUtil;
 
-import net.minecraft.ChatFormatting;
 import net.minecraft.MethodsReturnNonnullByDefault;
-import net.minecraft.network.chat.Component;
-import net.minecraft.network.chat.HoverEvent;
-import net.minecraft.network.chat.Style;
 import net.minecraft.resources.ResourceLocation;
 import net.minecraft.world.level.block.Block;
 
 import lombok.Getter;
 
-import java.util.List;
-
 import javax.annotation.ParametersAreNonnullByDefault;
 
 @ParametersAreNonnullByDefault
@@ -56,47 +48,47 @@ public int getEnergyTier() {
         return Math.min(this.tier + 1, Math.max(this.tier, GTUtil.getFloorTierByVoltage(energyCont.getInputVoltage())));
     }
 
-    @Override
-    public void addDisplayText(List<Component> textList) {
-        if (isFormed()) {
-            int energyContainer = getEnergyTier();
-            long maxVoltage = GTValues.V[energyContainer];
-            String voltageName = GTValues.VNF[energyContainer];
-            textList.add(Component.translatable("gtceu.multiblock.max_energy_per_tick", maxVoltage, voltageName));
-
-            if (getRecipeLogic().getVeinMaterials() != null) {
-                // Ore names
-                textList.add(Component.translatable("gtceu.multiblock.ore_rig.drilled_ores_list")
-                        .withStyle(ChatFormatting.GREEN));
-                List<WeightedMaterial> drilledOres = getRecipeLogic().getVeinMaterials();
-                for (var entry : drilledOres) {
-                    Component fluidInfo = entry.material().getLocalizedName().withStyle(ChatFormatting.GREEN);
-                    textList.add(Component.translatable("gtceu.multiblock.ore_rig.drilled_ore_entry", fluidInfo)
-                            .withStyle(ChatFormatting.GRAY));
-                }
-
-                // Ore amount
-                Component amountInfo = Component.literal(FormattingUtil.formatNumbers(
-                        getRecipeLogic().getOreToProduce() * 20L / BedrockOreMinerLogic.MAX_PROGRESS) +
-                        "/s").withStyle(ChatFormatting.BLUE);
-                textList.add(Component.translatable("gtceu.multiblock.ore_rig.ore_amount", amountInfo)
-                        .withStyle(ChatFormatting.GRAY));
-            } else {
-                Component noOre = Component.translatable("gtceu.multiblock.fluid_rig.no_fluid_in_area")
-                        .withStyle(ChatFormatting.RED);
-                textList.add(Component.translatable("gtceu.multiblock.ore_rig.drilled_ores_list")
-                        .withStyle(ChatFormatting.GREEN));
-                textList.add(Component.translatable("gtceu.multiblock.ore_rig.drilled_ore_entry", noOre)
-                        .withStyle(ChatFormatting.GRAY));
-            }
-        } else {
-            Component tooltip = Component.translatable("gtceu.multiblock.invalid_structure.tooltip")
-                    .withStyle(ChatFormatting.GRAY);
-            textList.add(Component.translatable("gtceu.multiblock.invalid_structure")
-                    .withStyle(Style.EMPTY.withColor(ChatFormatting.RED)
-                            .withHoverEvent(new HoverEvent(HoverEvent.Action.SHOW_TEXT, tooltip))));
-        }
-    }
+    // @Override
+    // public void addDisplayText(List<Component> textList) {
+    // if (isFormed()) {
+    // int energyContainer = getEnergyTier();
+    // long maxVoltage = GTValues.V[energyContainer];
+    // String voltageName = GTValues.VNF[energyContainer];
+    // textList.add(Component.translatable("gtceu.multiblock.max_energy_per_tick", maxVoltage, voltageName));
+    //
+    // if (getRecipeLogic().getVeinMaterials() != null) {
+    // // Ore names
+    // textList.add(Component.translatable("gtceu.multiblock.ore_rig.drilled_ores_list")
+    // .withStyle(ChatFormatting.GREEN));
+    // List<WeightedMaterial> drilledOres = getRecipeLogic().getVeinMaterials();
+    // for (var entry : drilledOres) {
+    // Component fluidInfo = entry.material().getLocalizedName().withStyle(ChatFormatting.GREEN);
+    // textList.add(Component.translatable("gtceu.multiblock.ore_rig.drilled_ore_entry", fluidInfo)
+    // .withStyle(ChatFormatting.GRAY));
+    // }
+    //
+    // // Ore amount
+    // Component amountInfo = Component.literal(FormattingUtil.formatNumbers(
+    // getRecipeLogic().getOreToProduce() * 20L / BedrockOreMinerLogic.MAX_PROGRESS) +
+    // "/s").withStyle(ChatFormatting.BLUE);
+    // textList.add(Component.translatable("gtceu.multiblock.ore_rig.ore_amount", amountInfo)
+    // .withStyle(ChatFormatting.GRAY));
+    // } else {
+    // Component noOre = Component.translatable("gtceu.multiblock.fluid_rig.no_fluid_in_area")
+    // .withStyle(ChatFormatting.RED);
+    // textList.add(Component.translatable("gtceu.multiblock.ore_rig.drilled_ores_list")
+    // .withStyle(ChatFormatting.GREEN));
+    // textList.add(Component.translatable("gtceu.multiblock.ore_rig.drilled_ore_entry", noOre)
+    // .withStyle(ChatFormatting.GRAY));
+    // }
+    // } else {
+    // Component tooltip = Component.translatable("gtceu.multiblock.invalid_structure.tooltip")
+    // .withStyle(ChatFormatting.GRAY);
+    // textList.add(Component.translatable("gtceu.multiblock.invalid_structure")
+    // .withStyle(Style.EMPTY.withColor(ChatFormatting.RED)
+    // .withHoverEvent(new HoverEvent(HoverEvent.Action.SHOW_TEXT, tooltip))));
+    // }
+    // }
 
     public static int getDepletionChance(int tier) {
         if (tier == GTValues.MV)
diff --git a/src/main/java/com/gregtechceu/gtceu/common/machine/multiblock/electric/CentralMonitorMachine.java b/src/main/java/com/gregtechceu/gtceu/common/machine/multiblock/electric/CentralMonitorMachine.java
index 73c81b133a4..75274b71e9e 100644
--- a/src/main/java/com/gregtechceu/gtceu/common/machine/multiblock/electric/CentralMonitorMachine.java
+++ b/src/main/java/com/gregtechceu/gtceu/common/machine/multiblock/electric/CentralMonitorMachine.java
@@ -1,18 +1,13 @@
 package com.gregtechceu.gtceu.common.machine.multiblock.electric;
 
-import com.gregtechceu.gtceu.GTCEu;
 import com.gregtechceu.gtceu.api.blockentity.BlockEntityCreationInfo;
 import com.gregtechceu.gtceu.api.capability.GTCapabilityHelper;
 import com.gregtechceu.gtceu.api.capability.IMonitorComponent;
 import com.gregtechceu.gtceu.api.capability.recipe.IO;
-import com.gregtechceu.gtceu.api.gui.GuiTextures;
-import com.gregtechceu.gtceu.api.gui.widget.IntInputWidget;
-import com.gregtechceu.gtceu.api.gui.widget.SlotWidget;
 import com.gregtechceu.gtceu.api.item.IComponentItem;
 import com.gregtechceu.gtceu.api.item.component.IItemComponent;
 import com.gregtechceu.gtceu.api.item.component.IMonitorModuleItem;
 import com.gregtechceu.gtceu.api.machine.feature.IDataInfoProvider;
-import com.gregtechceu.gtceu.api.machine.multiblock.MultiblockDisplayText;
 import com.gregtechceu.gtceu.api.machine.multiblock.PartAbility;
 import com.gregtechceu.gtceu.api.machine.multiblock.WorkableElectricMultiblockMachine;
 import com.gregtechceu.gtceu.api.misc.EnergyContainerList;
@@ -26,33 +21,24 @@
 import com.gregtechceu.gtceu.common.item.behavior.PortableScannerBehavior;
 import com.gregtechceu.gtceu.common.machine.multiblock.electric.monitor.MonitorGroup;
 import com.gregtechceu.gtceu.common.machine.trait.CentralMonitorLogic;
+import com.gregtechceu.gtceu.common.mui.GTGuiTextures;
 import com.gregtechceu.gtceu.common.network.GTNetwork;
 import com.gregtechceu.gtceu.common.network.packets.SCPacketMonitorGroupNBTChange;
-import com.gregtechceu.gtceu.data.lang.LangHandler;
-import com.gregtechceu.gtceu.utils.GTStringUtils;
-import com.gregtechceu.gtceu.utils.GTUtil;
-
-import com.lowdragmc.lowdraglib.gui.texture.*;
-import com.lowdragmc.lowdraglib.gui.widget.*;
 
 import net.minecraft.MethodsReturnNonnullByDefault;
 import net.minecraft.core.BlockPos;
 import net.minecraft.core.Direction;
 import net.minecraft.network.chat.Component;
-import net.minecraft.util.Mth;
 import net.minecraft.world.entity.player.Player;
 import net.minecraft.world.item.ItemStack;
 import net.minecraft.world.level.Level;
-import net.minecraftforge.items.IItemHandler;
 
+import brachy.modularui.api.drawable.IDrawable;
 import lombok.Getter;
-import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 
-import java.awt.*;
 import java.util.*;
 import java.util.List;
-import java.util.function.Consumer;
 import java.util.stream.Stream;
 
 import javax.annotation.ParametersAreNonnullByDefault;
@@ -68,11 +54,9 @@ public class CentralMonitorMachine extends WorkableElectricMultiblockMachine
     private int leftDist = 0, rightDist = 0, upDist = 0, downDist = 0;
     @SaveField
     @SyncToClient
-    @Getter
     @RerenderOnChanged
+    @Getter
     private List<MonitorGroup> monitorGroups = new ArrayList<>();
-    private final Set<IMonitorComponent> selectedComponents = new HashSet<>();
-    private final List<IMonitorComponent> selectedTargets = new ArrayList<>();
 
     private @Nullable MultiblockState patternFindingState;
 
@@ -134,6 +118,8 @@ public void tick() {
                         new SCPacketMonitorGroupNBTChange(stack, group, this));
             }
         }
+        getSyncDataHolder().markClientSyncFieldDirty("monitorGroups");
+        recipeLogic.getSyncDataHolder().markClientSyncFieldDirty("status");
     }
 
     @Override
@@ -205,6 +191,10 @@ public void updateStructureDimensions() {
             posDown.move(down);
             downDist++;
         }
+        getSyncDataHolder().markClientSyncFieldDirty("leftDist");
+        getSyncDataHolder().markClientSyncFieldDirty("rightDist");
+        getSyncDataHolder().markClientSyncFieldDirty("upDist");
+        getSyncDataHolder().markClientSyncFieldDirty("downDist");
     }
 
     private boolean isValidMonitorBlockRow(Level level, BlockPos pos, int leftDist, int rightDist, Direction left,
@@ -283,383 +273,26 @@ public IMonitorComponent getComponent(int row, int col) {
         return GTCapabilityHelper.getMonitorComponent(level, pos, null);
     }
 
-    public boolean isMonitor(int row, int col) {
-        IMonitorComponent component = this.getComponent(row, col);
-        if (component == null) return false;
-        return component.isMonitor();
-    }
-
-    private IGuiTexture getComponentTexture(int row, int col) {
-        if (row < 0 || col < 0 || row > downDist + upDist + 1 || col > leftDist + rightDist + 1)
-            return GuiTextures.BLANK_TRANSPARENT;
-        IMonitorComponent component = getComponent(row, col);
-        if (component == null) return GuiTextures.BLANK_TRANSPARENT;
-        return component.getComponentIcon();
-    }
-
-    private boolean isInAnyGroup(IMonitorComponent component) {
-        return monitorGroups.stream().anyMatch(group -> group.contains(component.getBlockPos()));
-    }
-
-    @Override
-    public void addDisplayText(List<Component> textList) {
-        MultiblockDisplayText.builder(textList, isFormed())
-                .addWorkingStatusLine();
-        getDefinition().getAdditionalDisplay().accept(this, textList);
-    }
-
-    @Override
-    public Widget createUIWidget() {
-        updateStructureDimensions();
-        selectedComponents.clear();
-        WidgetGroup builder = (WidgetGroup) super.createUIWidget();
-
-        WidgetGroup main = new WidgetGroup();
-        DraggableScrollableWidgetGroup componentSelection = new DraggableScrollableWidgetGroup(0, 10, 200, 110);
-        main.addWidget(componentSelection);
-        WidgetGroup options = new WidgetGroup(-100, 20, 60, 20);
-        WidgetGroup groupConfig = new WidgetGroup(10, 30, 100, 100);
-        groupConfig.setVisible(false);
-
-        ButtonWidget infoWidget = new ButtonWidget(200, 10, 20, 20, null);
-        infoWidget.setButtonTexture(GuiTextures.INFO_ICON);
-        infoWidget.setHoverTooltips(
-                GTStringUtils.toImmutable(LangHandler.getSingleOrMultiLang("gtceu.central_monitor.info_tooltip")));
-        builder.addWidget(infoWidget);
-        List<@Nullable MonitorGroup> configGroup = new ArrayList<>();
-        configGroup.add(null);
-
-        Consumer<@Nullable MonitorGroup> openGroupConfig = (group) -> {
-            configGroup.set(0, group);
-            if (group == null) {
-                main.setVisible(true);
-                groupConfig.setVisible(false);
-                return;
-            }
-            groupConfig.clearAllWidgets();
-            groupConfig.addWidget(new LabelWidget(0, 5, () -> {
-                String currentName = "";
-                if (configGroup.get(0) != null) {
-                    currentName = configGroup.get(0).getName();
-                }
-                return Component.translatable("gtceu.central_monitor.gui.currently_editing", currentName).getString();
-            }));
-            for (int i = 0; i < 8; i++) {
-                SlotWidget slot = new SlotWidget(group.getPlaceholderSlotsHandler(), i, -38, 16 * i + 46);
-                slot.setHoverTooltips(GTStringUtils
-                        .toImmutable(LangHandler.getMultiLang("gtceu.gui.computer_monitor_cover.slot_tooltip", i + 1)));
-                groupConfig.addWidget(slot);
-            }
-            SlotWidget slot = new SlotWidget(
-                    group.getItemStackHandler(), 0,
-                    0, 20);
-            WidgetGroup itemUI = new WidgetGroup(40, 20, 100, 100);
-            Runnable changeListener = () -> {
-                if (slot.getLastItem().is(slot.getItem().getItem())) return;
-                itemUI.clearAllWidgets();
-                if (slot.getItem().getItem() instanceof IComponentItem item) {
-                    for (IItemComponent component : item.getComponents()) {
-                        if (component instanceof IMonitorModuleItem module) {
-                            itemUI.addWidget(module.createUIWidget(slot.getItem(), this, group));
-                        }
-                    }
-                }
-            };
-            slot.setChangeListener(changeListener);
-            changeListener.run();
-            groupConfig.addWidget(itemUI);
-            groupConfig.addWidget(slot);
-            main.setVisible(false);
-            groupConfig.setVisible(true);
-        };
-        builder.addWidget(groupConfig);
-        DraggableScrollableWidgetGroup groupList = new DraggableScrollableWidgetGroup(-100, 50, 70, 80);
-
-        List<List<Consumer<Iterator<IMonitorComponent>>>> imageButtons = new ArrayList<>();
-        Map<BlockPos, Runnable> rightClickCallbacks = new HashMap<>();
-        int[] dataSlot = new int[2]; // list to be able to modify it in lambdas
-        dataSlot[0] = 1; // the slot (index starts from 1)
-        dataSlot[1] = 9; // amount of slots
-        IntInputWidget dataSlotInput = new IntInputWidget(120, 20, 60, -20, () -> dataSlot[0],
-                n -> dataSlot[0] = Mth.clamp(n, 1, dataSlot[1]));
-        dataSlotInput.setVisible(false);
-        builder.addWidget(dataSlotInput);
-
-        Consumer<MonitorGroup> addGroupToList = group -> {
-            ButtonWidget label = new ButtonWidget(20, groupList.widgets.size() * 15 + 5, 60, 10, null);
-            TextTexture text = new TextTexture(group.getName());
-            text.setType(TextTexture.TextType.LEFT);
-            label.setButtonTexture(text);
-            label.setOnPressCallback(click -> {
-                group.getMonitorPositions().forEach(pos -> {
-                    BlockPos rel = toRelative(pos);
-                    if (imageButtons.size() - 1 < rel.getY()) return;
-                    if (imageButtons.get(rel.getY()).size() - 1 < rel.getX()) return;
-                    imageButtons.get(rel.getY()).get(rel.getX()).accept(null);
-                });
-                if (group.getTargetRaw() != null) {
-                    rightClickCallbacks.getOrDefault(group.getTargetRaw(), () -> {}).run();
-                }
-            });
-            groupList.addWidget(label);
-
-            ButtonWidget configButton = new ButtonWidget(
-                    0, label.getSelfPositionY() - 3,
-                    16, 16,
-                    GuiTextures.IO_CONFIG_COVER_SETTINGS,
-                    click -> {
-                        if (configGroup.get(0) == null) {
-                            openGroupConfig.accept(group);
-                        } else {
-                            openGroupConfig.accept(null);
-                        }
-                    });
-            groupList.addWidget(configButton);
-        };
-
-        monitorGroups.forEach(addGroupToList);
-        builder.addWidget(groupList);
-        main.addWidget(options);
-        ButtonWidget removeFromGroupButton = new ButtonWidget(0, 0, 60, 20, null);
-        removeFromGroupButton.setButtonTexture(new TextTexture("gtceu.central_monitor.gui.remove_from_group"));
-        removeFromGroupButton.setVisible(false);
-        ButtonWidget setTargetButton = new ButtonWidget(0, 15, 60, 20, null);
-        setTargetButton.setButtonTexture(new TextTexture("gtceu.central_monitor.gui.set_target"));
-        setTargetButton.setVisible(false);
-        ButtonWidget createGroupButton = new ButtonWidget(0, 0, 60, 20, null);
-        createGroupButton.setOnPressCallback(click -> {
-            MonitorGroup group = new MonitorGroup(
-                    Component.translatable("gtceu.gui.central_monitor.group_default_name", monitorGroups.size() + 1)
-                            .getString());
-            for (IMonitorComponent component : selectedComponents) {
-                if (isInAnyGroup(component)) return;
-                group.add(component.getBlockPos());
-            }
-            monitorGroups.add(group);
-            addGroupToList.accept(group);
-
-            createGroupButton.setVisible(false);
-            removeFromGroupButton.setVisible(true);
-            Iterator<IMonitorComponent> it = selectedComponents.iterator();
-            while (it.hasNext()) {
-                IMonitorComponent c = it.next();
-                BlockPos rel = toRelative(c.getBlockPos());
-                imageButtons.get(rel.getY()).get(rel.getX()).accept(it);
-            }
-            if (!selectedTargets.isEmpty()) {
-                rightClickCallbacks.getOrDefault(selectedTargets.get(0).getBlockPos(), () -> {}).run();
-            }
-        });
-        setTargetButton.setOnPressCallback(click -> {
-            MonitorGroup group = null;
-            for (MonitorGroup group2 : monitorGroups) {
-                for (IMonitorComponent component : selectedComponents) {
-                    if (group2.contains(component.getBlockPos())) {
-                        group = group2;
-                        break;
-                    }
-                }
-                if (group != null) break;
-            }
-            if (group == null) return;
-            if (selectedTargets.isEmpty()) group.setTarget(null);
-            else {
-                group.setTarget(selectedTargets.get(0).getBlockPos());
-                group.setDataSlot(dataSlot[0] - 1);
-            }
-        });
-        removeFromGroupButton.setOnPressCallback(click -> {
-            for (MonitorGroup group : monitorGroups) {
-                for (IMonitorComponent component : selectedComponents) group.remove(component.getBlockPos());
-            }
-            Iterator<MonitorGroup> itg = monitorGroups.iterator();
-            while (itg.hasNext()) {
-                MonitorGroup group = itg.next();
-                if (group.isEmpty()) {
-                    group.getItemStackHandler().dropInventoryInWorld(getLevel(), getBlockPos());
-                    group.getPlaceholderSlotsHandler().dropInventoryInWorld(getLevel(), getBlockPos());
-                    itg.remove();
-                }
-            }
-            groupList.clearAllWidgets();
-            monitorGroups.forEach(addGroupToList);
-
-            removeFromGroupButton.setVisible(false);
-            createGroupButton.setVisible(true);
-            Iterator<IMonitorComponent> it = selectedComponents.iterator();
-            while (it.hasNext()) {
-                IMonitorComponent c = it.next();
-                BlockPos rel = toRelative(c.getBlockPos());
-                if (imageButtons.size() - 1 < rel.getY()) continue;
-                if (imageButtons.get(rel.getY()).size() - 1 < rel.getX()) continue;
-                imageButtons.get(rel.getY()).get(rel.getX()).accept(it);
-            }
-            if (!selectedTargets.isEmpty()) {
-                rightClickCallbacks.getOrDefault(selectedTargets.get(0).getBlockPos(), () -> {}).run();
-            }
-        });
-        createGroupButton.setButtonTexture(new TextTexture("gtceu.central_monitor.gui.create_group"));
-        createGroupButton.setVisible(false);
-        options.addWidget(removeFromGroupButton);
-        options.addWidget(createGroupButton);
-        options.addWidget(setTargetButton);
-        int startX = 20;
-        int startY = 30;
-        for (int row = 0; row <= downDist + upDist; row++) {
-            imageButtons.add(new ArrayList<>());
-            for (int col = 0; col <= leftDist + rightDist; col++) {
-                IGuiTexture texture = getComponentTexture(row, col);
-                GuiTextureGroup textures = new GuiTextureGroup(texture, new ColorBorderTexture(2, 0xFFFFFF));
-                IMonitorComponent component = getComponent(row, col);
-                if (component == null) {
-                    GTUtil.getLast(imageButtons).add(it -> {});
-                    continue;
-                }
-                ButtonWidget img = new ButtonWidget(startX + (16 * col), startY + (16 * row), 16, 16, textures, null);
-                Consumer<Iterator<IMonitorComponent>> callback = (it) -> {
-                    if (!component.isMonitor()) return;
-                    if (selectedComponents.contains(component)) {
-                        if (it == null) {
-                            selectedComponents.remove(component);
-                        } else {
-                            it.remove();
-                        }
-
-                        if (!selectedTargets.isEmpty() && selectedTargets.get(0) == component) {
-                            ColorRectTexture rect = new ColorRectTexture(Color.BLUE);
-                            textures.setTextures(rect, texture);
-                        } else {
-                            textures.setTextures(texture);
-                        }
-
-                        createGroupButton.setVisible(selectedComponents.stream().noneMatch(this::isInAnyGroup));
-                        removeFromGroupButton.setVisible(selectedComponents.stream().allMatch(this::isInAnyGroup));
-                        setTargetButton.setVisible(removeFromGroupButton.isVisible());
-
-                        if (selectedComponents.isEmpty()) {
-                            createGroupButton.setVisible(false);
-                            removeFromGroupButton.setVisible(false);
-                            setTargetButton.setVisible(false);
-                        }
-                    } else {
-                        boolean inAnyGroup = isInAnyGroup(component);
-                        // yes I know this is terrible but if it works don't touch it :)
-                        if (selectedComponents.isEmpty() && !inAnyGroup) createGroupButton.setVisible(true);
-                        if (inAnyGroup) createGroupButton.setVisible(false);
-                        if (selectedComponents.isEmpty() && inAnyGroup) {
-                            removeFromGroupButton.setVisible(true);
-                            setTargetButton.setVisible(true);
-                        }
-                        if (!inAnyGroup) {
-                            removeFromGroupButton.setVisible(false);
-                            setTargetButton.setVisible(false);
-                        }
-                        selectedComponents.add(component);
-                        ColorRectTexture rect = new ColorRectTexture(
-                                (selectedTargets.isEmpty() || selectedTargets.get(0) != component) ? Color.RED :
-                                        Color.PINK);
-                        textures.setTextures(rect, texture);
-                    }
-                    if (isInAnyGroup(component)) {
-                        monitorGroups.forEach(group -> {
-                            if (group.contains(component.getBlockPos())) {
-                                img.setHoverTooltips(
-                                        Component.translatable("gtceu.gui.central_monitor.group", group.getName()));
-                            }
-                        });
-                    } else {
-                        img.setHoverTooltips(Component.translatable("gtceu.gui.central_monitor.group",
-                                Component.translatable("gtceu.gui.central_monitor.none")));
-                    }
-                };
-                Runnable rightClickCallback = () -> {
-                    if (!selectedTargets.isEmpty()) {
-                        if (selectedTargets.get(0).getBlockPos() == component.getBlockPos()) {
-                            selectedTargets.clear();
-                            if (selectedComponents.contains(component)) {
-                                ColorRectTexture rect = new ColorRectTexture(Color.RED);
-                                textures.setTextures(rect, texture);
-                            } else {
-                                textures.setTextures(texture);
-                            }
-                            dataSlotInput.setVisible(false);
-                            return;
-                        } else {
-                            try {
-                                rightClickCallbacks.get(selectedTargets.get(0).getBlockPos()).run();
-                            } catch (StackOverflowError e) {
-                                GTCEu.LOGGER.error(
-                                        "Stack overflow when right-clicking monitor component {} at {} (selectedTarget is {} at {})",
-                                        component, component.getBlockPos(), selectedTargets.get(0),
-                                        selectedTargets.get(0).getBlockPos());
-                            }
-                        }
-                    }
-                    selectedTargets.add(component);
-                    ColorRectTexture rect;
-                    if (selectedComponents.contains(component)) {
-                        rect = new ColorRectTexture(Color.PINK);
-                    } else {
-                        rect = new ColorRectTexture(Color.BLUE);
-                    }
-                    textures.setTextures(rect, texture);
-                    if (component.getDataItems() != null) {
-                        IItemHandler dataItems = component.getDataItems();
-                        MonitorGroup selectedGroup = null;
-                        for (MonitorGroup group : monitorGroups) {
-                            for (IMonitorComponent c : selectedComponents) {
-                                if (group.contains(c.getBlockPos())) {
-                                    if (selectedGroup == null || selectedGroup == group) {
-                                        selectedGroup = group;
-                                    } else {
-                                        selectedGroup = null;
-                                        break;
-                                    }
-                                }
-                            }
-                        }
-                        if (selectedGroup != null) {
-                            dataSlot[0] = selectedGroup.getDataSlot() + 1;
-                        }
-                        dataSlot[1] = dataItems.getSlots();
-                        dataSlotInput.setVisible(true);
-                    }
-                };
-                if (isInAnyGroup(component)) {
-                    monitorGroups.forEach(group -> {
-                        if (group.contains(component.getBlockPos())) img.setHoverTooltips(
-                                Component.translatable("gtceu.gui.central_monitor.group", group.getName()));
-                    });
-                } else {
-                    img.setHoverTooltips(Component.translatable("gtceu.gui.central_monitor.group",
-                            Component.translatable("gtceu.gui.central_monitor.none")));
-                }
-                img.setOnPressCallback(click -> {
-                    if (click.button == 0) callback.accept(null);
-                    else if (click.button == 1) rightClickCallback.run();
-                });
-                componentSelection.addWidget(img);
-                GTUtil.getLast(imageButtons).add(callback);
-                rightClickCallbacks.put(component.getBlockPos(), rightClickCallback);
-            }
-        }
-        builder.addWidget(main);
-        return builder;
+    public void setMonitorGroups(List<MonitorGroup> groups) {
+        if (!(monitorGroups instanceof ArrayList<MonitorGroup>)) monitorGroups = new ArrayList<>(monitorGroups);
+        monitorGroups.clear();
+        monitorGroups.addAll(groups);
+        getSyncDataHolder().markClientSyncFieldDirty("monitorGroups");
     }
 
     @Override
-    public IGuiTexture getComponentIcon() {
-        return ResourceTexture.fromSpirit(GTCEu.id("block/multiblock/network_switch/overlay_front_active"));
+    public IDrawable getIcon() {
+        return GTGuiTextures.GREGTECH_LOGO;
     }
 
     @Override
-    public @NotNull List<Component> getDebugInfo(Player player, int logLevel,
-                                                 PortableScannerBehavior.DisplayMode mode) {
+    public List<Component> getDebugInfo(Player player, int logLevel,
+                                        PortableScannerBehavior.DisplayMode mode) {
         return List.of(Component.translatable("gtceu.central_monitor.size", leftDist, rightDist, upDist, downDist));
     }
 
     @Override
-    public @NotNull List<Component> getDataInfo(PortableScannerBehavior.DisplayMode mode) {
+    public List<Component> getDataInfo(PortableScannerBehavior.DisplayMode mode) {
         return List.of(Component.translatable("gtceu.central_monitor.size", leftDist, rightDist, upDist, downDist));
     }
 
diff --git a/src/main/java/com/gregtechceu/gtceu/common/machine/multiblock/electric/CleanroomMachine.java b/src/main/java/com/gregtechceu/gtceu/common/machine/multiblock/electric/CleanroomMachine.java
index b674b5520e0..16418929a3e 100644
--- a/src/main/java/com/gregtechceu/gtceu/common/machine/multiblock/electric/CleanroomMachine.java
+++ b/src/main/java/com/gregtechceu/gtceu/common/machine/multiblock/electric/CleanroomMachine.java
@@ -9,7 +9,6 @@
 import com.gregtechceu.gtceu.api.machine.MetaMachine;
 import com.gregtechceu.gtceu.api.machine.SimpleGeneratorMachine;
 import com.gregtechceu.gtceu.api.machine.feature.IDataInfoProvider;
-import com.gregtechceu.gtceu.api.machine.feature.multiblock.IDisplayUIMachine;
 import com.gregtechceu.gtceu.api.machine.feature.multiblock.IMaintenanceMachine;
 import com.gregtechceu.gtceu.api.machine.feature.multiblock.IMultiPart;
 import com.gregtechceu.gtceu.api.machine.multiblock.CleanroomType;
@@ -35,6 +34,7 @@
 import com.gregtechceu.gtceu.common.machine.trait.CleanroomLogic;
 import com.gregtechceu.gtceu.common.machine.trait.CleanroomProviderTrait;
 import com.gregtechceu.gtceu.common.machine.trait.CleanroomReceiverTrait;
+import com.gregtechceu.gtceu.common.mui.GTMultiblockTextUtil;
 import com.gregtechceu.gtceu.config.ConfigHolder;
 import com.gregtechceu.gtceu.data.recipe.CustomTags;
 import com.gregtechceu.gtceu.utils.GTUtil;
@@ -56,6 +56,14 @@
 import net.minecraft.world.level.block.state.BlockState;
 import net.minecraft.world.level.block.state.properties.DoubleBlockHalf;
 
+import brachy.modularui.api.drawable.IKey;
+import brachy.modularui.api.widget.IWidget;
+import brachy.modularui.value.sync.BooleanSyncValue;
+import brachy.modularui.value.sync.GenericSyncValue;
+import brachy.modularui.value.sync.IntSyncValue;
+import brachy.modularui.value.sync.LongSyncValue;
+import brachy.modularui.value.sync.PanelSyncManager;
+import brachy.modularui.value.sync.StringSyncValue;
 import com.google.common.collect.ImmutableSet;
 import com.google.common.collect.Sets;
 import it.unimi.dsi.fastutil.longs.Long2ObjectMap;
@@ -69,11 +77,12 @@
 
 import static com.gregtechceu.gtceu.api.pattern.Predicates.*;
 import static com.gregtechceu.gtceu.api.pattern.util.RelativeDirection.*;
+import static com.gregtechceu.gtceu.common.mui.GTByteBufAdapters.COMPONENT;
 
 @ParametersAreNonnullByDefault
 @MethodsReturnNonnullByDefault
 public class CleanroomMachine extends WorkableElectricMultiblockMachine
-                              implements IDisplayUIMachine, IDataInfoProvider {
+                              implements IDataInfoProvider {
 
     public static final int CLEAN_AMOUNT_THRESHOLD = 95;
     public static final int MIN_CLEAN_AMOUNT = 0;
@@ -448,55 +457,114 @@ protected boolean isMachineBanned(MetaMachine machine) {
         return machine instanceof PrimitivePumpMachine;
     }
 
-    @Override
-    public void addDisplayText(List<Component> textList) {
-        if (isFormed()) {
-            var maxVoltage = getMaxVoltage();
-            if (maxVoltage > 0) {
-                String voltageName = GTValues.VNF[GTUtil.getFloorTierByVoltage(maxVoltage)];
-                textList.add(Component.translatable("gtceu.multiblock.max_energy_per_tick", maxVoltage, voltageName));
-            }
-
-            if (cleanroomType != null) {
-                textList.add(Component.translatable(cleanroomType.getTranslationKey()));
-            }
-
-            if (!isWorkingEnabled()) {
-                textList.add(Component.translatable("gtceu.multiblock.work_paused"));
-
-            } else if (isActive()) {
-                textList.add(Component.translatable("gtceu.multiblock.running"));
-                int currentProgress = (int) (recipeLogic.getProgressPercent() * 100);
-                double maxInSec = (float) recipeLogic.getDuration() / 20.0f;
-                double currentInSec = (float) recipeLogic.getProgress() / 20.0f;
-                textList.add(
-                        Component.translatable("gtceu.multiblock.progress", String.format("%.2f", (float) currentInSec),
-                                String.format("%.2f", (float) maxInSec), currentProgress));
-            } else {
-                textList.add(Component.translatable("gtceu.multiblock.idling"));
-            }
-
-            if (recipeLogic.isWaiting()) {
-                textList.add(Component.translatable("gtceu.multiblock.waiting")
-                        .setStyle(Style.EMPTY.withColor(ChatFormatting.RED)));
-            }
+    public List<IWidget> getWidgetsForDisplay(PanelSyncManager syncManager) {
+        List<IWidget> widgets = new ArrayList<>();
+
+        // Machine generic sync handlers
+        BooleanSyncValue isFormed = syncManager.getOrCreateSyncHandler("isFormed", BooleanSyncValue.class,
+                () -> new BooleanSyncValue(this::isFormed));
+        BooleanSyncValue workingEnabled = syncManager.getOrCreateSyncHandler("workingEnabled", BooleanSyncValue.class,
+                () -> new BooleanSyncValue(this.recipeLogic::isWorkingEnabled, this.recipeLogic::setWorkingEnabled));
+        BooleanSyncValue active = syncManager.getOrCreateSyncHandler("isActive", BooleanSyncValue.class,
+                () -> new BooleanSyncValue(this.recipeLogic::isActive));
+        BooleanSyncValue waiting = syncManager.getOrCreateSyncHandler("isWaiting", BooleanSyncValue.class,
+                () -> new BooleanSyncValue(this.recipeLogic::isWaiting));
+
+        // Energy bank specific sync handlers
+        // These will not be called anywhere else, so we can create them directly instead of using
+        // getOrCreateSyncHandler
+
+        LongSyncValue maxVoltage = new LongSyncValue(this::getMaxVoltage);
+        syncManager.syncValue("maxVoltage", maxVoltage);
+
+        StringSyncValue cleanroomTranslationKey = new StringSyncValue(() -> {
+            if (this.cleanroomType == null) return "";
+            return this.cleanroomType.getTranslationKey();
+        });
+        syncManager.syncValue("cleanroomTranslationKey", cleanroomTranslationKey);
+
+        BooleanSyncValue cleanroomTypeIsNull = new BooleanSyncValue(() -> this.cleanroomType == null);
+        syncManager.syncValue("cleanroomTypeIsNull", cleanroomTypeIsNull);
+
+        BooleanSyncValue cleanroomProviderTraitIsActive = new BooleanSyncValue(
+                () -> this.cleanroomProviderTrait != null && this.cleanroomProviderTrait.isActive());
+        syncManager.syncValue("cleanroomProviderTrait", cleanroomProviderTraitIsActive);
+
+        IntSyncValue cleanAmount = new IntSyncValue(() -> this.cleanAmount);
+        syncManager.syncValue("cleanAmount", cleanAmount);
+
+        GenericSyncValue<Component> distComponent = GenericSyncValue.builder(Component.class)
+                .adapter(COMPONENT)
+                .getter(() -> Component.translatable("gtceu.multiblock.dimensions.1", lDist + rDist + 1, hDist + 1,
+                        fDist + bDist + 1))
+                .build();
+        syncManager.syncValue("distComponent", distComponent);
 
-            if (cleanroomProviderTrait.isActive()) {
-                textList.add(Component.translatable("gtceu.multiblock.cleanroom.clean_state"));
-            } else {
-                textList.add(Component.translatable("gtceu.multiblock.cleanroom.dirty_state"));
-            }
-            textList.add(Component.translatable("gtceu.multiblock.cleanroom.clean_amount", this.cleanAmount));
-            textList.add(Component.translatable("gtceu.multiblock.dimensions.0"));
-            textList.add(Component.translatable("gtceu.multiblock.dimensions.1", lDist + rDist + 1, hDist + 1,
-                    fDist + bDist + 1));
-        } else {
+        widgets.add(IKey.dynamic(() -> {
             Component tooltip = Component.translatable("gtceu.multiblock.invalid_structure.tooltip")
                     .withStyle(ChatFormatting.GRAY);
-            textList.add(Component.translatable("gtceu.multiblock.invalid_structure")
+            return Component.translatable("gtceu.multiblock.invalid_structure")
                     .withStyle(Style.EMPTY.withColor(ChatFormatting.RED)
-                            .withHoverEvent(new HoverEvent(HoverEvent.Action.SHOW_TEXT, tooltip))));
-        }
+                            .withHoverEvent(new HoverEvent(HoverEvent.Action.SHOW_TEXT, tooltip)));
+        })
+                .asWidget()
+                .setEnabledIf((widget) -> !isFormed.getBoolValue()));
+
+        widgets.add(IKey.dynamic(() -> {
+            String voltageName = GTValues.VNF[GTUtil.getFloorTierByVoltage(maxVoltage.getLongValue())];
+            return Component.translatable("gtceu.multiblock.max_energy_per_tick", maxVoltage.getLongValue(),
+                    voltageName);
+        })
+                .asWidget()
+                .setEnabledIf((widget) -> isFormed.getBoolValue() && maxVoltage.getLongValue() > 0));
+
+        widgets.add(IKey.dynamic(() -> {
+            if (cleanroomTypeIsNull.getBoolValue()) {
+                return Component.empty();
+            } else {
+                return Component.translatable(cleanroomTranslationKey.getStringValue());
+            }
+        })
+                .asWidget()
+                .setEnabledIf((widget) -> isFormed.getBoolValue() && !cleanroomTypeIsNull.getBoolValue()));
+
+        widgets.add(IKey.dynamic(() -> Component.translatable("gtceu.multiblock.work_paused"))
+                .asWidget()
+                .setEnabledIf((widget) -> isFormed.getBoolValue() && !workingEnabled.getBoolValue()));
+
+        widgets.add(GTMultiblockTextUtil.addProgressLine(this, syncManager));
+
+        widgets.add(IKey.lang(Component.translatable("gtceu.multiblock.idling"))
+                .asWidget()
+                .setEnabledIf((widget) -> isFormed.getBoolValue() && workingEnabled.getBoolValue() &&
+                        !active.getBoolValue()));
+
+        widgets.add(IKey
+                .lang(Component.translatable("gtceu.multiblock.waiting")
+                        .setStyle(Style.EMPTY.withColor(ChatFormatting.RED)))
+                .asWidget()
+                .setEnabledIf((widget) -> isFormed.getBoolValue() && waiting.getBoolValue()));
+
+        widgets.add(IKey.lang(Component.translatable("gtceu.multiblock.cleanroom.clean_state"))
+                .asWidget()
+                .setEnabledIf((widget) -> isFormed.getBoolValue() && cleanroomProviderTraitIsActive.getBoolValue()));
+        widgets.add(IKey.lang(Component.translatable("gtceu.multiblock.cleanroom.dirty_state"))
+                .asWidget()
+                .setEnabledIf((widget) -> isFormed.getBoolValue() && !cleanroomProviderTraitIsActive.getBoolValue()));
+
+        widgets.add(IKey.dynamic(
+                () -> Component.translatable("gtceu.multiblock.cleanroom.clean_amount", cleanAmount.getIntValue()))
+                .asWidget()
+                .setEnabledIf((widget) -> isFormed.getBoolValue()));
+
+        widgets.add(IKey.lang(Component.translatable("gtceu.multiblock.dimensions.0"))
+                .asWidget()
+                .setEnabledIf((widget) -> isFormed.getBoolValue()));
+        widgets.add(IKey.dynamic(distComponent::getValue)
+                .asWidget()
+                .setEnabledIf((widget) -> isFormed.getBoolValue()));
+
+        return widgets;
     }
 
     /**
diff --git a/src/main/java/com/gregtechceu/gtceu/common/machine/multiblock/electric/FluidDrillMachine.java b/src/main/java/com/gregtechceu/gtceu/common/machine/multiblock/electric/FluidDrillMachine.java
index 53ac4ec0e35..6f1bc80704f 100644
--- a/src/main/java/com/gregtechceu/gtceu/common/machine/multiblock/electric/FluidDrillMachine.java
+++ b/src/main/java/com/gregtechceu/gtceu/common/machine/multiblock/electric/FluidDrillMachine.java
@@ -14,23 +14,15 @@
 import com.gregtechceu.gtceu.common.data.GTMaterialBlocks;
 import com.gregtechceu.gtceu.common.data.GTMaterials;
 import com.gregtechceu.gtceu.common.machine.trait.FluidDrillLogic;
-import com.gregtechceu.gtceu.utils.FormattingUtil;
 import com.gregtechceu.gtceu.utils.GTUtil;
 
-import net.minecraft.ChatFormatting;
 import net.minecraft.MethodsReturnNonnullByDefault;
-import net.minecraft.network.chat.Component;
-import net.minecraft.network.chat.HoverEvent;
-import net.minecraft.network.chat.Style;
 import net.minecraft.resources.ResourceLocation;
 import net.minecraft.world.level.block.Block;
-import net.minecraft.world.level.material.Fluid;
 
 import lombok.Getter;
 import org.jetbrains.annotations.NotNull;
 
-import java.util.List;
-
 import javax.annotation.ParametersAreNonnullByDefault;
 
 @ParametersAreNonnullByDefault
@@ -59,42 +51,42 @@ public int getEnergyTier() {
         return Math.min(this.tier + 1, Math.max(this.tier, GTUtil.getFloorTierByVoltage(energyCont.getInputVoltage())));
     }
 
-    @Override
-    public void addDisplayText(List<Component> textList) {
-        if (isFormed()) {
-            int energyContainer = getEnergyTier();
-            long maxVoltage = GTValues.V[energyContainer];
-            String voltageName = GTValues.VNF[energyContainer];
-            textList.add(Component.translatable("gtceu.multiblock.max_energy_per_tick", maxVoltage, voltageName));
-
-            if (getRecipeLogic().getVeinFluid() != null) {
-                // Fluid name
-                Fluid drilledFluid = getRecipeLogic().getVeinFluid();
-                Component fluidInfo = drilledFluid.getFluidType().getDescription().copy()
-                        .withStyle(ChatFormatting.GREEN);
-                textList.add(Component.translatable("gtceu.multiblock.fluid_rig.drilled_fluid", fluidInfo)
-                        .withStyle(ChatFormatting.GRAY));
-
-                // Fluid amount
-                Component amountInfo = Component.literal(FormattingUtil.formatNumbers(
-                        getRecipeLogic().getFluidToProduce() * 20L / FluidDrillLogic.MAX_PROGRESS) +
-                        " mB/s").withStyle(ChatFormatting.BLUE);
-                textList.add(Component.translatable("gtceu.multiblock.fluid_rig.fluid_amount", amountInfo)
-                        .withStyle(ChatFormatting.GRAY));
-            } else {
-                Component noFluid = Component.translatable("gtceu.multiblock.fluid_rig.no_fluid_in_area")
-                        .withStyle(ChatFormatting.RED);
-                textList.add(Component.translatable("gtceu.multiblock.fluid_rig.drilled_fluid", noFluid)
-                        .withStyle(ChatFormatting.GRAY));
-            }
-        } else {
-            Component tooltip = Component.translatable("gtceu.multiblock.invalid_structure.tooltip")
-                    .withStyle(ChatFormatting.GRAY);
-            textList.add(Component.translatable("gtceu.multiblock.invalid_structure")
-                    .withStyle(Style.EMPTY.withColor(ChatFormatting.RED)
-                            .withHoverEvent(new HoverEvent(HoverEvent.Action.SHOW_TEXT, tooltip))));
-        }
-    }
+    // @Override
+    // public void addDisplayText(List<Component> textList) {
+    // if (isFormed()) {
+    // int energyContainer = getEnergyTier();
+    // long maxVoltage = GTValues.V[energyContainer];
+    // String voltageName = GTValues.VNF[energyContainer];
+    // textList.add(Component.translatable("gtceu.multiblock.max_energy_per_tick", maxVoltage, voltageName));
+    //
+    // if (getRecipeLogic().getVeinFluid() != null) {
+    // // Fluid name
+    // Fluid drilledFluid = getRecipeLogic().getVeinFluid();
+    // Component fluidInfo = drilledFluid.getFluidType().getDescription().copy()
+    // .withStyle(ChatFormatting.GREEN);
+    // textList.add(Component.translatable("gtceu.multiblock.fluid_rig.drilled_fluid", fluidInfo)
+    // .withStyle(ChatFormatting.GRAY));
+    //
+    // // Fluid amount
+    // Component amountInfo = Component.literal(FormattingUtil.formatNumbers(
+    // getRecipeLogic().getFluidToProduce() * 20L / FluidDrillLogic.MAX_PROGRESS) +
+    // " mB/s").withStyle(ChatFormatting.BLUE);
+    // textList.add(Component.translatable("gtceu.multiblock.fluid_rig.fluid_amount", amountInfo)
+    // .withStyle(ChatFormatting.GRAY));
+    // } else {
+    // Component noFluid = Component.translatable("gtceu.multiblock.fluid_rig.no_fluid_in_area")
+    // .withStyle(ChatFormatting.RED);
+    // textList.add(Component.translatable("gtceu.multiblock.fluid_rig.drilled_fluid", noFluid)
+    // .withStyle(ChatFormatting.GRAY));
+    // }
+    // } else {
+    // Component tooltip = Component.translatable("gtceu.multiblock.invalid_structure.tooltip")
+    // .withStyle(ChatFormatting.GRAY);
+    // textList.add(Component.translatable("gtceu.multiblock.invalid_structure")
+    // .withStyle(Style.EMPTY.withColor(ChatFormatting.RED)
+    // .withHoverEvent(new HoverEvent(HoverEvent.Action.SHOW_TEXT, tooltip))));
+    // }
+    // }
 
     public static int getDepletionChance(int tier) {
         if (tier == GTValues.MV)
diff --git a/src/main/java/com/gregtechceu/gtceu/common/machine/multiblock/electric/FusionReactorMachine.java b/src/main/java/com/gregtechceu/gtceu/common/machine/multiblock/electric/FusionReactorMachine.java
index b0538ef1158..afcf74d9c47 100644
--- a/src/main/java/com/gregtechceu/gtceu/common/machine/multiblock/electric/FusionReactorMachine.java
+++ b/src/main/java/com/gregtechceu/gtceu/common/machine/multiblock/electric/FusionReactorMachine.java
@@ -268,15 +268,15 @@ public long getMaxVoltage() {
     //////////////////////////////////////
     // ******** GUI *********//
     //////////////////////////////////////
-    @Override
-    public void addDisplayText(List<Component> textList) {
-        super.addDisplayText(textList);
-        if (isFormed()) {
-            textList.add(Component.translatable("gtceu.multiblock.fusion_reactor.energy",
-                    this.energyContainer.getEnergyStored(), this.energyContainer.getEnergyCapacity()));
-            textList.add(Component.translatable("gtceu.multiblock.fusion_reactor.heat", heat));
-        }
-    }
+    // @Override
+    // public void addDisplayText(List<Component> textList) {
+    // super.addDisplayText(textList);
+    // if (isFormed()) {
+    // textList.add(Component.translatable("gtceu.multiblock.fusion_reactor.energy",
+    // this.energyContainer.getEnergyStored(), this.energyContainer.getEnergyCapacity()));
+    // textList.add(Component.translatable("gtceu.multiblock.fusion_reactor.heat", heat));
+    // }
+    // }
 
     public static void addEUToStartLabel(GTRecipe recipe, WidgetGroup group) {
         long euToStart = recipe.data.getLong("eu_to_start");
diff --git a/src/main/java/com/gregtechceu/gtceu/common/machine/multiblock/electric/LargeMinerMachine.java b/src/main/java/com/gregtechceu/gtceu/common/machine/multiblock/electric/LargeMinerMachine.java
index c1278309ed1..a51ed9fe164 100644
--- a/src/main/java/com/gregtechceu/gtceu/common/machine/multiblock/electric/LargeMinerMachine.java
+++ b/src/main/java/com/gregtechceu/gtceu/common/machine/multiblock/electric/LargeMinerMachine.java
@@ -22,14 +22,9 @@
 import com.gregtechceu.gtceu.utils.GTTransferUtils;
 import com.gregtechceu.gtceu.utils.GTUtil;
 
-import com.lowdragmc.lowdraglib.gui.util.ClickData;
-import com.lowdragmc.lowdraglib.gui.widget.ComponentPanelWidget;
-
-import net.minecraft.ChatFormatting;
 import net.minecraft.MethodsReturnNonnullByDefault;
 import net.minecraft.core.Direction;
 import net.minecraft.network.chat.Component;
-import net.minecraft.network.chat.Style;
 import net.minecraft.world.InteractionResult;
 import net.minecraft.world.level.block.Block;
 import net.minecraftforge.fluids.FluidStack;
@@ -181,54 +176,54 @@ public boolean drainInput(boolean simulate) {
     //////////////////////////////////////
     // *********** GUI ***********//
     //////////////////////////////////////
-    @Override
-    public void addDisplayText(List<Component> textList) {
-        super.addDisplayText(textList);
-        if (this.isFormed()) {
-            int workingAreaChunks = getRecipeLogic().getCurrentRadius() * 2 / CHUNK_LENGTH;
-            int workingArea = IMiner.getWorkingArea(getRecipeLogic().getCurrentRadius());
-            textList.add(Component.translatable("gtceu.machine.miner.startx",
-                    getRecipeLogic().getX() == Integer.MAX_VALUE ? 0 : getRecipeLogic().getX()));
-            textList.add(Component.translatable("gtceu.machine.miner.starty",
-                    getRecipeLogic().getY() == Integer.MAX_VALUE ? 0 : getRecipeLogic().getY()));
-            textList.add(Component.translatable("gtceu.machine.miner.startz",
-                    getRecipeLogic().getZ() == Integer.MAX_VALUE ? 0 : getRecipeLogic().getZ()));
-            textList.add(Component.translatable("gtceu.universal.tooltip.silk_touch")
-                    .append(ComponentPanelWidget.withButton(Component.literal("[")
-                            .append(getRecipeLogic().isSilkTouchMode() ?
-                                    Component.translatable("gtceu.creative.activity.on") :
-                                    Component.translatable("gtceu.creative.activity.off"))
-                            .append(Component.literal("]")), "silk_touch")));
-            textList.add(Component.translatable("gtceu.universal.tooltip.chunk_mode")
-                    .append(ComponentPanelWidget.withButton(Component.literal("[")
-                            .append(getRecipeLogic().isChunkMode() ?
-                                    Component.translatable("gtceu.creative.activity.on") :
-                                    Component.translatable("gtceu.creative.activity.off"))
-                            .append(Component.literal("]")), "chunk_mode")));
-            if (getRecipeLogic().isChunkMode()) {
-                textList.add(Component.translatable("gtceu.universal.tooltip.working_area_chunks", workingAreaChunks,
-                        workingAreaChunks));
-            } else {
-                textList.add(Component.translatable("gtceu.universal.tooltip.working_area", workingArea, workingArea));
-            }
-            if (getRecipeLogic().isDone()) {
-                textList.add(Component.translatable("gtceu.multiblock.large_miner.done")
-                        .setStyle(Style.EMPTY.withColor(ChatFormatting.GREEN)));
-            }
-        }
-    }
-
-    @Override
-    public void handleDisplayClick(String componentData, ClickData clickData) {
-        if (!clickData.isRemote) {
-            if (componentData.equals("chunk_mode")) {
-                getRecipeLogic().setChunkMode(!getRecipeLogic().isChunkMode());
-            }
-            if (componentData.equals("silk_touch")) {
-                getRecipeLogic().setSilkTouchMode(!getRecipeLogic().isSilkTouchMode());
-            }
-        }
-    }
+    // @Override
+    // public void addDisplayText(List<Component> textList) {
+    // super.addDisplayText(textList);
+    // if (this.isFormed()) {
+    // int workingAreaChunks = getRecipeLogic().getCurrentRadius() * 2 / CHUNK_LENGTH;
+    // int workingArea = IMiner.getWorkingArea(getRecipeLogic().getCurrentRadius());
+    // textList.add(Component.translatable("gtceu.machine.miner.startx",
+    // getRecipeLogic().getX() == Integer.MAX_VALUE ? 0 : getRecipeLogic().getX()));
+    // textList.add(Component.translatable("gtceu.machine.miner.starty",
+    // getRecipeLogic().getY() == Integer.MAX_VALUE ? 0 : getRecipeLogic().getY()));
+    // textList.add(Component.translatable("gtceu.machine.miner.startz",
+    // getRecipeLogic().getZ() == Integer.MAX_VALUE ? 0 : getRecipeLogic().getZ()));
+    // textList.add(Component.translatable("gtceu.universal.tooltip.silk_touch")
+    // .append(ComponentPanelWidget.withButton(Component.literal("[")
+    // .append(getRecipeLogic().isSilkTouchMode() ?
+    // Component.translatable("gtceu.creative.activity.on") :
+    // Component.translatable("gtceu.creative.activity.off"))
+    // .append(Component.literal("]")), "silk_touch")));
+    // textList.add(Component.translatable("gtceu.universal.tooltip.chunk_mode")
+    // .append(ComponentPanelWidget.withButton(Component.literal("[")
+    // .append(getRecipeLogic().isChunkMode() ?
+    // Component.translatable("gtceu.creative.activity.on") :
+    // Component.translatable("gtceu.creative.activity.off"))
+    // .append(Component.literal("]")), "chunk_mode")));
+    // if (getRecipeLogic().isChunkMode()) {
+    // textList.add(Component.translatable("gtceu.universal.tooltip.working_area_chunks", workingAreaChunks,
+    // workingAreaChunks));
+    // } else {
+    // textList.add(Component.translatable("gtceu.universal.tooltip.working_area", workingArea, workingArea));
+    // }
+    // if (getRecipeLogic().isDone()) {
+    // textList.add(Component.translatable("gtceu.multiblock.large_miner.done")
+    // .setStyle(Style.EMPTY.withColor(ChatFormatting.GREEN)));
+    // }
+    // }
+    // }
+    //
+    // @Override
+    // public void handleDisplayClick(String componentData, ClickData clickData) {
+    // if (!clickData.isRemote) {
+    // if (componentData.equals("chunk_mode")) {
+    // getRecipeLogic().setChunkMode(!getRecipeLogic().isChunkMode());
+    // }
+    // if (componentData.equals("silk_touch")) {
+    // getRecipeLogic().setSilkTouchMode(!getRecipeLogic().isSilkTouchMode());
+    // }
+    // }
+    // }
 
     //////////////////////////////////////
     // ******* Interaction *******//
diff --git a/src/main/java/com/gregtechceu/gtceu/common/machine/multiblock/electric/MultiblockTankMachine.java b/src/main/java/com/gregtechceu/gtceu/common/machine/multiblock/electric/MultiblockTankMachine.java
index ee61035c8ea..127b4d2e238 100644
--- a/src/main/java/com/gregtechceu/gtceu/common/machine/multiblock/electric/MultiblockTankMachine.java
+++ b/src/main/java/com/gregtechceu/gtceu/common/machine/multiblock/electric/MultiblockTankMachine.java
@@ -3,24 +3,30 @@
 import com.gregtechceu.gtceu.api.blockentity.BlockEntityCreationInfo;
 import com.gregtechceu.gtceu.api.capability.recipe.IO;
 import com.gregtechceu.gtceu.api.fluids.PropertyFluidFilter;
-import com.gregtechceu.gtceu.api.gui.GuiTextures;
-import com.gregtechceu.gtceu.api.gui.widget.TankWidget;
-import com.gregtechceu.gtceu.api.machine.feature.IFancyUIMachine;
+import com.gregtechceu.gtceu.api.machine.feature.IMuiMachine;
 import com.gregtechceu.gtceu.api.machine.multiblock.MultiblockControllerMachine;
 import com.gregtechceu.gtceu.api.machine.trait.NotifiableFluidTank;
 import com.gregtechceu.gtceu.api.sync_system.annotations.SaveField;
 import com.gregtechceu.gtceu.api.transfer.fluid.IFluidHandlerModifiable;
+import com.gregtechceu.gtceu.common.mui.GTGuiTextures;
 import com.gregtechceu.gtceu.utils.ExtendedUseOnContext;
-
-import com.lowdragmc.lowdraglib.gui.widget.ImageWidget;
-import com.lowdragmc.lowdraglib.gui.widget.LabelWidget;
-import com.lowdragmc.lowdraglib.gui.widget.Widget;
-import com.lowdragmc.lowdraglib.gui.widget.WidgetGroup;
+import com.gregtechceu.gtceu.utils.FormattingUtil;
 
 import net.minecraft.MethodsReturnNonnullByDefault;
 import net.minecraft.core.Direction;
+import net.minecraft.network.chat.Component;
 import net.minecraft.world.InteractionResult;
 
+import brachy.modularui.api.drawable.IKey;
+import brachy.modularui.api.widget.IWidget;
+import brachy.modularui.factory.PosGuiData;
+import brachy.modularui.screen.UISettings;
+import brachy.modularui.value.sync.IntSyncValue;
+import brachy.modularui.value.sync.PanelSyncManager;
+import brachy.modularui.value.sync.SyncHandlers;
+import brachy.modularui.widget.ParentWidget;
+import brachy.modularui.widgets.layout.Flow;
+import brachy.modularui.widgets.slot.FluidSlot;
 import lombok.Getter;
 import org.jetbrains.annotations.Nullable;
 
@@ -28,7 +34,7 @@
 
 @MethodsReturnNonnullByDefault
 @ParametersAreNonnullByDefault
-public class MultiblockTankMachine extends MultiblockControllerMachine implements IFancyUIMachine {
+public class MultiblockTankMachine extends MultiblockControllerMachine implements IMuiMachine {
 
     @SaveField
     @Getter
@@ -62,23 +68,35 @@ public IFluidHandlerModifiable getFluidHandlerCap(@Nullable Direction side, bool
 
     /////////////////////////////////////
     // *********** GUI ***********//
+
     /////////////////////////////////////
 
     @Override
-    public Widget createUIWidget() {
-        var group = new WidgetGroup(0, 0, 90, 63);
-        group.setBackground(GuiTextures.BACKGROUND_INVERSE);
-
-        group.addWidget(new ImageWidget(4, 4, 82, 55, GuiTextures.DISPLAY));
-        group.addWidget(new LabelWidget(8, 8, "gtceu.gui.fluid_amount"));
-        group.addWidget(new LabelWidget(8, 18, this::getFluidLabel).setTextColor(-1).setDropShadow(true));
-        group.addWidget(new TankWidget(tank.getStorages()[0], 68, 23, true, true)
-                .setBackground(GuiTextures.FLUID_SLOT));
-
-        return group;
+    public void buildMainUI(ParentWidget<?> mainWidget, PosGuiData guiData, PanelSyncManager syncManager,
+                            UISettings settings) {
+        IntSyncValue bucketSyncer = new IntSyncValue(() -> tank.getFluidInTank(0).getAmount(), (ignored) -> {});
+        syncManager.syncValue("bucket_amount", bucketSyncer);
+
+        mainWidget
+                .background(GTGuiTextures.DISPLAY)
+                .child(IKey.lang("gtceu.gui.fluid_amount").asWidget()
+                        .color(0xffffff)
+                        .margin(8, 0, 8, 0))
+                .child(IKey.dynamic(
+                        () -> Component.literal(
+                                FormattingUtil.formatBuckets(bucketSyncer.getIntValue())))
+                        .asWidget()
+                        .color(0xffffff)
+                        .margin(8, 0, 20, 0))
+                .child(Flow.column()
+                        .margin(68, 0, 23, 0)
+                        .coverChildren()
+                        .child(createFluidSlot(syncManager)));
     }
 
-    private String getFluidLabel() {
-        return String.valueOf(tank.getFluidInTank(0).getAmount());
+    private IWidget createFluidSlot(PanelSyncManager syncManager) {
+        syncManager.syncValue("fluid_slot",
+                SyncHandlers.fluidSlot(tank.getStorages()[0]).controlsAmount(false));
+        return new FluidSlot().syncHandler("fluid_slot", 0).background(GTGuiTextures.FLUID_SLOT);
     }
 }
diff --git a/src/main/java/com/gregtechceu/gtceu/common/machine/multiblock/electric/PowerSubstationMachine.java b/src/main/java/com/gregtechceu/gtceu/common/machine/multiblock/electric/PowerSubstationMachine.java
index c0cacf8efa5..f9ac89ba070 100644
--- a/src/main/java/com/gregtechceu/gtceu/common/machine/multiblock/electric/PowerSubstationMachine.java
+++ b/src/main/java/com/gregtechceu/gtceu/common/machine/multiblock/electric/PowerSubstationMachine.java
@@ -5,13 +5,9 @@
 import com.gregtechceu.gtceu.api.capability.IEnergyInfoProvider;
 import com.gregtechceu.gtceu.api.capability.recipe.EURecipeCapability;
 import com.gregtechceu.gtceu.api.capability.recipe.IO;
-import com.gregtechceu.gtceu.api.gui.GuiTextures;
-import com.gregtechceu.gtceu.api.gui.fancy.FancyMachineUIWidget;
-import com.gregtechceu.gtceu.api.gui.fancy.IFancyUIProvider;
-import com.gregtechceu.gtceu.api.gui.fancy.TooltipsPanel;
 import com.gregtechceu.gtceu.api.machine.ConditionalSubscriptionHandler;
-import com.gregtechceu.gtceu.api.machine.feature.IFancyUIMachine;
-import com.gregtechceu.gtceu.api.machine.feature.multiblock.IDisplayUIMachine;
+import com.gregtechceu.gtceu.api.machine.feature.IMuiMachine;
+import com.gregtechceu.gtceu.api.machine.feature.IVoidable;
 import com.gregtechceu.gtceu.api.machine.feature.multiblock.IMaintenanceMachine;
 import com.gregtechceu.gtceu.api.machine.feature.multiblock.IMultiPart;
 import com.gregtechceu.gtceu.api.machine.multiblock.IBatteryData;
@@ -24,18 +20,28 @@
 import com.gregtechceu.gtceu.config.ConfigHolder;
 import com.gregtechceu.gtceu.utils.FormattingUtil;
 
-import com.lowdragmc.lowdraglib.gui.modular.ModularUI;
-import com.lowdragmc.lowdraglib.gui.widget.*;
-
 import net.minecraft.ChatFormatting;
 import net.minecraft.nbt.CompoundTag;
 import net.minecraft.network.chat.Component;
 import net.minecraft.network.chat.HoverEvent;
 import net.minecraft.network.chat.MutableComponent;
 import net.minecraft.network.chat.Style;
-import net.minecraft.world.entity.player.Player;
 import net.minecraftforge.common.util.INBTSerializable;
 
+import brachy.modularui.api.drawable.IKey;
+import brachy.modularui.drawable.GuiTextures;
+import brachy.modularui.drawable.Icon;
+import brachy.modularui.factory.PosGuiData;
+import brachy.modularui.screen.UISettings;
+import brachy.modularui.utils.Alignment;
+import brachy.modularui.value.sync.BigIntegerSyncValue;
+import brachy.modularui.value.sync.BooleanSyncValue;
+import brachy.modularui.value.sync.LongSyncValue;
+import brachy.modularui.value.sync.PanelSyncManager;
+import brachy.modularui.widget.ParentWidget;
+import brachy.modularui.widget.Widget;
+import brachy.modularui.widgets.ListWidget;
+import brachy.modularui.widgets.layout.Flow;
 import com.google.common.annotations.VisibleForTesting;
 import it.unimi.dsi.fastutil.longs.Long2ObjectMap;
 import it.unimi.dsi.fastutil.longs.Long2ObjectMaps;
@@ -47,7 +53,7 @@
 import java.util.*;
 
 public class PowerSubstationMachine extends WorkableMultiblockMachine
-                                    implements IEnergyInfoProvider, IFancyUIMachine, IDisplayUIMachine {
+                                    implements IEnergyInfoProvider, IMuiMachine, IVoidable {
 
     // Structure Constants
     public static final int MAX_BATTERY_LAYERS = 18;
@@ -66,8 +72,9 @@ public class PowerSubstationMachine extends WorkableMultiblockMachine
 
     private @Nullable IMaintenanceMachine maintenance;
 
+    @Getter
     @SaveField
-    private PowerStationEnergyBank energyBank;
+    private final PowerStationEnergyBank energyBank;
 
     private @Nullable EnergyContainerList inputHatches;
     private @Nullable EnergyContainerList outputHatches;
@@ -188,79 +195,6 @@ protected void transferEnergyTick() {
         }
     }
 
-    @Override
-    public void addDisplayText(List<Component> textList) {
-        IDisplayUIMachine.super.addDisplayText(textList);
-        if (isFormed()) {
-            if (!isWorkingEnabled()) {
-                textList.add(Component.translatable("gtceu.multiblock.work_paused"));
-
-            } else if (isActive()) {
-                textList.add(Component.translatable("gtceu.multiblock.running"));
-                int currentProgress = (int) (recipeLogic.getProgressPercent() * 100);
-                double maxInSec = (float) recipeLogic.getDuration() / 20.0f;
-                double currentInSec = (float) recipeLogic.getProgress() / 20.0f;
-                textList.add(
-                        Component.translatable("gtceu.multiblock.progress", String.format("%.2f", (float) currentInSec),
-                                String.format("%.2f", (float) maxInSec), currentProgress));
-            } else {
-                textList.add(Component.translatable("gtceu.multiblock.idling"));
-            }
-
-            if (recipeLogic.isWaiting()) {
-                textList.add(Component.translatable("gtceu.multiblock.waiting")
-                        .setStyle(Style.EMPTY.withColor(ChatFormatting.RED)));
-            }
-
-            BigInteger energyStored = energyBank.getStored();
-            BigInteger energyCapacity = energyBank.getCapacity();
-
-            var STYLE_GOLD = Style.EMPTY.withColor(ChatFormatting.GOLD);
-            var STYLE_DARK_RED = Style.EMPTY.withColor(ChatFormatting.DARK_RED);
-            var STYLE_GREEN = Style.EMPTY.withColor(ChatFormatting.GREEN);
-            var STYLE_RED = Style.EMPTY.withColor(ChatFormatting.RED);
-
-            var storedComponent = Component.literal(FormattingUtil.formatNumbers(energyStored));
-            textList.add(Component.translatable("gtceu.multiblock.power_substation.stored",
-                    storedComponent.setStyle(STYLE_GOLD)));
-
-            var capacityComponent = Component.literal(FormattingUtil.formatNumbers(energyCapacity));
-            textList.add(Component.translatable("gtceu.multiblock.power_substation.capacity",
-                    capacityComponent.setStyle(STYLE_GOLD)));
-
-            var passiveDrainComponent = Component.literal(FormattingUtil.formatNumbers(getPassiveDrain()));
-            textList.add(Component.translatable("gtceu.multiblock.power_substation.passive_drain",
-                    passiveDrainComponent.setStyle(STYLE_DARK_RED)));
-
-            var avgInComponent = Component.literal(FormattingUtil.formatNumbers(inputPerSec / 20));
-            textList.add(Component
-                    .translatable("gtceu.multiblock.power_substation.average_in",
-                            avgInComponent.setStyle(STYLE_GREEN))
-                    .withStyle(Style.EMPTY.withHoverEvent(new HoverEvent(HoverEvent.Action.SHOW_TEXT,
-                            Component.translatable("gtceu.multiblock.power_substation.average_in_hover")))));
-
-            var avgOutComponent = Component.literal(FormattingUtil.formatNumbers(Math.abs(outputPerSec / 20)));
-            textList.add(Component
-                    .translatable("gtceu.multiblock.power_substation.average_out",
-                            avgOutComponent.setStyle(STYLE_RED))
-                    .withStyle(Style.EMPTY.withHoverEvent(new HoverEvent(HoverEvent.Action.SHOW_TEXT,
-                            Component.translatable("gtceu.multiblock.power_substation.average_out_hover")))));
-
-            if (inputPerSec > outputPerSec) {
-                BigInteger timeToFillSeconds = energyCapacity.subtract(energyStored)
-                        .divide(BigInteger.valueOf(inputPerSec - outputPerSec));
-                textList.add(Component.translatable("gtceu.multiblock.power_substation.time_to_fill",
-                        getTimeToFillDrainText(timeToFillSeconds).setStyle(STYLE_GREEN)));
-            } else if (inputPerSec < outputPerSec) {
-                BigInteger timeToDrainSeconds = energyStored
-                        .divide(BigInteger.valueOf(outputPerSec - inputPerSec));
-                textList.add(Component.translatable("gtceu.multiblock.power_substation.time_to_drain",
-                        getTimeToFillDrainText(timeToDrainSeconds).setStyle(STYLE_RED)));
-            }
-        }
-        getDefinition().getAdditionalDisplay().accept(this, textList);
-    }
-
     private static MutableComponent getTimeToFillDrainText(BigInteger timeToFillSeconds) {
         if (timeToFillSeconds.compareTo(BIG_INTEGER_MAX_LONG) > 0) {
             // too large to represent in a java Duration
@@ -328,33 +262,162 @@ public boolean supportsBigIntEnergyValues() {
     }
 
     @Override
-    public Widget createUIWidget() {
-        var group = new WidgetGroup(0, 0, 182 + 8, 117 + 8);
-        group.addWidget(new DraggableScrollableWidgetGroup(4, 4, 182, 117).setBackground(getScreenTexture())
-                .addWidget(new LabelWidget(4, 5, self().getBlockState().getBlock().getDescriptionId()))
-                .addWidget(new ComponentPanelWidget(4, 17, this::addDisplayText)
-                        .setMaxWidthLimit(150)
-                        .clickHandler(this::handleDisplayClick)));
-        group.setBackground(GuiTextures.BACKGROUND_INVERSE);
-        return group;
-    }
-
-    @Override
-    public ModularUI createUI(Player entityPlayer) {
-        return new ModularUI(198, 208, this, entityPlayer).widget(new FancyMachineUIWidget(this, 198, 208));
-    }
-
-    @Override
-    public List<IFancyUIProvider> getSubTabs() {
-        return getParts().stream().filter(Objects::nonNull).map(IFancyUIProvider.class::cast)
-                .toList();
+    public void buildMainUI(ParentWidget<?> mainWidget, PosGuiData guiData, PanelSyncManager syncManager,
+                            UISettings settings) {
+        mainWidget.child(new ParentWidget<>()
+                .widthRel(0.95f)
+                .heightRel(.65f)
+                .margin(4, 0)
+                .left(3).top(2)
+                .horizontalCenter()
+                .child(Flow.row()
+                        .child(getMainTextPanel(syncManager, 186, 146))));
     }
 
-    @Override
-    public void attachTooltips(TooltipsPanel tooltipsPanel) {
-        for (IMultiPart part : getParts()) {
-            part.attachFancyTooltipsToController(this, tooltipsPanel);
-        }
+    public Widget<?> getMainTextPanel(PanelSyncManager syncManager, int width, int height) {
+        var parentWidget = new ParentWidget<>();
+        var listWidget = new ListWidget<>();
+        listWidget
+                .width(width - 6)
+                .height(height - 6)
+                .childSeparator(Icon.EMPTY_2PX)
+                .crossAxisAlignment(Alignment.CrossAxis.START)
+                .posRel(Alignment.CenterLeft)
+                .left(3)
+                .top(3);
+        parentWidget.size(width, height)
+                .background(GuiTextures.DISPLAY);
+        // Machine generic sync handlers
+        BooleanSyncValue isFormed = syncManager.getOrCreateSyncHandler("isFormed", BooleanSyncValue.class,
+                () -> new BooleanSyncValue(this::isFormed));
+        BooleanSyncValue power = syncManager.getOrCreateSyncHandler("workingEnabled", BooleanSyncValue.class,
+                () -> new BooleanSyncValue(this.recipeLogic::isWorkingEnabled, this.recipeLogic::setWorkingEnabled));
+        BooleanSyncValue active = syncManager.getOrCreateSyncHandler("isActive", BooleanSyncValue.class,
+                () -> new BooleanSyncValue(this.recipeLogic::isActive));
+        BooleanSyncValue waiting = syncManager.getOrCreateSyncHandler("isWaiting", BooleanSyncValue.class,
+                () -> new BooleanSyncValue(this.recipeLogic::isWaiting));
+
+        // Energy bank specific sync handlers
+        // These will not be called anywhere else, so we can create them directly instead of using
+        // getOrCreateSyncHandler
+        BooleanSyncValue energyBankExists = new BooleanSyncValue(() -> energyBank != null);
+        syncManager.syncValue("energyBankExists", energyBankExists);
+
+        BigIntegerSyncValue energyStored = new BigIntegerSyncValue(
+                energyBank::getStored, $ -> {});
+        syncManager.syncValue("energyStored", energyStored);
+
+        BigIntegerSyncValue capacity = new BigIntegerSyncValue(
+                energyBank::getCapacity, $ -> {});
+        syncManager.syncValue("capacity", capacity);
+
+        LongSyncValue passiveDrain = new LongSyncValue(this::getPassiveDrain);
+        syncManager.syncValue("passiveDrain", passiveDrain);
+
+        LongSyncValue inputPerSec = new LongSyncValue(() -> this.inputPerSec);
+        syncManager.syncValue("inputPerSec", inputPerSec);
+
+        LongSyncValue outputPerSec = new LongSyncValue(() -> this.outputPerSec);
+        syncManager.syncValue("outputPerSec", outputPerSec);
+
+        // Generic machine lines
+        listWidget.child(IKey.lang(Component.translatable("gtceu.multiblock.work_paused"))
+                .asWidget()
+                .setEnabledIf((widget) -> !power.getBoolValue()));
+        listWidget.child(IKey.lang(Component.translatable("gtceu.multiblock.running"))
+                .asWidget()
+                .setEnabledIf((widget) -> active.getBoolValue()));
+        listWidget.child(IKey.lang(Component.translatable("gtceu.multiblock.idling"))
+                .asWidget()
+                .setEnabledIf((widget) -> !active.getBoolValue() && power.getBoolValue()));
+        listWidget.child(IKey.lang(Component.translatable("gtceu.multiblock.waiting")
+                .setStyle(Style.EMPTY.withColor(ChatFormatting.RED)))
+                .asWidget()
+                .setEnabledIf((widget) -> waiting.getBoolValue()));
+
+        // Energy bank specific lines
+
+        var STYLE_GOLD = Style.EMPTY.withColor(ChatFormatting.GOLD);
+        var STYLE_DARK_RED = Style.EMPTY.withColor(ChatFormatting.DARK_RED);
+        var STYLE_GREEN = Style.EMPTY.withColor(ChatFormatting.GREEN);
+        var STYLE_RED = Style.EMPTY.withColor(ChatFormatting.RED);
+
+        listWidget.child(IKey.dynamic(() -> {
+            if (!energyBankExists.getBoolValue()) return Component.empty();
+            var storedComponent = Component.literal(FormattingUtil.formatNumbers(energyStored.getValue()));
+            return Component.translatable("gtceu.multiblock.power_substation.stored",
+                    storedComponent.setStyle(STYLE_GOLD));
+        })
+                .asWidget()
+                .setEnabledIf((widget) -> energyBankExists.getBoolValue()));
+
+        listWidget.child(IKey.dynamic(() -> {
+            if (!energyBankExists.getBoolValue()) return Component.empty();
+            var capacityComponent = Component.literal(FormattingUtil.formatNumbers(capacity.getValue()));
+            return Component.translatable("gtceu.multiblock.power_substation.capacity",
+                    capacityComponent.setStyle(STYLE_GOLD));
+        })
+                .asWidget()
+                .setEnabledIf((widget) -> energyBankExists.getBoolValue()));
+
+        listWidget.child(IKey.dynamic(() -> {
+            if (!energyBankExists.getBoolValue()) return Component.empty();
+            var passiveDrainComponent = Component.literal(FormattingUtil.formatNumbers(passiveDrain.getLongValue()));
+            return Component.translatable("gtceu.multiblock.power_substation.passive_drain",
+                    passiveDrainComponent.setStyle(STYLE_DARK_RED));
+        })
+                .asWidget()
+                .setEnabledIf((widget) -> energyBankExists.getBoolValue()));
+
+        listWidget.child(IKey.dynamic(() -> {
+            if (!energyBankExists.getBoolValue()) return Component.empty();
+            var avgInComponent = Component.literal(FormattingUtil.formatNumbers(inputPerSec.getLongValue() / 20));
+            return Component
+                    .translatable("gtceu.multiblock.power_substation.average_in",
+                            avgInComponent.setStyle(STYLE_GREEN))
+                    .withStyle(Style.EMPTY.withHoverEvent(new HoverEvent(HoverEvent.Action.SHOW_TEXT,
+                            Component.translatable("gtceu.multiblock.power_substation.average_in_hover"))));
+        })
+                .asWidget()
+                .setEnabledIf((widget) -> energyBankExists.getBoolValue()));
+        listWidget.child(IKey.dynamic(() -> {
+            if (!energyBankExists.getBoolValue()) return Component.empty();
+            var avgOutComponent = Component
+                    .literal(FormattingUtil.formatNumbers(Math.abs(outputPerSec.getLongValue() / 20)));
+            return Component
+                    .translatable("gtceu.multiblock.power_substation.average_out",
+                            avgOutComponent.setStyle(STYLE_RED))
+                    .withStyle(Style.EMPTY.withHoverEvent(new HoverEvent(HoverEvent.Action.SHOW_TEXT,
+                            Component.translatable("gtceu.multiblock.power_substation.average_out_hover"))));
+        })
+                .asWidget()
+                .setEnabledIf((widget) -> energyBankExists.getBoolValue()));
+
+        listWidget.child(IKey.dynamic(() -> {
+            if (!energyBankExists.getBoolValue() || inputPerSec.getLongValue() <= outputPerSec.getLongValue())
+                return Component.empty();
+            BigInteger timeToFillSeconds = capacity.getValue().subtract(energyStored.getValue())
+                    .divide(BigInteger.valueOf(inputPerSec.getLongValue() - outputPerSec.getLongValue()));
+            return Component.translatable("gtceu.multiblock.power_substation.time_to_fill",
+                    getTimeToFillDrainText(timeToFillSeconds).setStyle(STYLE_GREEN));
+        })
+                .asWidget()
+                .setEnabledIf((widget) -> energyBankExists.getBoolValue() &&
+                        inputPerSec.getLongValue() > outputPerSec.getLongValue()));
+
+        listWidget.child(IKey.dynamic(() -> {
+            if (!energyBankExists.getBoolValue() || inputPerSec.getLongValue() >= outputPerSec.getLongValue())
+                return Component.empty();
+            BigInteger timeToDrainSeconds = energyStored.getValue()
+                    .divide(BigInteger.valueOf(outputPerSec.getLongValue() - inputPerSec.getLongValue()));
+            return Component.translatable("gtceu.multiblock.power_substation.time_to_drain",
+                    getTimeToFillDrainText(timeToDrainSeconds).setStyle(STYLE_RED));
+        })
+                .asWidget()
+                .setEnabledIf((widget) -> energyBankExists.getBoolValue() &&
+                        inputPerSec.getLongValue() < outputPerSec.getLongValue()));
+        parentWidget.child(listWidget);
+        return parentWidget;
     }
 
     public static class PowerStationEnergyBank extends MachineTrait implements INBTSerializable<CompoundTag> {
diff --git a/src/main/java/com/gregtechceu/gtceu/common/machine/multiblock/electric/monitor/MonitorGroup.java b/src/main/java/com/gregtechceu/gtceu/common/machine/multiblock/electric/monitor/MonitorGroup.java
index 2977aca420f..35df7bf7f9a 100644
--- a/src/main/java/com/gregtechceu/gtceu/common/machine/multiblock/electric/monitor/MonitorGroup.java
+++ b/src/main/java/com/gregtechceu/gtceu/common/machine/multiblock/electric/monitor/MonitorGroup.java
@@ -11,6 +11,7 @@
 
 import net.minecraft.core.BlockPos;
 import net.minecraft.core.Direction;
+import net.minecraft.core.NonNullList;
 import net.minecraft.core.Vec3i;
 import net.minecraft.core.registries.Registries;
 import net.minecraft.nbt.CompoundTag;
@@ -19,6 +20,8 @@
 import net.minecraft.world.item.ItemStack;
 import net.minecraft.world.level.Level;
 
+import com.mojang.serialization.Codec;
+import com.mojang.serialization.codecs.RecordCodecBuilder;
 import it.unimi.dsi.fastutil.ints.IntOpenHashSet;
 import it.unimi.dsi.fastutil.ints.IntSet;
 import lombok.Getter;
@@ -30,10 +33,25 @@
 
 public class MonitorGroup {
 
+    public static final Codec<MonitorGroup> CODEC = RecordCodecBuilder
+            .create(instance -> instance.group(
+                    BlockPos.CODEC.listOf().fieldOf("monitorPositions")
+                            .forGetter(g -> g.monitorPositions.stream().toList()),
+                    Codec.STRING.fieldOf("name").forGetter(MonitorGroup::getName),
+                    ItemStack.CODEC.listOf().fieldOf("items").forGetter(g -> g.getItemStackHandler().toList()),
+                    ItemStack.CODEC.listOf().fieldOf("placeholderItems")
+                            .forGetter(g -> g.getPlaceholderSlotsHandler().toList()),
+                    BlockPos.CODEC.optionalFieldOf("target").forGetter(g -> Optional.ofNullable(g.getTargetRaw())),
+                    Direction.CODEC.optionalFieldOf("targetSide")
+                            .forGetter(g -> Optional.ofNullable(g.getTargetCoverSide())),
+                    Codec.INT.fieldOf("dataSlot").forGetter(MonitorGroup::getDataSlot))
+                    .apply(instance, MonitorGroup::new));
+
     @Getter
     private final Set<BlockPos> monitorPositions = new HashSet<>();
+    @Setter
     @Getter
-    private final String name;
+    private String name;
     @Getter
     private final CustomItemStackHandler itemStackHandler;
     @Getter
@@ -73,6 +91,21 @@ public MonitorGroup(String name, CustomItemStackHandler handler, CustomItemStack
         this.placeholderSlotsHandler = placeholderSlotsHandler;
     }
 
+    @SuppressWarnings("OptionalUsedAsFieldOrParameterType")
+    public MonitorGroup(List<BlockPos> monitorPositions, String name, List<ItemStack> items,
+                        List<ItemStack> placeholderItems, Optional<BlockPos> rawTarget,
+                        Optional<Direction> targetCoverSide, int dataSlot) {
+        this.monitorPositions.addAll(monitorPositions);
+        this.name = name;
+        this.itemStackHandler = new CustomItemStackHandler(
+                NonNullList.of(ItemStack.EMPTY, items.toArray(ItemStack[]::new)));
+        this.placeholderSlotsHandler = new CustomItemStackHandler(
+                NonNullList.of(ItemStack.EMPTY, placeholderItems.toArray(ItemStack[]::new)));
+        this.target = rawTarget.orElse(null);
+        this.targetCoverSide = targetCoverSide.orElse(null);
+        this.dataSlot = dataSlot;
+    }
+
     public void add(BlockPos pos) {
         monitorPositions.add(pos);
     }
diff --git a/src/main/java/com/gregtechceu/gtceu/common/machine/multiblock/electric/research/DataBankMachine.java b/src/main/java/com/gregtechceu/gtceu/common/machine/multiblock/electric/research/DataBankMachine.java
index 00f643a92c3..cc7bbaf8341 100644
--- a/src/main/java/com/gregtechceu/gtceu/common/machine/multiblock/electric/research/DataBankMachine.java
+++ b/src/main/java/com/gregtechceu/gtceu/common/machine/multiblock/electric/research/DataBankMachine.java
@@ -7,23 +7,25 @@
 import com.gregtechceu.gtceu.api.capability.recipe.EURecipeCapability;
 import com.gregtechceu.gtceu.api.capability.recipe.IO;
 import com.gregtechceu.gtceu.api.machine.TickableSubscription;
-import com.gregtechceu.gtceu.api.machine.feature.IFancyUIMachine;
-import com.gregtechceu.gtceu.api.machine.feature.multiblock.IDisplayUIMachine;
 import com.gregtechceu.gtceu.api.machine.feature.multiblock.IMaintenanceMachine;
 import com.gregtechceu.gtceu.api.machine.feature.multiblock.IMultiPart;
-import com.gregtechceu.gtceu.api.machine.multiblock.MultiblockDisplayText;
 import com.gregtechceu.gtceu.api.machine.multiblock.PartAbility;
 import com.gregtechceu.gtceu.api.machine.multiblock.WorkableElectricMultiblockMachine;
 import com.gregtechceu.gtceu.api.machine.trait.RecipeLogic;
 import com.gregtechceu.gtceu.api.misc.EnergyContainerList;
+import com.gregtechceu.gtceu.common.mui.GTMultiblockTextUtil;
 import com.gregtechceu.gtceu.config.ConfigHolder;
 
+import net.minecraft.ChatFormatting;
 import net.minecraft.MethodsReturnNonnullByDefault;
 import net.minecraft.network.chat.Component;
 import net.minecraft.server.TickTask;
 import net.minecraft.server.level.ServerLevel;
 import net.minecraft.world.level.block.Block;
 
+import brachy.modularui.api.widget.IWidget;
+import brachy.modularui.value.sync.LongSyncValue;
+import brachy.modularui.value.sync.PanelSyncManager;
 import it.unimi.dsi.fastutil.longs.Long2ObjectMap;
 import it.unimi.dsi.fastutil.longs.Long2ObjectMaps;
 import lombok.Getter;
@@ -37,7 +39,7 @@
 @MethodsReturnNonnullByDefault
 @ParametersAreNonnullByDefault
 public class DataBankMachine extends WorkableElectricMultiblockMachine
-                             implements IFancyUIMachine, IDisplayUIMachine, IControllable {
+                             implements IControllable {
 
     public static final int EUT_PER_HATCH = GTValues.VA[GTValues.EV];
     public static final int EUT_PER_HATCH_CHAINED = GTValues.VA[GTValues.LuV];
@@ -176,25 +178,18 @@ public void tick() {
     }
 
     @Override
-    public void addDisplayText(List<Component> textList) {
-        MultiblockDisplayText.builder(textList, isFormed())
-                .setWorkingStatus(true, isActive() && isWorkingEnabled()) // transform into two-state system for display
-                .setWorkingStatusKeys(
-                        "gtceu.multiblock.idling",
-                        "gtceu.multiblock.idling",
-                        "gtceu.multiblock.data_bank.providing")
-                .addEnergyUsageExactLine(getEnergyUsage())
-                .addWorkingStatusLine();
-    }
+    public List<IWidget> getWidgetsForDisplay(PanelSyncManager syncManager) {
+        LongSyncValue energyStoredSyncValue = new LongSyncValue(this::getEnergyUsage);
+        syncManager.syncValue("dataBankEnergyStored", energyStoredSyncValue);
+
+        List<IWidget> widgets = new ArrayList<>();
 
-    /*
-     * @Override
-     * protected void addWarningText(List<Component> textList) {
-     * MultiblockDisplayText.builder(textList, isFormed(), false)
-     * .addLowPowerLine(hasNotEnoughEnergy)
-     * .addMaintenanceProblemLines(maintenance.getMaintenanceProblems());
-     * }
-     */
+        widgets.add(GTMultiblockTextUtil.addEnergyUsageExactLine(this, syncManager, energyStoredSyncValue));
+        widgets.add(GTMultiblockTextUtil.addWorkingStatusLine(this, syncManager,
+                () -> Component.translatable("gtceu.multiblock.data_bank.providing").withStyle(ChatFormatting.GREEN)));
+
+        return widgets;
+    }
 
     @Override
     public int getProgress() {
diff --git a/src/main/java/com/gregtechceu/gtceu/common/machine/multiblock/electric/research/HPCAMachine.java b/src/main/java/com/gregtechceu/gtceu/common/machine/multiblock/electric/research/HPCAMachine.java
index f8349c8a361..5b151ff58c4 100644
--- a/src/main/java/com/gregtechceu/gtceu/common/machine/multiblock/electric/research/HPCAMachine.java
+++ b/src/main/java/com/gregtechceu/gtceu/common/machine/multiblock/electric/research/HPCAMachine.java
@@ -6,14 +6,10 @@
 import com.gregtechceu.gtceu.api.capability.recipe.EURecipeCapability;
 import com.gregtechceu.gtceu.api.capability.recipe.FluidRecipeCapability;
 import com.gregtechceu.gtceu.api.capability.recipe.IO;
-import com.gregtechceu.gtceu.api.gui.GuiTextures;
-import com.gregtechceu.gtceu.api.gui.util.TimedProgressSupplier;
-import com.gregtechceu.gtceu.api.gui.widget.ExtendedProgressWidget;
 import com.gregtechceu.gtceu.api.machine.MetaMachine;
 import com.gregtechceu.gtceu.api.machine.TickableSubscription;
 import com.gregtechceu.gtceu.api.machine.feature.multiblock.IMaintenanceMachine;
 import com.gregtechceu.gtceu.api.machine.feature.multiblock.IMultiPart;
-import com.gregtechceu.gtceu.api.machine.multiblock.MultiblockDisplayText;
 import com.gregtechceu.gtceu.api.machine.multiblock.WorkableElectricMultiblockMachine;
 import com.gregtechceu.gtceu.api.machine.trait.RecipeLogic;
 import com.gregtechceu.gtceu.api.misc.EnergyContainerList;
@@ -27,17 +23,12 @@
 import com.gregtechceu.gtceu.common.machine.trait.hpca.HPCAComponentTrait;
 import com.gregtechceu.gtceu.common.machine.trait.hpca.HPCAComputationProviderTrait;
 import com.gregtechceu.gtceu.common.machine.trait.hpca.HPCACoolantProviderTrait;
+import com.gregtechceu.gtceu.common.mui.GTByteBufAdapters;
+import com.gregtechceu.gtceu.common.mui.GTGuiTextures;
+import com.gregtechceu.gtceu.common.mui.GTMultiblockTextUtil;
 import com.gregtechceu.gtceu.config.ConfigHolder;
-import com.gregtechceu.gtceu.utils.FormattingUtil;
+import com.gregtechceu.gtceu.utils.GTStringUtils;
 import com.gregtechceu.gtceu.utils.GTTransferUtils;
-import com.gregtechceu.gtceu.utils.GTUtil;
-
-import com.lowdragmc.lowdraglib.gui.texture.IGuiTexture;
-import com.lowdragmc.lowdraglib.gui.texture.ProgressTexture;
-import com.lowdragmc.lowdraglib.gui.texture.ResourceTexture;
-import com.lowdragmc.lowdraglib.gui.widget.ImageWidget;
-import com.lowdragmc.lowdraglib.gui.widget.Widget;
-import com.lowdragmc.lowdraglib.gui.widget.WidgetGroup;
 
 import net.minecraft.ChatFormatting;
 import net.minecraft.MethodsReturnNonnullByDefault;
@@ -48,20 +39,28 @@
 import net.minecraft.network.chat.MutableComponent;
 import net.minecraft.server.TickTask;
 import net.minecraft.server.level.ServerLevel;
+import net.minecraft.world.item.ItemStack;
+import net.minecraft.world.item.TooltipFlag;
 import net.minecraft.world.level.Level;
 import net.minecraftforge.fluids.FluidStack;
 import net.minecraftforge.fluids.capability.IFluidHandler;
 
+import brachy.modularui.api.drawable.IDrawable;
+import brachy.modularui.api.drawable.IKey;
+import brachy.modularui.api.widget.IWidget;
+import brachy.modularui.screen.RichTooltip;
+import brachy.modularui.value.sync.GenericSyncValue;
+import brachy.modularui.value.sync.PanelSyncManager;
+import brachy.modularui.widgets.TextWidget;
+import brachy.modularui.widgets.layout.Grid;
 import it.unimi.dsi.fastutil.longs.Long2ObjectMap;
 import it.unimi.dsi.fastutil.longs.Long2ObjectMaps;
 import it.unimi.dsi.fastutil.objects.ObjectArrayList;
 import it.unimi.dsi.fastutil.objects.ObjectOpenHashSet;
 import lombok.Getter;
-import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 
 import java.util.*;
-import java.util.function.Supplier;
 
 import javax.annotation.ParametersAreNonnullByDefault;
 
@@ -87,15 +86,12 @@ public class HPCAMachine extends WorkableElectricMultiblockMachine
     @SaveField
     private double temperature = IDLE_TEMPERATURE; // start at idle temperature
 
-    private final TimedProgressSupplier progressSupplier;
-
     @Nullable
     protected TickableSubscription tickSubs;
 
     public HPCAMachine(BlockEntityCreationInfo info) {
         super(info);
         this.energyContainer = new EnergyContainerList(new ArrayList<>());
-        this.progressSupplier = new TimedProgressSupplier(200, 47, false);
         this.hpcaHandler = new HPCAGridHandler(this);
     }
 
@@ -174,19 +170,19 @@ public void onStructureInvalid() {
     }
 
     @Override
-    public int requestCWUt(int cwut, boolean simulate, @NotNull Collection<IOpticalComputationProvider> seen) {
+    public int requestCWUt(int cwut, boolean simulate, Collection<IOpticalComputationProvider> seen) {
         seen.add(this);
         return isActive() && isWorkingEnabled() && !hasNotEnoughEnergy ? hpcaHandler.allocateCWUt(cwut, simulate) : 0;
     }
 
     @Override
-    public int getMaxCWUt(@NotNull Collection<IOpticalComputationProvider> seen) {
+    public int getMaxCWUt(Collection<IOpticalComputationProvider> seen) {
         seen.add(this);
         return isActive() && isWorkingEnabled() ? hpcaHandler.getMaxCWUt() : 0;
     }
 
     @Override
-    public boolean canBridge(@NotNull Collection<IOpticalComputationProvider> seen) {
+    public boolean canBridge(Collection<IOpticalComputationProvider> seen) {
         seen.add(this);
         // don't show a problem if the structure is not yet formed
         return !isFormed() || hpcaHandler.hasHPCABridge();
@@ -251,67 +247,98 @@ private void consumeEnergy() {
     }
 
     @Override
-    public Widget createUIWidget() {
-        WidgetGroup builder = (WidgetGroup) super.createUIWidget();
-        // Create the hover grid
-        builder.addWidget(new ExtendedProgressWidget(
-                () -> hpcaHandler.getAllocatedCWUt() > 0 ? progressSupplier.getAsDouble() : 0,
-                74, 57, 47, 47, GuiTextures.HPCA_COMPONENT_OUTLINE)
-                .setServerTooltipSupplier(hpcaHandler::addInfo)
-                .setFillDirection(ProgressTexture.FillDirection.LEFT_TO_RIGHT));
-        int startX = 76;
-        int startY = 59;
-
-        // we need to know what components we have on the client
-        if (getLevel().isClientSide) {
-            if (isFormed) {
-                hpcaHandler.tryGatherClientComponents(this.getLevel(), this.getBlockPos(), this.getFrontFacing(),
-                        this.getUpwardsFacing(), this.isFlipped);
-            } else {
-                hpcaHandler.clearClientComponents();
-            }
-        }
-        for (int i = 0; i < 3; i++) {
-            for (int j = 0; j < 3; j++) {
-                final int index = i * 3 + j;
-                Supplier<IGuiTexture> textureSupplier = () -> hpcaHandler.getComponentTexture(index);
-                builder.addWidget(new ImageWidget(startX + (15 * j), startY + (15 * i), 13, 13, textureSupplier));
-            }
-        }
-        return builder;
-    }
-
-    @Override
-    public void addDisplayText(List<Component> textList) {
-        MultiblockDisplayText.builder(textList, isFormed())
-                .setWorkingStatus(true, hpcaHandler.getAllocatedCWUt() > 0) // transform into two-state system for
-                                                                            // display
-                .setWorkingStatusKeys(
-                        "gtceu.multiblock.idling",
-                        "gtceu.multiblock.idling",
-                        "gtceu.multiblock.data_bank.providing")
-                .addCustom(tl -> {
-                    if (isFormed()) {
-                        // Energy Usage
-                        tl.add(Component.translatable(
-                                "gtceu.multiblock.hpca.energy",
-                                FormattingUtil.formatNumbers(hpcaHandler.cachedEUt),
-                                FormattingUtil.formatNumbers(hpcaHandler.getMaxEUt()),
-                                GTValues.VNF[GTUtil.getTierByVoltage(hpcaHandler.getMaxEUt())])
-                                .withStyle(ChatFormatting.GRAY));
-
-                        // Provided Computation
-                        Component cwutInfo = Component.literal(
-                                hpcaHandler.cachedCWUt + " / " + hpcaHandler.getMaxCWUt() + " CWU/t")
-                                .withStyle(ChatFormatting.AQUA);
-                        tl.add(Component.translatable(
-                                "gtceu.multiblock.hpca.computation",
-                                cwutInfo).withStyle(ChatFormatting.GRAY));
-                    }
+    public List<IWidget> getWidgetsForDisplay(PanelSyncManager syncManager) {
+        if (isRemote()) {
+            hpcaHandler.clearClientComponents();
+            if (isFormed()) {
+                hpcaHandler.tryGatherClientComponents(getLevel(), getBlockPos(), getFrontFacing(), getUpwardsFacing(),
+                        isFlipped());
+            }
+        }
+        GenericSyncValue<Component> text = GenericSyncValue.builder(Component.class)
+                .adapter(GTByteBufAdapters.COMPONENT)
+                .getter(() -> {
+                    List<Component> list = new ArrayList<>();
+                    hpcaHandler.addErrors(list);
+                    hpcaHandler.addWarnings(list);
+                    hpcaHandler.addInfo(list);
+                    return GTStringUtils.toComponent(list);
                 })
-                .addWorkingStatusLine();
+                .build();
+        syncManager.syncValue("text", text);
+        List<IWidget> widgets = new ArrayList<>();
+        widgets.add(GTMultiblockTextUtil.addWorkingStatusLine(this, syncManager));
+        widgets.add(GTMultiblockTextUtil.addEnergyUsageExactLine(this, syncManager));
+        widgets.add(new TextWidget<>(IKey.dynamic(text::getValue)));
+        widgets.add(new Grid()
+                .mapTo(3, 9, i -> hpcaHandler.getComponentTexture(i).asWidget()
+                        .tooltip(hpcaHandler.getComponentTooltip(i)))
+                .horizontalCenter());
+        return widgets;
     }
 
+    // @Override
+    // public Widget createUIWidget() {
+    // WidgetGroup builder = (WidgetGroup) super.createUIWidget();
+    // // Create the hover grid
+    // builder.addWidget(new ExtendedProgressWidget(
+    // () -> hpcaHandler.getAllocatedCWUt() > 0 ? progressSupplier.getAsDouble() : 0,
+    // 74, 57, 47, 47, GuiTextures.HPCA_COMPONENT_OUTLINE)
+    // .setServerTooltipSupplier(hpcaHandler::addInfo)
+    // .setFillDirection(ProgressTexture.FillDirection.LEFT_TO_RIGHT));
+    // int startX = 76;
+    // int startY = 59;
+    //
+    // // we need to know what components we have on the client
+    // if (getLevel().isClientSide) {
+    // if (isFormed) {
+    // hpcaHandler.tryGatherClientComponents(this.getLevel(), this.getPos(), this.getFrontFacing(),
+    // this.getUpwardsFacing(), this.isFlipped);
+    // } else {
+    // hpcaHandler.clearClientComponents();
+    // }
+    // }
+    // for (int i = 0; i < 3; i++) {
+    // for (int j = 0; j < 3; j++) {
+    // final int index = i * 3 + j;
+    // Supplier<IGuiTexture> textureSupplier = () -> hpcaHandler.getComponentTexture(index);
+    // builder.addWidget(new ImageWidget(startX + (15 * j), startY + (15 * i), 13, 13, textureSupplier));
+    // }
+    // }
+    // return builder;
+    // }
+    //
+    // @Override
+    // public void addDisplayText(List<Component> textList) {
+    // MultiblockDisplayText.builder(textList, isFormed())
+    // .setWorkingStatus(true, hpcaHandler.getAllocatedCWUt() > 0) // transform into two-state system for
+    // // display
+    // .setWorkingStatusKeys(
+    // "gtceu.multiblock.idling",
+    // "gtceu.multiblock.idling",
+    // "gtceu.multiblock.data_bank.providing")
+    // .addCustom(tl -> {
+    // if (isFormed()) {
+    // // Energy Usage
+    // tl.add(Component.translatable(
+    // "gtceu.multiblock.hpca.energy",
+    // FormattingUtil.formatNumbers(hpcaHandler.cachedEUt),
+    // FormattingUtil.formatNumbers(hpcaHandler.getMaxEUt()),
+    // GTValues.VNF[GTUtil.getTierByVoltage(hpcaHandler.getMaxEUt())])
+    // .withStyle(ChatFormatting.GRAY));
+    //
+    // // Provided Computation
+    // Component cwutInfo = Component.literal(
+    // hpcaHandler.cachedCWUt + " / " + hpcaHandler.getMaxCWUt() + " CWU/t")
+    // .withStyle(ChatFormatting.AQUA);
+    // tl.add(Component.translatable(
+    // "gtceu.multiblock.hpca.computation",
+    // cwutInfo).withStyle(ChatFormatting.GRAY));
+    // }
+    // })
+    // .addWorkingStatusLine();
+    // }
+
     private ChatFormatting getDisplayTemperatureColor() {
         if (temperature < 500) {
             return ChatFormatting.GREEN;
@@ -645,21 +672,25 @@ public int getMaxCoolantDemand() {
         }
 
         public void addInfo(List<Component> textList) {
-            // Max Computation
-            MutableComponent data = Component.literal(Integer.toString(getMaxCWUt())).withStyle(ChatFormatting.AQUA);
-            textList.add(Component.translatable("gtceu.multiblock.hpca.info_max_computation", data)
+            // CWU/t
+            Component cwutInfo = Component.literal(cachedCWUt + " / " + getMaxCWUt() + " CWU/t")
+                    .withStyle(ChatFormatting.AQUA);
+            textList.add(Component.translatable("gtceu.multiblock.hpca.computation", cwutInfo)
+                    .withStyle(ChatFormatting.GRAY));
+
+            // Temperature
+            Component tempInfo = Component.literal(Math.round(controller.temperature / 10.0D) + " °C")
+                    .withStyle(controller.getDisplayTemperatureColor());
+            textList.add(Component.translatable("gtceu.multiblock.hpca.temperature", tempInfo)
                     .withStyle(ChatFormatting.GRAY));
 
             // Cooling
             ChatFormatting coolingColor = getMaxCoolingAmount() < getMaxCoolingDemand() ? ChatFormatting.RED :
                     ChatFormatting.GREEN;
-            data = Component.literal(Integer.toString(getMaxCoolingDemand())).withStyle(coolingColor);
-            textList.add(Component.translatable("gtceu.multiblock.hpca.info_max_cooling_demand", data)
-                    .withStyle(ChatFormatting.GRAY));
-
-            data = Component.literal(Integer.toString(getMaxCoolingAmount())).withStyle(coolingColor);
-            textList.add(Component.translatable("gtceu.multiblock.hpca.info_max_cooling_available", data)
-                    .withStyle(ChatFormatting.GRAY));
+            MutableComponent data = Component.literal(Integer.toString(getMaxCoolingDemand())).withStyle(coolingColor);
+            textList.add(
+                    Component.translatable("gtceu.multiblock.hpca.info_cooling_demand", data, getMaxCoolingAmount())
+                            .withStyle(ChatFormatting.GRAY));
 
             // Coolant Required
             if (getMaxCoolantDemand() > 0) {
@@ -712,13 +743,26 @@ public void addErrors(List<Component> textList) {
             }
         }
 
-        public ResourceTexture getComponentTexture(int index) {
+        public IDrawable getComponentTexture(int index) {
             if (components.size() <= index) {
-                return GuiTextures.BLANK_TRANSPARENT;
+                return GTGuiTextures.BLANK_TRANSPARENT;
             }
             if (components.get(index).getMachine() instanceof HPCAComponentPartMachine componentPartMachine)
                 return componentPartMachine.getComponentIcon();
-            return GuiTextures.BLANK_TRANSPARENT;
+            return GTGuiTextures.BLANK_TRANSPARENT;
+        }
+
+        public RichTooltip getComponentTooltip(int index) {
+            if (components.size() <= index) {
+                return new RichTooltip();
+            }
+            if (components.get(index).getMachine() instanceof HPCAComponentPartMachine componentPartMachine) {
+                ItemStack stack = componentPartMachine.getDefinition().asStack();
+                RichTooltip tooltip = new RichTooltip();
+                stack.getTooltipLines(null, TooltipFlag.NORMAL).forEach(tooltip::addLine);
+                return tooltip;
+            }
+            return new RichTooltip();
         }
 
         public void tryGatherClientComponents(Level world, BlockPos pos, Direction frontFacing,
diff --git a/src/main/java/com/gregtechceu/gtceu/common/machine/multiblock/electric/research/NetworkSwitchMachine.java b/src/main/java/com/gregtechceu/gtceu/common/machine/multiblock/electric/research/NetworkSwitchMachine.java
index e4898bf92fd..9455535d29f 100644
--- a/src/main/java/com/gregtechceu/gtceu/common/machine/multiblock/electric/research/NetworkSwitchMachine.java
+++ b/src/main/java/com/gregtechceu/gtceu/common/machine/multiblock/electric/research/NetworkSwitchMachine.java
@@ -6,12 +6,10 @@
 import com.gregtechceu.gtceu.api.capability.IOpticalComputationProvider;
 import com.gregtechceu.gtceu.api.capability.recipe.CWURecipeCapability;
 import com.gregtechceu.gtceu.api.capability.recipe.IO;
-import com.gregtechceu.gtceu.api.machine.multiblock.MultiblockDisplayText;
 import com.gregtechceu.gtceu.api.machine.multiblock.PartAbility;
 import com.gregtechceu.gtceu.api.machine.trait.NotifiableComputationContainer;
 
 import net.minecraft.MethodsReturnNonnullByDefault;
-import net.minecraft.network.chat.Component;
 import net.minecraft.world.level.block.Block;
 
 import it.unimi.dsi.fastutil.objects.ObjectOpenHashSet;
@@ -115,18 +113,18 @@ public boolean canBridge(Collection<IOpticalComputationProvider> seen) {
         return true;
     }
 
-    @Override
-    public void addDisplayText(List<Component> textList) {
-        MultiblockDisplayText.builder(textList, isFormed())
-                .setWorkingStatus(true, isActive() && isWorkingEnabled()) // transform into two-state system for display
-                .setWorkingStatusKeys(
-                        "gtceu.multiblock.idling",
-                        "gtceu.multiblock.idling",
-                        "gtceu.multiblock.data_bank.providing")
-                .addEnergyUsageExactLine(getEnergyUsage())
-                .addComputationUsageLine(computationHandler.getMaxCWUtForDisplay())
-                .addWorkingStatusLine();
-    }
+    // @Override
+    // public void addDisplayText(List<Component> textList) {
+    // MultiblockDisplayText.builder(textList, isFormed())
+    // .setWorkingStatus(true, isActive() && isWorkingEnabled()) // transform into two-state system for display
+    // .setWorkingStatusKeys(
+    // "gtceu.multiblock.idling",
+    // "gtceu.multiblock.idling",
+    // "gtceu.multiblock.data_bank.providing")
+    // .addEnergyUsageExactLine(getEnergyUsage())
+    // .addComputationUsageLine(computationHandler.getMaxCWUtForDisplay())
+    // .addWorkingStatusLine();
+    // }
 
     /*
      * @Override
diff --git a/src/main/java/com/gregtechceu/gtceu/common/machine/multiblock/electric/research/ResearchStationMachine.java b/src/main/java/com/gregtechceu/gtceu/common/machine/multiblock/electric/research/ResearchStationMachine.java
index 2d3eea4c21b..20792800340 100644
--- a/src/main/java/com/gregtechceu/gtceu/common/machine/multiblock/electric/research/ResearchStationMachine.java
+++ b/src/main/java/com/gregtechceu/gtceu/common/machine/multiblock/electric/research/ResearchStationMachine.java
@@ -7,22 +7,25 @@
 import com.gregtechceu.gtceu.api.capability.recipe.CWURecipeCapability;
 import com.gregtechceu.gtceu.api.capability.recipe.IO;
 import com.gregtechceu.gtceu.api.capability.recipe.ItemRecipeCapability;
-import com.gregtechceu.gtceu.api.machine.feature.multiblock.IDisplayUIMachine;
 import com.gregtechceu.gtceu.api.machine.feature.multiblock.IMultiPart;
-import com.gregtechceu.gtceu.api.machine.multiblock.MultiblockDisplayText;
 import com.gregtechceu.gtceu.api.machine.multiblock.WorkableElectricMultiblockMachine;
 import com.gregtechceu.gtceu.api.machine.trait.RecipeLogic;
 import com.gregtechceu.gtceu.api.recipe.ActionResult;
 import com.gregtechceu.gtceu.api.recipe.GTRecipe;
 import com.gregtechceu.gtceu.api.recipe.RecipeHelper;
 import com.gregtechceu.gtceu.common.machine.multiblock.part.ObjectHolderMachine;
+import com.gregtechceu.gtceu.common.mui.GTMultiblockTextUtil;
 
+import net.minecraft.ChatFormatting;
 import net.minecraft.MethodsReturnNonnullByDefault;
 import net.minecraft.network.chat.Component;
 import net.minecraft.world.item.ItemStack;
 
+import brachy.modularui.api.widget.IWidget;
+import brachy.modularui.value.sync.PanelSyncManager;
 import lombok.Getter;
 
+import java.util.ArrayList;
 import java.util.Collections;
 import java.util.List;
 
@@ -31,7 +34,7 @@
 @MethodsReturnNonnullByDefault
 @ParametersAreNonnullByDefault
 public class ResearchStationMachine extends WorkableElectricMultiblockMachine
-                                    implements IOpticalComputationReceiver, IDisplayUIMachine {
+                                    implements IOpticalComputationReceiver {
 
     @Getter
     private IOpticalComputationProvider computationProvider;
@@ -100,16 +103,16 @@ public boolean regressWhenWaiting() {
     }
 
     @Override
-    public void addDisplayText(List<Component> textList) {
-        MultiblockDisplayText.builder(textList, isFormed())
-                .setWorkingStatus(recipeLogic.isWorkingEnabled(), recipeLogic.isActive())
-                .setWorkingStatusKeys("gtceu.multiblock.idling", "gtceu.multiblock.work_paused",
-                        "gtceu.multiblock.research_station.researching")
-                .addEnergyUsageLine(energyContainer)
-                .addEnergyTierLine(tier)
-                .addWorkingStatusLine()
-                // .addComputationUsageExactLine(computationProvider.getMaxCWUt()) // TODO: (Onion)
-                .addProgressLineOnlyPercent(recipeLogic.getProgressPercent());
+    public List<IWidget> getWidgetsForDisplay(PanelSyncManager syncManager) {
+        List<IWidget> widgets = new ArrayList<>();
+        widgets.add(GTMultiblockTextUtil.addWorkingStatusLine(this, syncManager,
+                () -> Component.translatable("gtceu.multiblock.research_station.researching")
+                        .withStyle(ChatFormatting.GREEN)));
+        widgets.add(GTMultiblockTextUtil.addEnergyTierLine(this, syncManager));
+        widgets.add(GTMultiblockTextUtil.addEnergyUsageLine(this, syncManager));
+        widgets.add(GTMultiblockTextUtil.addOutputLines(this, syncManager));
+        widgets.add(GTMultiblockTextUtil.addProgressLinePercentOnly(this, syncManager));
+        return widgets;
     }
 
     public static class ResearchStationRecipeLogic extends RecipeLogic {
diff --git a/src/main/java/com/gregtechceu/gtceu/common/machine/multiblock/generator/LargeCombustionEngineMachine.java b/src/main/java/com/gregtechceu/gtceu/common/machine/multiblock/generator/LargeCombustionEngineMachine.java
index 0d181339977..fcd37f5ce67 100644
--- a/src/main/java/com/gregtechceu/gtceu/common/machine/multiblock/generator/LargeCombustionEngineMachine.java
+++ b/src/main/java/com/gregtechceu/gtceu/common/machine/multiblock/generator/LargeCombustionEngineMachine.java
@@ -4,12 +4,8 @@
 import com.gregtechceu.gtceu.api.blockentity.BlockEntityCreationInfo;
 import com.gregtechceu.gtceu.api.capability.recipe.IO;
 import com.gregtechceu.gtceu.api.fluids.store.FluidStorageKeys;
-import com.gregtechceu.gtceu.api.gui.GuiTextures;
-import com.gregtechceu.gtceu.api.gui.fancy.IFancyTooltip;
-import com.gregtechceu.gtceu.api.gui.fancy.TooltipsPanel;
 import com.gregtechceu.gtceu.api.machine.MetaMachine;
 import com.gregtechceu.gtceu.api.machine.feature.ITieredMachine;
-import com.gregtechceu.gtceu.api.machine.multiblock.MultiblockDisplayText;
 import com.gregtechceu.gtceu.api.machine.multiblock.WorkableElectricMultiblockMachine;
 import com.gregtechceu.gtceu.api.pattern.util.RelativeDirection;
 import com.gregtechceu.gtceu.api.recipe.GTRecipe;
@@ -27,8 +23,6 @@
 
 import net.minecraft.ChatFormatting;
 import net.minecraft.MethodsReturnNonnullByDefault;
-import net.minecraft.network.chat.Component;
-import net.minecraft.network.chat.Style;
 import net.minecraftforge.fluids.FluidStack;
 
 import lombok.Getter;
@@ -36,7 +30,6 @@
 import org.jetbrains.annotations.Nullable;
 
 import java.util.Iterator;
-import java.util.List;
 
 import javax.annotation.ParametersAreNonnullByDefault;
 
@@ -180,33 +173,33 @@ public boolean regressWhenWaiting() {
     // ******* GUI ********//
     //////////////////////////////////////
 
-    @Override
-    public void addDisplayText(List<Component> textList) {
-        MultiblockDisplayText.Builder builder = MultiblockDisplayText.builder(textList, isFormed())
-                .setWorkingStatus(recipeLogic.isWorkingEnabled(), recipeLogic.isActive());
-
-        long lastEUt = recipeLogic.getLastRecipe() != null ?
-                recipeLogic.getLastRecipe().getOutputEUt().getTotalEU() : 0;
-        if (isExtreme()) {
-            builder.addEnergyProductionLine(GTValues.V[tier + 1], lastEUt);
-        } else {
-            builder.addEnergyProductionAmpsLine(GTValues.V[tier] * 3, 3);
-        }
-
-        if (isActive() && isWorkingEnabled()) {
-            builder.addCurrentEnergyProductionLine(lastEUt);
-        }
-
-        builder.addFuelNeededLine(getRecipeFluidInputInfo(), recipeLogic.getDuration());
-
-        if (isFormed && isOxygenBoosted) {
-            final var key = isExtreme() ? "gtceu.multiblock.large_combustion_engine.liquid_oxygen_boosted" :
-                    "gtceu.multiblock.large_combustion_engine.oxygen_boosted";
-            builder.addCustom(tl -> tl.add(Component.translatable(key).withStyle(ChatFormatting.AQUA)));
-        }
-
-        builder.addWorkingStatusLine();
-    }
+    // @Override
+    // public void addDisplayText(List<Component> textList) {
+    // MultiblockDisplayText.Builder builder = MultiblockDisplayText.builder(textList, isFormed())
+    // .setWorkingStatus(recipeLogic.isWorkingEnabled(), recipeLogic.isActive());
+    //
+    // long lastEUt = recipeLogic.getLastRecipe() != null ?
+    // recipeLogic.getLastRecipe().getOutputEUt().getTotalEU() : 0;
+    // if (isExtreme()) {
+    // builder.addEnergyProductionLine(GTValues.V[tier + 1], lastEUt);
+    // } else {
+    // builder.addEnergyProductionAmpsLine(GTValues.V[tier] * 3, 3);
+    // }
+    //
+    // if (isActive() && isWorkingEnabled()) {
+    // builder.addCurrentEnergyProductionLine(lastEUt);
+    // }
+    //
+    // builder.addFuelNeededLine(getRecipeFluidInputInfo(), recipeLogic.getDuration());
+    //
+    // if (isFormed && isOxygenBoosted) {
+    // final var key = isExtreme() ? "gtceu.multiblock.large_combustion_engine.liquid_oxygen_boosted" :
+    // "gtceu.multiblock.large_combustion_engine.oxygen_boosted";
+    // builder.addCustom(tl -> tl.add(Component.translatable(key).withStyle(ChatFormatting.AQUA)));
+    // }
+    //
+    // builder.addWorkingStatusLine();
+    // }
 
     @Nullable
     public String getRecipeFluidInputInfo() {
@@ -224,14 +217,14 @@ public String getRecipeFluidInputInfo() {
         return ChatFormatting.RED + FormattingUtil.formatNumbers(neededAmount) + "mB";
     }
 
-    @Override
-    public void attachTooltips(TooltipsPanel tooltipsPanel) {
-        super.attachTooltips(tooltipsPanel);
-        tooltipsPanel.attachTooltips(new IFancyTooltip.Basic(
-                () -> GuiTextures.INDICATOR_NO_STEAM.get(false),
-                () -> List.of(Component.translatable("gtceu.multiblock.large_combustion_engine.obstructed")
-                        .setStyle(Style.EMPTY.withColor(ChatFormatting.RED))),
-                this::isIntakesObstructed,
-                () -> null));
-    }
+    // @Override
+    // public void attachTooltips(TooltipsPanel tooltipsPanel) {
+    // super.attachTooltips(tooltipsPanel);
+    // tooltipsPanel.attachTooltips(new IFancyTooltip.Basic(
+    // () -> GuiTextures.INDICATOR_NO_STEAM.get(false),
+    // () -> List.of(Component.translatable("gtceu.multiblock.large_combustion_engine.obstructed")
+    // .setStyle(Style.EMPTY.withColor(ChatFormatting.RED))),
+    // this::isIntakesObstructed,
+    // () -> null));
+    // }
 }
diff --git a/src/main/java/com/gregtechceu/gtceu/common/machine/multiblock/generator/LargeTurbineMachine.java b/src/main/java/com/gregtechceu/gtceu/common/machine/multiblock/generator/LargeTurbineMachine.java
index 6b00d51931b..8ebc5901ea6 100644
--- a/src/main/java/com/gregtechceu/gtceu/common/machine/multiblock/generator/LargeTurbineMachine.java
+++ b/src/main/java/com/gregtechceu/gtceu/common/machine/multiblock/generator/LargeTurbineMachine.java
@@ -14,19 +14,13 @@
 import com.gregtechceu.gtceu.api.recipe.modifier.ParallelLogic;
 import com.gregtechceu.gtceu.api.recipe.modifier.RecipeModifier;
 import com.gregtechceu.gtceu.common.machine.multiblock.part.RotorHolderPartMachine;
-import com.gregtechceu.gtceu.utils.FormattingUtil;
 
-import net.minecraft.ChatFormatting;
 import net.minecraft.MethodsReturnNonnullByDefault;
-import net.minecraft.network.chat.Component;
-import net.minecraft.network.chat.Style;
 
 import lombok.Getter;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 
-import java.util.List;
-
 import javax.annotation.ParametersAreNonnullByDefault;
 
 @ParametersAreNonnullByDefault
@@ -182,36 +176,36 @@ public boolean canVoidRecipeOutputs(RecipeCapability<?> capability) {
     // ******* GUI ********//
     //////////////////////////////////////
 
-    @Override
-    public void addDisplayText(List<Component> textList) {
-        super.addDisplayText(textList);
-        if (isFormed()) {
-            var rotorHolder = getRotorHolder();
-
-            if (rotorHolder != null && rotorHolder.getRotorEfficiency() > 0) {
-                textList.add(Component.translatable("gtceu.multiblock.turbine.rotor_speed",
-                        FormattingUtil.formatNumbers(rotorHolder.getRotorSpeed()),
-                        FormattingUtil.formatNumbers(rotorHolder.getMaxRotorHolderSpeed())));
-                textList.add(Component.translatable("gtceu.multiblock.turbine.efficiency",
-                        rotorHolder.getTotalEfficiency()));
-
-                long maxProduction = getOverclockVoltage();
-                long currentProduction = getCurrentProduction();
-
-                if (isActive()) {
-                    textList.add(3, Component.translatable("gtceu.multiblock.turbine.energy_per_tick",
-                            FormattingUtil.formatNumbers(currentProduction),
-                            FormattingUtil.formatNumbers(maxProduction)));
-                }
-
-                int rotorDurability = rotorHolder.getRotorDurabilityPercent();
-                if (rotorDurability > MIN_DURABILITY_TO_WARN) {
-                    textList.add(Component.translatable("gtceu.multiblock.turbine.rotor_durability", rotorDurability));
-                } else {
-                    textList.add(Component.translatable("gtceu.multiblock.turbine.rotor_durability", rotorDurability)
-                            .setStyle(Style.EMPTY.withColor(ChatFormatting.RED)));
-                }
-            }
-        }
-    }
+    // @Override
+    // public void addDisplayText(List<Component> textList) {
+    // super.addDisplayText(textList);
+    // if (isFormed()) {
+    // var rotorHolder = getRotorHolder();
+    //
+    // if (rotorHolder != null && rotorHolder.getRotorEfficiency() > 0) {
+    // textList.add(Component.translatable("gtceu.multiblock.turbine.rotor_speed",
+    // FormattingUtil.formatNumbers(rotorHolder.getRotorSpeed()),
+    // FormattingUtil.formatNumbers(rotorHolder.getMaxRotorHolderSpeed())));
+    // textList.add(Component.translatable("gtceu.multiblock.turbine.efficiency",
+    // rotorHolder.getTotalEfficiency()));
+    //
+    // long maxProduction = getOverclockVoltage();
+    // long currentProduction = getCurrentProduction();
+    //
+    // if (isActive()) {
+    // textList.add(3, Component.translatable("gtceu.multiblock.turbine.energy_per_tick",
+    // FormattingUtil.formatNumbers(currentProduction),
+    // FormattingUtil.formatNumbers(maxProduction)));
+    // }
+    //
+    // int rotorDurability = rotorHolder.getRotorDurabilityPercent();
+    // if (rotorDurability > MIN_DURABILITY_TO_WARN) {
+    // textList.add(Component.translatable("gtceu.multiblock.turbine.rotor_durability", rotorDurability));
+    // } else {
+    // textList.add(Component.translatable("gtceu.multiblock.turbine.rotor_durability", rotorDurability)
+    // .setStyle(Style.EMPTY.withColor(ChatFormatting.RED)));
+    // }
+    // }
+    // }
+    // }
 }
diff --git a/src/main/java/com/gregtechceu/gtceu/common/machine/multiblock/part/AutoMaintenanceHatchPartMachine.java b/src/main/java/com/gregtechceu/gtceu/common/machine/multiblock/part/AutoMaintenanceHatchPartMachine.java
index 2d5d529437b..626b9466da3 100644
--- a/src/main/java/com/gregtechceu/gtceu/common/machine/multiblock/part/AutoMaintenanceHatchPartMachine.java
+++ b/src/main/java/com/gregtechceu/gtceu/common/machine/multiblock/part/AutoMaintenanceHatchPartMachine.java
@@ -5,6 +5,10 @@
 import com.gregtechceu.gtceu.api.machine.feature.multiblock.IMaintenanceMachine;
 import com.gregtechceu.gtceu.api.machine.multiblock.part.TieredPartMachine;
 
+import net.minecraft.world.InteractionHand;
+import net.minecraft.world.entity.player.Player;
+import net.minecraft.world.phys.BlockHitResult;
+
 public class AutoMaintenanceHatchPartMachine extends TieredPartMachine implements IMaintenanceMachine {
 
     public AutoMaintenanceHatchPartMachine(BlockEntityCreationInfo info) {
@@ -44,4 +48,9 @@ public int getTimeActive() {
 
     @Override
     public void setTimeActive(int time) {}
+
+    @Override
+    public boolean shouldOpenUI(Player player, InteractionHand hand, BlockHitResult hit) {
+        return false;
+    }
 }
diff --git a/src/main/java/com/gregtechceu/gtceu/common/machine/multiblock/part/DataAccessHatchMachine.java b/src/main/java/com/gregtechceu/gtceu/common/machine/multiblock/part/DataAccessHatchMachine.java
index 22bfb2397d8..c13ca821d07 100644
--- a/src/main/java/com/gregtechceu/gtceu/common/machine/multiblock/part/DataAccessHatchMachine.java
+++ b/src/main/java/com/gregtechceu/gtceu/common/machine/multiblock/part/DataAccessHatchMachine.java
@@ -1,32 +1,27 @@
 package com.gregtechceu.gtceu.common.machine.multiblock.part;
 
-import com.gregtechceu.gtceu.GTCEu;
 import com.gregtechceu.gtceu.api.GTValues;
 import com.gregtechceu.gtceu.api.blockentity.BlockEntityCreationInfo;
 import com.gregtechceu.gtceu.api.capability.IDataAccessHatch;
 import com.gregtechceu.gtceu.api.capability.IMonitorComponent;
 import com.gregtechceu.gtceu.api.capability.recipe.IO;
 import com.gregtechceu.gtceu.api.capability.recipe.ItemRecipeCapability;
-import com.gregtechceu.gtceu.api.gui.GuiTextures;
-import com.gregtechceu.gtceu.api.gui.widget.SlotWidget;
 import com.gregtechceu.gtceu.api.machine.feature.IDataInfoProvider;
 import com.gregtechceu.gtceu.api.machine.multiblock.MultiblockControllerMachine;
 import com.gregtechceu.gtceu.api.machine.multiblock.part.TieredPartMachine;
 import com.gregtechceu.gtceu.api.machine.trait.NotifiableItemStackHandler;
 import com.gregtechceu.gtceu.api.recipe.GTRecipe;
 import com.gregtechceu.gtceu.api.sync_system.annotations.SaveField;
+import com.gregtechceu.gtceu.api.sync_system.annotations.SyncToClient;
 import com.gregtechceu.gtceu.common.data.GTRecipeTypes;
 import com.gregtechceu.gtceu.common.item.behavior.PortableScannerBehavior;
 import com.gregtechceu.gtceu.common.machine.multiblock.electric.research.DataBankMachine;
+import com.gregtechceu.gtceu.common.mui.GTGuiTextures;
+import com.gregtechceu.gtceu.common.mui.GTMuiMachineUtil;
 import com.gregtechceu.gtceu.common.recipe.condition.ResearchCondition;
 import com.gregtechceu.gtceu.utils.ItemStackHashStrategy;
 import com.gregtechceu.gtceu.utils.ResearchManager;
 
-import com.lowdragmc.lowdraglib.gui.texture.IGuiTexture;
-import com.lowdragmc.lowdraglib.gui.texture.ResourceTexture;
-import com.lowdragmc.lowdraglib.gui.widget.Widget;
-import com.lowdragmc.lowdraglib.gui.widget.WidgetGroup;
-
 import net.minecraft.MethodsReturnNonnullByDefault;
 import net.minecraft.network.chat.Component;
 import net.minecraft.world.InteractionHand;
@@ -35,6 +30,11 @@
 import net.minecraft.world.phys.BlockHitResult;
 import net.minecraftforge.items.IItemHandler;
 
+import brachy.modularui.api.drawable.IDrawable;
+import brachy.modularui.factory.PosGuiData;
+import brachy.modularui.screen.UISettings;
+import brachy.modularui.value.sync.PanelSyncManager;
+import brachy.modularui.widget.ParentWidget;
 import it.unimi.dsi.fastutil.objects.ObjectOpenCustomHashSet;
 import it.unimi.dsi.fastutil.objects.ObjectOpenHashSet;
 import lombok.Getter;
@@ -51,6 +51,7 @@ public class DataAccessHatchMachine extends TieredPartMachine
     private final Set<GTRecipe> recipes;
     @Getter
     private final boolean isCreative;
+    @SyncToClient
     @SaveField
     public final NotifiableItemStackHandler importItems;
 
@@ -82,21 +83,15 @@ public ItemStack insertItem(int slot, ItemStack stack, boolean simulate) {
         };
     }
 
+    // TODO MUI: Might need EIO widget? Not sure
     @Override
-    public Widget createUIWidget() {
-        int rowSize = (int) Math.sqrt(getInventorySize());
-        int xOffset = 18 * rowSize / 2;
-        WidgetGroup group = new WidgetGroup(0, 0, 18 * rowSize, 18 * rowSize);
-
-        for (int y = 0; y < rowSize; y++) {
-            for (int x = 0; x < rowSize; x++) {
-                int index = y * rowSize + x;
-                group.addWidget(new SlotWidget(importItems, index,
-                        rowSize * 9 + x * 18 - xOffset, y * 18, true, true)
-                        .setBackgroundTexture(GuiTextures.SLOT));
-            }
-        }
-        return group;
+    public void buildMainUI(ParentWidget<?> mainWidget, PosGuiData guiData, PanelSyncManager syncManager,
+                            UISettings settings) {
+        var grid = GTMuiMachineUtil.createSlotGroupFromInventory(importItems, "data_inventory", getInventorySize(), 'I',
+                i -> i.background(GTGuiTextures.SLOT, GTGuiTextures.DATA_ORB_OVERLAY), syncManager,
+                GTMuiMachineUtil.createSquareMatrix(importItems.getSlots(), 'I'));
+
+        mainWidget.child(grid.center());
     }
 
     @Override
@@ -178,8 +173,8 @@ public GTRecipe modifyRecipe(GTRecipe recipe) {
     }
 
     @Override
-    public IGuiTexture getComponentIcon() {
-        return new ResourceTexture(GTCEu.id("textures/item/data_module.png")).getSubTexture(0, 0, 1, 1 / 13f);
+    public IDrawable getIcon() {
+        return GTGuiTextures.DATA_HATCH;
     }
 
     @Override
diff --git a/src/main/java/com/gregtechceu/gtceu/common/machine/multiblock/part/DualHatchPartMachine.java b/src/main/java/com/gregtechceu/gtceu/common/machine/multiblock/part/DualHatchPartMachine.java
index 18829f2dffb..4a89506a959 100644
--- a/src/main/java/com/gregtechceu/gtceu/common/machine/multiblock/part/DualHatchPartMachine.java
+++ b/src/main/java/com/gregtechceu/gtceu/common/machine/multiblock/part/DualHatchPartMachine.java
@@ -2,27 +2,34 @@
 
 import com.gregtechceu.gtceu.api.blockentity.BlockEntityCreationInfo;
 import com.gregtechceu.gtceu.api.capability.recipe.IO;
-import com.gregtechceu.gtceu.api.gui.GuiTextures;
-import com.gregtechceu.gtceu.api.gui.widget.SlotWidget;
-import com.gregtechceu.gtceu.api.gui.widget.TankWidget;
 import com.gregtechceu.gtceu.api.machine.MachineDefinition;
 import com.gregtechceu.gtceu.api.machine.trait.NotifiableFluidTank;
 import com.gregtechceu.gtceu.api.sync_system.annotations.SaveField;
 import com.gregtechceu.gtceu.common.data.GTMachines;
+import com.gregtechceu.gtceu.common.mui.GTMuiMachineUtil;
 import com.gregtechceu.gtceu.utils.GTTransferUtils;
 import com.gregtechceu.gtceu.utils.ISubscription;
 
-import com.lowdragmc.lowdraglib.gui.widget.Widget;
-import com.lowdragmc.lowdraglib.gui.widget.WidgetGroup;
-import com.lowdragmc.lowdraglib.jei.IngredientIO;
-
 import net.minecraft.MethodsReturnNonnullByDefault;
 import net.minecraft.core.BlockPos;
 import net.minecraft.world.level.block.state.BlockState;
 import net.minecraftforge.fluids.FluidType;
 
+import brachy.modularui.factory.PosGuiData;
+import brachy.modularui.screen.UISettings;
+import brachy.modularui.value.sync.FluidSlotSyncHandler;
+import brachy.modularui.value.sync.ItemSlotSyncHandler;
+import brachy.modularui.value.sync.PanelSyncManager;
+import brachy.modularui.widget.ParentWidget;
+import brachy.modularui.widgets.SlotGroupWidget;
+import brachy.modularui.widgets.slot.FluidSlot;
+import brachy.modularui.widgets.slot.ItemSlot;
+import brachy.modularui.widgets.slot.ModularSlot;
+import brachy.modularui.widgets.slot.SlotGroup;
 import org.jetbrains.annotations.Nullable;
 
+import java.util.Arrays;
+
 import javax.annotation.ParametersAreNonnullByDefault;
 
 @ParametersAreNonnullByDefault
@@ -153,31 +160,27 @@ public boolean swapIO() {
     ///////////////////////////////
 
     @Override
-    public Widget createUIWidget() {
-        int slots = getInventorySize();
-        int tanks = (int) Math.sqrt(slots);
-        var group = new WidgetGroup(0, 0, 18 * (tanks + 1) + 16, 18 * tanks + 16);
-        var container = new WidgetGroup(4, 4, 18 * (tanks + 1) + 8, 18 * tanks + 8);
-
-        int index = 0;
-        for (int y = 0; y < tanks; y++) {
-            for (int x = 0; x < tanks; x++) {
-                container.addWidget(new SlotWidget(
-                        getInventory().storage, index++, 4 + x * 18, 4 + y * 18, true, io.support(IO.IN))
-                        .setBackgroundTexture(GuiTextures.SLOT)
-                        .setIngredientIO(this.io == IO.IN ? IngredientIO.INPUT : IngredientIO.OUTPUT));
-            }
-        }
-
-        index = 0;
-        for (int y = 0; y < tanks; y++) {
-            container.addWidget(new TankWidget(
-                    tank.getStorages()[index++], 4 + tanks * 18, 4 + y * 18, true, io.support(IO.IN))
-                    .setBackground(GuiTextures.FLUID_SLOT));
-        }
-
-        container.setBackground(GuiTextures.BACKGROUND_INVERSE);
-        group.addWidget(container);
-        return group;
+    public void buildMainUI(ParentWidget<?> mainWidget, PosGuiData guiData, PanelSyncManager syncManager,
+                            UISettings settings) {
+        String slotGroupName = "inv_slot_group";
+        SlotGroup slotGroup = new SlotGroup(slotGroupName, getInventorySize());
+        mainWidget.child(SlotGroupWidget.builder()
+                .matrix(Arrays.stream(GTMuiMachineUtil.createSquareMatrix(getInventorySize(), 'I'))
+                        .map(s -> s + 'F')
+                        .toArray(String[]::new))
+                .key('I', i -> {
+                    ModularSlot slot = new ModularSlot(getInventory(), i)
+                            .accessibility(io.support(IO.IN), true);
+                    ItemSlotSyncHandler syncHandler = new ItemSlotSyncHandler(slot.slotGroup(slotGroup));
+                    syncManager.syncValue(slotGroupName, i, syncHandler);
+                    return new ItemSlot().syncHandler(slotGroupName, i);
+                })
+                .key('F', i -> {
+                    FluidSlotSyncHandler syncHandler = new FluidSlotSyncHandler(tank.getStorages()[i])
+                            .canFillSlot(io.support(IO.IN))
+                            .canDrainSlot(true);
+                    syncManager.syncValue(slotGroupName + "_fluid", i, syncHandler);
+                    return new FluidSlot().syncHandler(slotGroupName + "_fluid", i);
+                }).build().margin(7, 10).center());
     }
 }
diff --git a/src/main/java/com/gregtechceu/gtceu/common/machine/multiblock/part/FluidHatchPartMachine.java b/src/main/java/com/gregtechceu/gtceu/common/machine/multiblock/part/FluidHatchPartMachine.java
index eeea2f47de8..cd1285ffd06 100644
--- a/src/main/java/com/gregtechceu/gtceu/common/machine/multiblock/part/FluidHatchPartMachine.java
+++ b/src/main/java/com/gregtechceu/gtceu/common/machine/multiblock/part/FluidHatchPartMachine.java
@@ -3,15 +3,10 @@
 import com.gregtechceu.gtceu.api.blockentity.BlockEntityCreationInfo;
 import com.gregtechceu.gtceu.api.blockentity.IPaintable;
 import com.gregtechceu.gtceu.api.capability.recipe.IO;
-import com.gregtechceu.gtceu.api.gui.GuiTextures;
-import com.gregtechceu.gtceu.api.gui.fancy.ConfiguratorPanel;
-import com.gregtechceu.gtceu.api.gui.widget.PhantomFluidWidget;
-import com.gregtechceu.gtceu.api.gui.widget.TankWidget;
-import com.gregtechceu.gtceu.api.gui.widget.ToggleButtonWidget;
 import com.gregtechceu.gtceu.api.machine.MachineDefinition;
 import com.gregtechceu.gtceu.api.machine.TickableSubscription;
-import com.gregtechceu.gtceu.api.machine.fancyconfigurator.CircuitFancyConfigurator;
 import com.gregtechceu.gtceu.api.machine.feature.IHasCircuitSlot;
+import com.gregtechceu.gtceu.api.machine.mui.MachineUIPanel;
 import com.gregtechceu.gtceu.api.machine.multiblock.MultiblockControllerMachine;
 import com.gregtechceu.gtceu.api.machine.multiblock.part.TieredIOPartMachine;
 import com.gregtechceu.gtceu.api.machine.trait.NotifiableFluidTank;
@@ -20,16 +15,14 @@
 import com.gregtechceu.gtceu.api.sync_system.annotations.SyncToClient;
 import com.gregtechceu.gtceu.common.data.GTMachines;
 import com.gregtechceu.gtceu.common.item.behavior.IntCircuitBehaviour;
+import com.gregtechceu.gtceu.common.mui.GTGuiTextures;
+import com.gregtechceu.gtceu.common.mui.GTMuiMachineUtil;
 import com.gregtechceu.gtceu.config.ConfigHolder;
 import com.gregtechceu.gtceu.utils.ExtendedUseOnContext;
+import com.gregtechceu.gtceu.utils.FormattingUtil;
 import com.gregtechceu.gtceu.utils.GTTransferUtils;
 import com.gregtechceu.gtceu.utils.ISubscription;
 
-import com.lowdragmc.lowdraglib.gui.widget.ImageWidget;
-import com.lowdragmc.lowdraglib.gui.widget.LabelWidget;
-import com.lowdragmc.lowdraglib.gui.widget.Widget;
-import com.lowdragmc.lowdraglib.gui.widget.WidgetGroup;
-
 import net.minecraft.MethodsReturnNonnullByDefault;
 import net.minecraft.core.BlockPos;
 import net.minecraft.core.Direction;
@@ -43,6 +36,20 @@
 import net.minecraftforge.fluids.FluidStack;
 import net.minecraftforge.fluids.FluidType;
 
+import brachy.modularui.api.drawable.IKey;
+import brachy.modularui.drawable.GuiTextures;
+import brachy.modularui.factory.PosGuiData;
+import brachy.modularui.screen.UISettings;
+import brachy.modularui.utils.Alignment;
+import brachy.modularui.value.sync.BooleanSyncValue;
+import brachy.modularui.value.sync.FluidSlotSyncHandler;
+import brachy.modularui.value.sync.PanelSyncManager;
+import brachy.modularui.widget.ParentWidget;
+import brachy.modularui.widgets.SlotGroupWidget;
+import brachy.modularui.widgets.TextWidget;
+import brachy.modularui.widgets.ToggleButton;
+import brachy.modularui.widgets.layout.Flow;
+import brachy.modularui.widgets.slot.FluidSlot;
 import lombok.Getter;
 import org.jetbrains.annotations.Nullable;
 
@@ -253,119 +260,69 @@ public boolean swapIO() {
         return true;
     }
 
-    //////////////////////////////////////
-    // ********** GUI ***********//
-    //////////////////////////////////////
-
-    @Override
-    public void attachConfigurators(ConfiguratorPanel configuratorPanel) {
-        super.attachConfigurators(configuratorPanel);
-        if (isCircuitSlotEnabled() && this.io == IO.IN) {
-            configuratorPanel.attachConfigurators(new CircuitFancyConfigurator(circuitInventory.storage));
-        }
-    }
-
-    @Override
-    public Widget createUIWidget() {
-        if (slots == 1) {
-            return createSingleSlotGUI();
-        } else {
-            return createMultiSlotGUI();
-        }
-    }
-
-    protected Widget createSingleSlotGUI() {
-        var group = new WidgetGroup(0, 0, 89, 63);
-        group.addWidget(new ImageWidget(4, 4, 81, 55, GuiTextures.DISPLAY));
-        TankWidget tankWidget;
-
-        // Add input/output-specific widgets
-        if (this.io == IO.OUT) {
-            // if this is an output hatch, assign tankWidget to the phantom widget displaying the locked fluid...
-            group.addWidget(tankWidget = new PhantomFluidWidget(this.tank.getLockedFluid(), 0, 67, 40, 18, 18,
-                    () -> this.tank.getLockedFluid().getFluid(), f -> {
-                        if (!this.tank.getFluidInTank(0).isEmpty()) {
-                            return;
-                        }
-                        if (f == null || f.isEmpty()) {
-                            this.tank.setLocked(false);
-                        } else {
-                            FluidStack newFluid = f.copy();
-                            newFluid.setAmount(1);
-                            this.tank.setLocked(true, newFluid);
-                        }
-                    }).setShowAmount(false).setDrawHoverTips(true).setBackground(GuiTextures.FLUID_SLOT));
-
-            group.addWidget(new ToggleButtonWidget(7, 40, 18, 18,
-                    GuiTextures.BUTTON_LOCK, this.tank::isLocked, this.tank::setLocked)
-                    .setTooltipText("gtceu.gui.fluid_lock.tooltip")
-                    .setShouldUseBaseBackground())
-                    // ...and add the actual tank widget separately.
-                    .addWidget(new TankWidget(tank.getStorages()[0], 67, 22, 18, 18, true, io.support(IO.IN))
-                            .setShowAmount(true).setDrawHoverTips(true).setBackground(GuiTextures.FLUID_SLOT));
-        } else {
-            group.addWidget(tankWidget = new TankWidget(tank.getStorages()[0], 67, 22, 18, 18, true, io.support(IO.IN))
-                    .setShowAmount(true).setDrawHoverTips(true).setBackground(GuiTextures.FLUID_SLOT));
-        }
-
-        group.addWidget(new LabelWidget(8, 8, "gtceu.gui.fluid_amount"))
-                .addWidget(new LabelWidget(8, 18, () -> getFluidAmountText(tankWidget)))
-                .addWidget(new LabelWidget(8, 28, () -> getFluidNameText(tankWidget).getString()));
-
-        group.setBackground(GuiTextures.BACKGROUND_INVERSE);
-        return group;
+    private Component getFluidNameText() {
+        return this.tank.getFluidInTank(0).isEmpty() ?
+                Component.translatable("gtceu.fluid.empty") :
+                this.tank.getFluidInTank(0).getDisplayName();
     }
 
-    private Component getFluidNameText(TankWidget tankWidget) {
-        Component translation;
-        if (!tank.getFluidInTank(tankWidget.getTank()).isEmpty()) {
-            translation = tank.getFluidInTank(tankWidget.getTank()).getDisplayName();
-        } else {
-            translation = this.tank.getLockedFluid().getFluid().getDisplayName();
-        }
-        return translation;
+    private Component getFluidAmountText() {
+        return Component.literal(FormattingUtil.formatBuckets(this.tank.getFluidInTank(0).getAmount()));
     }
 
-    private String getFluidAmountText(TankWidget tankWidget) {
-        String fluidAmount = "";
-        if (!tank.getFluidInTank(tankWidget.getTank()).isEmpty()) {
-            fluidAmount = getFormattedFluidAmount(tank.getFluidInTank(tankWidget.getTank()));
-        } else {
-            // Display Zero to show information about the locked fluid
-            if (!this.tank.getLockedFluid().getFluid().isEmpty()) {
-                fluidAmount = "0";
-            }
-        }
-        return fluidAmount;
+    private Component getFluidText() {
+        return getFluidNameText().copy().append("\n").append(getFluidAmountText());
     }
 
     public String getFormattedFluidAmount(FluidStack fluidStack) {
         return String.format("%,d", fluidStack.isEmpty() ? 0 : fluidStack.getAmount());
     }
 
-    protected Widget createMultiSlotGUI() {
-        int rowSize = (int) Math.sqrt(slots);
-        int colSize = rowSize;
-        if (slots == 8) {
-            rowSize = 4;
-            colSize = 2;
-        }
-
-        var group = new WidgetGroup(0, 0, 18 * rowSize + 16, 18 * colSize + 16);
-        var container = new WidgetGroup(4, 4, 18 * rowSize + 8, 18 * colSize + 8);
-
-        int index = 0;
-        for (int y = 0; y < colSize; y++) {
-            for (int x = 0; x < rowSize; x++) {
-                container.addWidget(
-                        new TankWidget(tank.getStorages()[index++], 4 + x * 18, 4 + y * 18, true, io.support(IO.IN))
-                                .setBackground(GuiTextures.FLUID_SLOT));
-            }
-        }
+    @Override
+    public void buildMainUI(ParentWidget<?> mainWidget, PosGuiData guiData, PanelSyncManager syncManager,
+                            UISettings settings) {
+        mainWidget.child(slots == 1 ? createSingleSlotUI(syncManager) : createMultiSlotUI(syncManager));
+    }
 
-        container.setBackground(GuiTextures.BACKGROUND_INVERSE);
-        group.addWidget(container);
+    protected Flow createSingleSlotUI(PanelSyncManager syncManager) {
+        BooleanSyncValue locked = new BooleanSyncValue(this.tank::isLocked, this.tank::setLocked);
+        syncManager.syncValue("locked", locked);
+        return Flow.col()
+                .width(MachineUIPanel.DEFAULT_CONTENT_WIDTH)
+                .height(60)
+                .mainAxisAlignment(Alignment.MainAxis.CENTER)
+                .childPadding(4)
+                .child(new TextWidget<>(IKey.dynamic(this::getFluidNameText))
+                        .horizontalCenter())
+                .child(new TextWidget<>(IKey.dynamic(this::getFluidAmountText))
+                        .horizontalCenter())
+                .child(Flow.row()
+                        .childPadding(2)
+                        .coverChildren()
+                        .childIf(io.support(IO.OUT), () -> new FluidSlot()
+                                .name("lockedFluid")
+                                .syncHandler(new FluidSlotSyncHandler(tank.getLockedFluid()))
+                                .alwaysShowFull(true)
+                                .tooltip(t -> t.addLine("Locked Fluid")))
+                        .childIf(io.support(IO.OUT), () -> new ToggleButton()
+                                .syncHandler("locked")
+                                .tooltip(t -> t.addLine("gtceu.gui.fluid_lock.tooltip"))
+                                .overlay(false, GTGuiTextures.BUTTON_LOCK)
+                                .overlay(true, GTGuiTextures.BUTTON_LOCK)
+                                .background(GuiTextures.MC_BUTTON)
+                                .selectedBackground(GuiTextures.MC_BUTTON_PRESSED)
+
+                        )
+                        .child(new FluidSlot()
+                                .name("regularFluid")
+                                .syncHandler(new FluidSlotSyncHandler(tank.getStorages()[0])
+                                        .canFillSlot(io.support(IO.IN)))));
+    }
 
-        return group;
+    protected SlotGroupWidget createMultiSlotUI(PanelSyncManager syncManager) {
+        return GTMuiMachineUtil.createSlotGroupFromInventory(
+                syncManager,
+                tank, "fluid_inv",
+                slots, 'F', GTMuiMachineUtil.createSquareMatrix(slots, 'F'));
     }
 }
diff --git a/src/main/java/com/gregtechceu/gtceu/common/machine/multiblock/part/ItemBusPartMachine.java b/src/main/java/com/gregtechceu/gtceu/common/machine/multiblock/part/ItemBusPartMachine.java
index 35d16d598fb..987f40f448c 100644
--- a/src/main/java/com/gregtechceu/gtceu/common/machine/multiblock/part/ItemBusPartMachine.java
+++ b/src/main/java/com/gregtechceu/gtceu/common/machine/multiblock/part/ItemBusPartMachine.java
@@ -6,12 +6,8 @@
 import com.gregtechceu.gtceu.api.cover.filter.FilterHandler;
 import com.gregtechceu.gtceu.api.cover.filter.FilterHandlers;
 import com.gregtechceu.gtceu.api.cover.filter.ItemFilter;
-import com.gregtechceu.gtceu.api.gui.GuiTextures;
-import com.gregtechceu.gtceu.api.gui.fancy.ConfiguratorPanel;
-import com.gregtechceu.gtceu.api.gui.widget.SlotWidget;
 import com.gregtechceu.gtceu.api.machine.MachineDefinition;
 import com.gregtechceu.gtceu.api.machine.TickableSubscription;
-import com.gregtechceu.gtceu.api.machine.fancyconfigurator.CircuitFancyConfigurator;
 import com.gregtechceu.gtceu.api.machine.feature.IHasCircuitSlot;
 import com.gregtechceu.gtceu.api.machine.feature.multiblock.IDistinctPart;
 import com.gregtechceu.gtceu.api.machine.multiblock.MultiblockControllerMachine;
@@ -26,14 +22,9 @@
 import com.gregtechceu.gtceu.utils.GTTransferUtils;
 import com.gregtechceu.gtceu.utils.ISubscription;
 
-import com.lowdragmc.lowdraglib.gui.widget.Widget;
-import com.lowdragmc.lowdraglib.gui.widget.WidgetGroup;
-import com.lowdragmc.lowdraglib.jei.IngredientIO;
-
 import net.minecraft.MethodsReturnNonnullByDefault;
 import net.minecraft.core.BlockPos;
 import net.minecraft.core.Direction;
-import net.minecraft.network.chat.Component;
 import net.minecraft.server.TickTask;
 import net.minecraft.server.level.ServerLevel;
 import net.minecraft.world.InteractionResult;
@@ -41,6 +32,14 @@
 import net.minecraft.world.level.block.Block;
 import net.minecraft.world.level.block.state.BlockState;
 
+import brachy.modularui.factory.PosGuiData;
+import brachy.modularui.screen.UISettings;
+import brachy.modularui.value.sync.PanelSyncManager;
+import brachy.modularui.value.sync.SyncHandlers;
+import brachy.modularui.widget.ParentWidget;
+import brachy.modularui.widgets.layout.Grid;
+import brachy.modularui.widgets.slot.ItemSlot;
+import brachy.modularui.widgets.slot.SlotGroup;
 import lombok.AccessLevel;
 import lombok.Getter;
 import org.jetbrains.annotations.Nullable;
@@ -266,7 +265,7 @@ public boolean swapIO() {
         getLevel().setBlockAndUpdate(blockPos, newBlockState);
 
         if (getLevel().getBlockEntity(blockPos) instanceof ItemBusPartMachine newMachine) {
-            // We don't set the circuit or distinct buses, since
+            // We don't set the circuit or distinct busses, since
             // that doesn't make sense on an output bus.
             // Furthermore, existing inventory items
             // and conveyors will drop to the floor on block override.
@@ -281,43 +280,24 @@ public boolean swapIO() {
     // ********** GUI ***********//
     //////////////////////////////////////
 
-    public void attachConfigurators(ConfiguratorPanel configuratorPanel) {
-        if (this.io == IO.IN) {
-            IDistinctPart.super.attachConfigurators(configuratorPanel);
-            if (hasCircuitSlot && isCircuitSlotEnabled()) {
-                configuratorPanel.attachConfigurators(new CircuitFancyConfigurator(circuitInventory.storage));
-            }
-        } else {
-            super.attachConfigurators(configuratorPanel);
-        }
-    }
-
     @Override
-    public Widget createUIWidget() {
+    public void buildMainUI(ParentWidget<?> mainWidget, PosGuiData guiData, PanelSyncManager syncManager,
+                            UISettings settings) {
         int rowSize = (int) Math.sqrt(getInventorySize());
-        int colSize = rowSize;
-        if (getInventorySize() == 8) {
-            rowSize = 4;
-            colSize = 2;
-        }
-        var group = new WidgetGroup(0, 0, 18 * rowSize + 16, 18 * colSize + 16);
-        var container = new WidgetGroup(4, 4, 18 * rowSize + 8, 18 * colSize + 8);
-        int index = 0;
-        if (this.io == IO.OUT) {
-            group.addWidget(filterHandler.createFilterSlotUI(71 + (18 * rowSize) / 2, 35 + 9 * rowSize)
-                    .setHoverTooltips(Component.translatable("cover.item_filter.title")));
-        }
-        for (int y = 0; y < colSize; y++) {
-            for (int x = 0; x < rowSize; x++) {
-                container.addWidget(
-                        new SlotWidget(getInventory().storage, index++, 4 + x * 18, 4 + y * 18, true, io.support(IO.IN))
-                                .setBackgroundTexture(GuiTextures.SLOT)
-                                .setIngredientIO(this.io == IO.IN ? IngredientIO.INPUT : IngredientIO.OUTPUT));
-            }
-        }
 
-        container.setBackground(GuiTextures.BACKGROUND_INVERSE);
-        group.addWidget(container);
-        return group;
+        SlotGroup group = new SlotGroup("item_inv", rowSize, 0, true);
+        mainWidget.child(new Grid()
+                .coverChildren()
+                .center()
+                .margin(7, 5)
+                .mapTo(rowSize, rowSize * rowSize, index -> new ItemSlot()
+                        .slot(SyncHandlers.itemSlot(inventory, index)
+                                .slotGroup(group)
+                                .changeListener((newItem, amount, client, init) -> {
+                                    if (amount) {
+                                        inventory.onContentsChanged();
+                                    }
+                                })
+                                .accessibility(inventory.handlerIO.support(IO.IN), true))));
     }
 }
diff --git a/src/main/java/com/gregtechceu/gtceu/common/machine/multiblock/part/MaintenanceHatchPartMachine.java b/src/main/java/com/gregtechceu/gtceu/common/machine/multiblock/part/MaintenanceHatchPartMachine.java
index db06ad3a5d4..7211ba67da6 100644
--- a/src/main/java/com/gregtechceu/gtceu/common/machine/multiblock/part/MaintenanceHatchPartMachine.java
+++ b/src/main/java/com/gregtechceu/gtceu/common/machine/multiblock/part/MaintenanceHatchPartMachine.java
@@ -3,12 +3,11 @@
 import com.gregtechceu.gtceu.api.GTValues;
 import com.gregtechceu.gtceu.api.blockentity.BlockEntityCreationInfo;
 import com.gregtechceu.gtceu.api.capability.recipe.IO;
-import com.gregtechceu.gtceu.api.gui.GuiTextures;
-import com.gregtechceu.gtceu.api.gui.widget.SlotWidget;
 import com.gregtechceu.gtceu.api.item.tool.GTToolType;
 import com.gregtechceu.gtceu.api.item.tool.ToolHelper;
 import com.gregtechceu.gtceu.api.machine.TickableSubscription;
 import com.gregtechceu.gtceu.api.machine.feature.multiblock.IMaintenanceMachine;
+import com.gregtechceu.gtceu.api.machine.mui.MachineUIPanel;
 import com.gregtechceu.gtceu.api.machine.multiblock.part.TieredPartMachine;
 import com.gregtechceu.gtceu.api.machine.property.GTMachineModelProperties;
 import com.gregtechceu.gtceu.api.machine.trait.NotifiableItemStackHandler;
@@ -16,18 +15,12 @@
 import com.gregtechceu.gtceu.api.sync_system.annotations.SyncToClient;
 import com.gregtechceu.gtceu.client.model.machine.MachineRenderState;
 import com.gregtechceu.gtceu.common.data.GTItems;
+import com.gregtechceu.gtceu.common.mui.GTGuiTextures;
 import com.gregtechceu.gtceu.utils.ExtendedUseOnContext;
-import com.gregtechceu.gtceu.utils.FormattingUtil;
-
-import com.lowdragmc.lowdraglib.gui.texture.GuiTextureGroup;
-import com.lowdragmc.lowdraglib.gui.widget.*;
+import com.gregtechceu.gtceu.utils.GTUtil;
 
 import net.minecraft.MethodsReturnNonnullByDefault;
-import net.minecraft.network.chat.Component;
-import net.minecraft.network.chat.HoverEvent;
-import net.minecraft.network.chat.Style;
 import net.minecraft.server.level.ServerPlayer;
-import net.minecraft.util.Mth;
 import net.minecraft.world.InteractionHand;
 import net.minecraft.world.InteractionResult;
 import net.minecraft.world.entity.player.Player;
@@ -35,6 +28,23 @@
 import net.minecraftforge.items.IItemHandler;
 import net.minecraftforge.items.wrapper.InvWrapper;
 
+import brachy.modularui.api.drawable.IDrawable;
+import brachy.modularui.api.drawable.IKey;
+import brachy.modularui.api.widget.IWidget;
+import brachy.modularui.drawable.ItemDrawable;
+import brachy.modularui.factory.PosGuiData;
+import brachy.modularui.screen.UISettings;
+import brachy.modularui.utils.Alignment;
+import brachy.modularui.value.sync.FloatSyncValue;
+import brachy.modularui.value.sync.InteractionSyncHandler;
+import brachy.modularui.value.sync.PanelSyncManager;
+import brachy.modularui.widget.ParentWidget;
+import brachy.modularui.widgets.ButtonWidget;
+import brachy.modularui.widgets.TextWidget;
+import brachy.modularui.widgets.layout.Flow;
+import brachy.modularui.widgets.slot.ItemSlot;
+import brachy.modularui.widgets.slot.ModularSlot;
+import brachy.modularui.widgets.textfield.TextFieldWidget;
 import lombok.Getter;
 import lombok.Setter;
 import org.jetbrains.annotations.Nullable;
@@ -44,7 +54,7 @@
 import java.util.Arrays;
 import java.util.List;
 import java.util.Objects;
-import java.util.function.DoubleSupplier;
+import java.util.stream.Stream;
 
 import javax.annotation.ParametersAreNonnullByDefault;
 
@@ -73,7 +83,6 @@ public class MaintenanceHatchPartMachine extends TieredPartMachine
     @SaveField
     @SyncToClient
     protected byte maintenanceProblems = startProblems();
-    @Getter
     @SaveField
     private float durationMultiplier = 1f;
     @Nullable
@@ -98,6 +107,11 @@ public byte startProblems() {
         return ALL_PROBLEMS;
     }
 
+    public void setDurationMultiplier(float durationMultiplier) {
+        this.durationMultiplier = durationMultiplier;
+        syncDataHolder.markClientSyncFieldDirty("durationMultiplier");
+    }
+
     //////////////////////////////////////
     // ********* Logic **********//
     //////////////////////////////////////
@@ -326,57 +340,117 @@ public InteractionResult onUseWithItem(ExtendedUseOnContext context) {
     //////////////////////////////////////
     // ******** GUI *********//
     //////////////////////////////////////
-    @Override
-    public Widget createUIWidget() {
-        WidgetGroup group;
-        if (isConfigurable) {
-            group = new WidgetGroup(0, 0, 150, 70);
-            group.addWidget(new DraggableScrollableWidgetGroup(4, 4, 150 - 8, 70 - 8).setBackground(GuiTextures.DISPLAY)
-                    .addWidget(new ComponentPanelWidget(4, 5, list -> {
-                        list.add(getTextWidgetText("duration", this::getDurationMultiplier));
-                        list.add(getTextWidgetText("time", this::getTimeMultiplier));
-                        var buttonText = Component.translatable("gtceu.maintenance.configurable_duration.modify");
-                        buttonText.append(" ");
-                        buttonText.append(ComponentPanelWidget.withButton(Component.literal("[-]"), "sub"));
-                        buttonText.append(" ");
-                        buttonText.append(ComponentPanelWidget.withButton(Component.literal("[+]"), "add"));
-                        list.add(buttonText);
-                    }).setMaxWidthLimit(150 - 8 - 8 - 4).clickHandler((componentData, clickData) -> {
-                        if (!clickData.isRemote) {
-                            if (componentData.equals("sub")) {
-                                durationMultiplier = Mth.clamp(durationMultiplier - DURATION_ACTION_AMOUNT,
-                                        MIN_DURATION_MULTIPLIER, MAX_DURATION_MULTIPLIER);
-                            } else if (componentData.equals("add")) {
-                                durationMultiplier = Mth.clamp(durationMultiplier + DURATION_ACTION_AMOUNT,
-                                        MIN_DURATION_MULTIPLIER, MAX_DURATION_MULTIPLIER);
-                            }
-                        }
-                    })));
-
-        } else {
-            group = new WidgetGroup(0, 0, 8 + 18, 8 + 20 + 18);
-        }
-        group.addWidget(new SlotWidget(itemStackHandler, 0, group.getSize().width - 4 - 18, 4)
-                .setBackgroundTexture(new GuiTextureGroup(GuiTextures.SLOT, GuiTextures.DUCT_TAPE_OVERLAY))
-                .setHoverTooltips("gtceu.machine.maintenance_hatch_tape_slot.tooltip"));
-        group.addWidget(new ButtonWidget(group.getSize().width - 4 - 18, 4 + 20, 18, 18, GuiTextures.MAINTENANCE_BUTTON,
-                data -> fixMaintenanceProblems(group.getGui().entityPlayer))
-                .setHoverTooltips("gtceu.machine.maintenance_hatch_tool_slot.tooltip"));
-        group.setBackground(GuiTextures.BACKGROUND_INVERSE);
-        return group;
-    }
+    /*
+     * @Override
+     * public Widget createUIWidget() {
+     * WidgetGroup group;
+     * if (isConfigurable) {
+     * group = new WidgetGroup(0, 0, 150, 70);
+     * group.addWidget(new DraggableScrollableWidgetGroup(4, 4, 150 - 8, 70 - 8).setBackground(GuiTextures.DISPLAY)
+     * .addWidget(new ComponentPanelWidget(4, 5, list -> {
+     * list.add(getTextWidgetText("duration", this::getDurationMultiplier));
+     * list.add(getTextWidgetText("time", this::getTimeMultiplier));
+     * var buttonText = Component.translatable("gtceu.maintenance.configurable_duration.modify");
+     * buttonText.append(" ");
+     * buttonText.append(ComponentPanelWidget.withButton(Component.literal("[-]"), "sub"));
+     * buttonText.append(" ");
+     * buttonText.append(ComponentPanelWidget.withButton(Component.literal("[+]"), "add"));
+     * list.add(buttonText);
+     * }).setMaxWidthLimit(150 - 8 - 8 - 4).clickHandler((componentData, clickData) -> {
+     * if (!clickData.isRemote) {
+     * if (componentData.equals("sub")) {
+     * durationMultiplier = Mth.clamp(durationMultiplier - DURATION_ACTION_AMOUNT,
+     * MIN_DURATION_MULTIPLIER, MAX_DURATION_MULTIPLIER);
+     * } else if (componentData.equals("add")) {
+     * durationMultiplier = Mth.clamp(durationMultiplier + DURATION_ACTION_AMOUNT,
+     * MIN_DURATION_MULTIPLIER, MAX_DURATION_MULTIPLIER);
+     * }
+     * }
+     * })));
+     *
+     * } else {
+     * group = new WidgetGroup(0, 0, 8 + 18, 8 + 20 + 18);
+     * }
+     * group.addWidget(new SlotWidget(itemStackHandler, 0, group.getSize().width - 4 - 18, 4)
+     * .setBackgroundTexture(new GuiTextureGroup(GuiTextures.SLOT, GuiTextures.DUCT_TAPE_OVERLAY))
+     * .setHoverTooltips("gtceu.machine.maintenance_hatch_tape_slot.tooltip"));
+     * group.addWidget(new ButtonWidget(group.getSize().width - 4 - 18, 4 + 20, 18, 18, GuiTextures.MAINTENANCE_BUTTON,
+     * data -> fixMaintenanceProblems(group.getGui().entityPlayer))
+     * .setHoverTooltips("gtceu.machine.maintenance_hatch_tool_slot.tooltip"));
+     * group.setBackground(GuiTextures.BACKGROUND_INVERSE);
+     * return group;
+     * }
+     */
 
-    private static Component getTextWidgetText(String type, DoubleSupplier multiplier) {
-        Component tooltip;
-        if (multiplier.getAsDouble() == 1.0) {
-            tooltip = Component.translatable("gtceu.maintenance.configurable_" + type + ".unchanged_description");
-        } else {
-            tooltip = Component.translatable("gtceu.maintenance.configurable_" + type + ".changed_description",
-                    FormattingUtil.formatNumber2Places(multiplier.getAsDouble()));
-        }
-        return Component
-                .translatable("gtceu.maintenance.configurable_" + type,
-                        FormattingUtil.formatNumber2Places(multiplier.getAsDouble()))
-                .setStyle(Style.EMPTY.withHoverEvent(new HoverEvent(HoverEvent.Action.SHOW_TEXT, tooltip)));
+    @Override
+    public void buildMainUI(ParentWidget<?> mainWidget, PosGuiData guiData, PanelSyncManager syncManager,
+                            UISettings settings) {
+        InteractionSyncHandler syncHandler = new InteractionSyncHandler();
+        // syncManager.syncValue("button_idk", syncHandler);
+        Flow maintenanceStatusWidget = Flow.column()
+                .crossAxisAlignment(Alignment.CrossAxis.START)
+                .coverChildren()
+                .padding(5)
+                .childPadding(2);
+        Runnable updateWidget = () -> {
+            while (!maintenanceStatusWidget.getChildren().isEmpty()) maintenanceStatusWidget.remove(0);
+            maintenanceStatusWidget.child(new TextWidget<>(IKey.lang(() -> hasMaintenanceProblems() ?
+                    "gtceu.top.maintenance_broken" :
+                    "gtceu.top.maintenance_fixed")))
+                    .child(Flow.row()
+                            .coverChildren()
+                            .children(Stream.iterate(Byte.valueOf("0"), i -> i < 6, i -> ++i)
+                                    .filter(i -> ((getMaintenanceProblems() >> i) & 1) == 0)
+                                    .map(GTUtil::getMaintenanceText)
+                                    .map(i -> new IDrawable.DrawableWidget(new ItemDrawable(i.getA())))
+                                    .map(IWidget.class::cast)
+                                    .toList()));
+        };
+        syncHandler.setOnMousePressed((button) -> {
+            fixMaintenanceProblems(guiData.getPlayer());
+            updateWidget.run();
+        });
+        updateWidget.run();
+        mainWidget.child(Flow.column()
+                .size(MachineUIPanel.DEFAULT_CONTENT_WIDTH, MachineUIPanel.DEFAULT_CONTENT_HEIGHT)
+                .crossAxisAlignment(Alignment.CrossAxis.START)
+                .childIf(this.isConfigurable, () -> Flow.column()
+                        .coverChildren()
+                        .padding(5)
+                        .paddingLeft(0)
+                        .marginLeft(5)
+                        .child(Flow.row()
+                                .coverChildren()
+                                .childPadding(5)
+                                .leftRel(0)
+                                .child(new TextWidget<>(
+                                        IKey.lang("gtceu.maintenance.configurable_duration.modify")))
+                                .child(new TextFieldWidget()
+                                        .setNumbersDouble(() -> MIN_DURATION_MULTIPLIER,
+                                                () -> MAX_DURATION_MULTIPLIER)
+                                        .setDefaultNumber(1)
+                                        .value(new FloatSyncValue(this::getDurationMultiplier,
+                                                this::setDurationMultiplier))
+                                        .addTooltipElement(IKey.lang(() -> getDurationMultiplier() == 1.0 ?
+                                                "gtceu.maintenance.configurable_duration.unchanged_description" :
+                                                "gtceu.maintenance.configurable_duration.changed_description"))))
+                        .child(new TextWidget<>(IKey.lang("gtceu.maintenance.configurable_time",
+                                () -> new Object[] { this.getTimeMultiplier() }))
+                                .leftRel(0)))
+                .child(Flow.row()
+                        .leftRel(0.5f)
+                        .coverChildren()
+                        .padding(5)
+                        .child(new ItemSlot()
+                                .slot(new ModularSlot(itemStackHandler, 0).changeListener(
+                                        (newItem, onlyAmountChanged, client, init) -> updateWidget.run()))
+                                .background(GTGuiTextures.SLOT, GTGuiTextures.DUCT_TAPE_OVERLAY))
+                        .child(new ButtonWidget<>()
+                                .background(GTGuiTextures.BUTTON_MAINTENANCE)
+                                .disableHoverBackground()
+                                .addTooltipElement(
+                                        IKey.lang("gtceu.machine.maintenance_hatch_tool_slot.tooltip"))
+                                .syncHandler(syncHandler)))
+                .child(maintenanceStatusWidget));
     }
 }
diff --git a/src/main/java/com/gregtechceu/gtceu/common/machine/multiblock/part/MufflerPartMachine.java b/src/main/java/com/gregtechceu/gtceu/common/machine/multiblock/part/MufflerPartMachine.java
index 189d870a4e6..f597589ed3d 100644
--- a/src/main/java/com/gregtechceu/gtceu/common/machine/multiblock/part/MufflerPartMachine.java
+++ b/src/main/java/com/gregtechceu/gtceu/common/machine/multiblock/part/MufflerPartMachine.java
@@ -4,12 +4,9 @@
 import com.gregtechceu.gtceu.api.blockentity.BlockEntityCreationInfo;
 import com.gregtechceu.gtceu.api.capability.GTCapabilityHelper;
 import com.gregtechceu.gtceu.api.capability.IHazardParticleContainer;
-import com.gregtechceu.gtceu.api.gui.GuiTextures;
-import com.gregtechceu.gtceu.api.gui.UITemplate;
-import com.gregtechceu.gtceu.api.gui.widget.SlotWidget;
 import com.gregtechceu.gtceu.api.machine.TickableSubscription;
+import com.gregtechceu.gtceu.api.machine.feature.IMuiMachine;
 import com.gregtechceu.gtceu.api.machine.feature.IRecipeLogicMachine;
-import com.gregtechceu.gtceu.api.machine.feature.IUIMachine;
 import com.gregtechceu.gtceu.api.machine.feature.multiblock.IWorkableMultiController;
 import com.gregtechceu.gtceu.api.machine.multiblock.MultiblockControllerMachine;
 import com.gregtechceu.gtceu.api.machine.multiblock.part.TieredPartMachine;
@@ -21,17 +18,17 @@
 import com.gregtechceu.gtceu.common.machine.trait.hazard.EnvironmentalHazardEmitterTrait;
 import com.gregtechceu.gtceu.utils.GTUtil;
 
-import com.lowdragmc.lowdraglib.gui.modular.ModularUI;
-import com.lowdragmc.lowdraglib.gui.widget.LabelWidget;
-
 import net.minecraft.MethodsReturnNonnullByDefault;
 import net.minecraft.core.BlockPos;
-import net.minecraft.world.entity.player.Player;
 import net.minecraft.world.item.ItemStack;
 import net.minecraftforge.api.distmarker.Dist;
 import net.minecraftforge.api.distmarker.OnlyIn;
 import net.minecraftforge.items.ItemHandlerHelper;
 
+import brachy.modularui.factory.PosGuiData;
+import brachy.modularui.screen.UISettings;
+import brachy.modularui.value.sync.PanelSyncManager;
+import brachy.modularui.widget.ParentWidget;
 import lombok.Getter;
 import org.jetbrains.annotations.MustBeInvokedByOverriders;
 import org.jetbrains.annotations.Nullable;
@@ -40,9 +37,11 @@
 
 import javax.annotation.ParametersAreNonnullByDefault;
 
+import static com.gregtechceu.gtceu.common.mui.GTMuiMachineUtil.createSquareSlotGroupFromInventory;
+
 @ParametersAreNonnullByDefault
 @MethodsReturnNonnullByDefault
-public class MufflerPartMachine extends TieredPartMachine implements IUIMachine {
+public class MufflerPartMachine extends TieredPartMachine implements IMuiMachine {
 
     @Getter
     private final int recoveryChance;
@@ -173,25 +172,12 @@ public void emitPollutionParticles() {
     //////////////////////////////////////
     // ********** GUI ***********//
     //////////////////////////////////////
+
     @Override
-    public ModularUI createUI(Player entityPlayer) {
-        int rowSize = (int) Math.sqrt(inventory.getSlots());
-        int xOffset = rowSize == 10 ? 9 : 0;
-        var modular = new ModularUI(176 + xOffset * 2,
-                18 + 18 * rowSize + 94, this, entityPlayer)
-                .background(GuiTextures.BACKGROUND)
-                .widget(new LabelWidget(10, 5, getBlockState().getBlock().getDescriptionId()))
-                .widget(UITemplate.bindPlayerInventory(entityPlayer.getInventory(), GuiTextures.SLOT, 7 + xOffset,
-                        18 + 18 * rowSize + 12, true));
-
-        for (int y = 0; y < rowSize; y++) {
-            for (int x = 0; x < rowSize; x++) {
-                int index = y * rowSize + x;
-                modular.widget(new SlotWidget(inventory, index,
-                        (88 - rowSize * 9 + x * 18) + xOffset, 18 + y * 18, true, false)
-                        .setBackgroundTexture(GuiTextures.SLOT));
-            }
-        }
-        return modular;
+    public void buildMainUI(ParentWidget<?> mainWidget, PosGuiData guiData, PanelSyncManager syncManager,
+                            UISettings settings) {
+        mainWidget
+                .child(createSquareSlotGroupFromInventory(inventory, "muffler_inventory", syncManager).margin(10)
+                        .center());
     }
 }
diff --git a/src/main/java/com/gregtechceu/gtceu/common/machine/multiblock/part/ObjectHolderMachine.java b/src/main/java/com/gregtechceu/gtceu/common/machine/multiblock/part/ObjectHolderMachine.java
index 736f33bb546..629f4df902b 100644
--- a/src/main/java/com/gregtechceu/gtceu/common/machine/multiblock/part/ObjectHolderMachine.java
+++ b/src/main/java/com/gregtechceu/gtceu/common/machine/multiblock/part/ObjectHolderMachine.java
@@ -2,8 +2,6 @@
 
 import com.gregtechceu.gtceu.api.blockentity.BlockEntityCreationInfo;
 import com.gregtechceu.gtceu.api.capability.recipe.IO;
-import com.gregtechceu.gtceu.api.gui.GuiTextures;
-import com.gregtechceu.gtceu.api.gui.widget.BlockableSlotWidget;
 import com.gregtechceu.gtceu.api.item.IComponentItem;
 import com.gregtechceu.gtceu.api.item.component.IDataItem;
 import com.gregtechceu.gtceu.api.item.component.IItemComponent;
@@ -12,15 +10,19 @@
 import com.gregtechceu.gtceu.api.sync_system.annotations.SaveField;
 import com.gregtechceu.gtceu.api.sync_system.annotations.SyncToClient;
 import com.gregtechceu.gtceu.api.transfer.item.CustomItemStackHandler;
-
-import com.lowdragmc.lowdraglib.gui.widget.ImageWidget;
-import com.lowdragmc.lowdraglib.gui.widget.Widget;
-import com.lowdragmc.lowdraglib.gui.widget.WidgetGroup;
-import com.lowdragmc.lowdraglib.utils.Position;
+import com.gregtechceu.gtceu.common.mui.GTGuiTextures;
 
 import net.minecraft.core.Direction;
 import net.minecraft.world.item.ItemStack;
 
+import brachy.modularui.factory.PosGuiData;
+import brachy.modularui.screen.UISettings;
+import brachy.modularui.value.sync.PanelSyncManager;
+import brachy.modularui.widget.ParentWidget;
+import brachy.modularui.widgets.layout.Flow;
+import brachy.modularui.widgets.slot.ItemSlot;
+import brachy.modularui.widgets.slot.ModularSlot;
+import brachy.modularui.widgets.slot.SlotGroup;
 import lombok.Getter;
 
 public class ObjectHolderMachine extends MultiblockPartMachine {
@@ -71,15 +73,31 @@ private ItemStack getHeldItem(int slot, boolean remove) {
     }
 
     @Override
-    public Widget createUIWidget() {
-        return new WidgetGroup(new Position(0, 0))
-                .addWidget(new ImageWidget(46, 15, 84, 60, GuiTextures.PROGRESS_BAR_RESEARCH_STATION_BASE))
-                .addWidget(new BlockableSlotWidget(heldItems, 0, 79, 36)
-                        .setIsBlocked(this::isLocked)
-                        .setBackground(GuiTextures.SLOT, GuiTextures.RESEARCH_STATION_OVERLAY))
-                .addWidget(new BlockableSlotWidget(heldItems, 1, 15, 36)
-                        .setIsBlocked(this::isLocked)
-                        .setBackground(GuiTextures.SLOT, GuiTextures.DATA_ORB_OVERLAY));
+    public void buildMainUI(ParentWidget<?> mainWidget, PosGuiData guiData, PanelSyncManager syncManager,
+                            UISettings settings) {
+        SlotGroup objectGroup = new SlotGroup("object_slot", 1);
+        SlotGroup orbGroup = new SlotGroup("orb_slot", 1);
+
+        mainWidget.child(Flow.row()
+                .center()
+                .coverChildren()
+                .child(new ItemSlot()
+                        .slot(new ModularSlot(heldItems, 1).slotGroup(orbGroup))
+                        .background(GTGuiTextures.SLOT, GTGuiTextures.DATA_ORB_OVERLAY)
+                        .marginLeft(30)
+                        .marginRight(30)
+                        .verticalCenter())
+
+                .child(GTGuiTextures.PROGRESS_BAR_RESEARCH_STATION_BASE.asWidget()
+                        .size(84, 60)
+                        .pos(75, 0))
+
+                .child(new ItemSlot()
+                        .slot(new ModularSlot(heldItems, 0).slotGroup(objectGroup))
+                        .background(GTGuiTextures.SLOT, GTGuiTextures.RESEARCH_STATION_OVERLAY)
+                        .marginLeft(30)
+                        .marginRight(30)
+                        .verticalCenter()));
     }
 
     @Override
diff --git a/src/main/java/com/gregtechceu/gtceu/common/machine/multiblock/part/ParallelHatchPartMachine.java b/src/main/java/com/gregtechceu/gtceu/common/machine/multiblock/part/ParallelHatchPartMachine.java
index 3dd1c4d534d..b0a8e101438 100644
--- a/src/main/java/com/gregtechceu/gtceu/common/machine/multiblock/part/ParallelHatchPartMachine.java
+++ b/src/main/java/com/gregtechceu/gtceu/common/machine/multiblock/part/ParallelHatchPartMachine.java
@@ -2,21 +2,30 @@
 
 import com.gregtechceu.gtceu.api.GTValues;
 import com.gregtechceu.gtceu.api.blockentity.BlockEntityCreationInfo;
-import com.gregtechceu.gtceu.api.gui.widget.IntInputWidget;
-import com.gregtechceu.gtceu.api.machine.feature.IFancyUIMachine;
+import com.gregtechceu.gtceu.api.machine.feature.IMuiMachine;
 import com.gregtechceu.gtceu.api.machine.feature.IRecipeLogicMachine;
 import com.gregtechceu.gtceu.api.machine.multiblock.MultiblockControllerMachine;
 import com.gregtechceu.gtceu.api.machine.multiblock.part.TieredPartMachine;
 import com.gregtechceu.gtceu.api.sync_system.annotations.SaveField;
-
-import com.lowdragmc.lowdraglib.gui.widget.Widget;
-import com.lowdragmc.lowdraglib.gui.widget.WidgetGroup;
+import com.gregtechceu.gtceu.utils.GTMath;
 
 import net.minecraft.util.Mth;
 
+import brachy.modularui.api.drawable.IKey;
+import brachy.modularui.drawable.DynamicDrawable;
+import brachy.modularui.factory.PosGuiData;
+import brachy.modularui.screen.UISettings;
+import brachy.modularui.utils.Alignment;
+import brachy.modularui.utils.MouseData;
+import brachy.modularui.value.sync.IntSyncValue;
+import brachy.modularui.value.sync.PanelSyncManager;
+import brachy.modularui.widget.ParentWidget;
+import brachy.modularui.widgets.ButtonWidget;
+import brachy.modularui.widgets.layout.Flow;
+import brachy.modularui.widgets.textfield.TextFieldWidget;
 import lombok.Getter;
 
-public class ParallelHatchPartMachine extends TieredPartMachine implements IFancyUIMachine {
+public class ParallelHatchPartMachine extends TieredPartMachine implements IMuiMachine {
 
     private static final int MIN_PARALLEL = 1;
 
@@ -42,17 +51,89 @@ public void setCurrentParallel(int parallelAmount) {
     }
 
     @Override
-    public Widget createUIWidget() {
-        WidgetGroup parallelAmountGroup = new WidgetGroup(0, 0, 100, 20);
-        parallelAmountGroup.addWidget(new IntInputWidget(this::getCurrentParallel, this::setCurrentParallel)
-                .setMin(MIN_PARALLEL)
-                .setMax(maxParallel));
-
-        return parallelAmountGroup;
+    public boolean canShared() {
+        return false;
     }
 
     @Override
-    public boolean canShared() {
-        return false;
+    public void buildMainUI(ParentWidget<?> mainWidget, PosGuiData guiData, PanelSyncManager syncManager,
+                            UISettings settings) {
+        IntSyncValue parallels = new IntSyncValue(this::getCurrentParallel, this::setCurrentParallel);
+        mainWidget.child(Flow.row()
+                .size(180, 60)
+                .child(new ButtonWidget<>()
+                        .overlay(new DynamicDrawable(() -> {
+                            MouseData mouseData = MouseData.create(-1);
+                            if (mouseData.ctrl() && mouseData.shift()) {
+                                return IKey.str("/16");
+                            } else if (mouseData.ctrl()) {
+                                return IKey.str("/8");
+                            } else if (mouseData.shift()) {
+                                return IKey.str("/4");
+                            } else {
+                                return IKey.str("/2");
+                            }
+                        }))
+                        .width(32)
+                        .height(16)
+                        .onMousePressed((a, b, c) -> {
+                            MouseData mouseData = MouseData.create(c);
+                            if (mouseData.ctrl() && mouseData.shift()) {
+                                parallels.setValue((int) GTMath.clamp(parallels.getValue() / 16, 1, this.maxParallel));
+                            } else if (mouseData.ctrl()) {
+                                parallels.setValue((int) GTMath.clamp(parallels.getValue() / 8, 1, this.maxParallel));
+                            } else if (mouseData.shift()) {
+                                parallels.setValue((int) GTMath.clamp(parallels.getValue() / 4, 1, this.maxParallel));
+                            } else {
+                                parallels.setValue((int) GTMath.clamp(parallels.getValue() / 2, 1, this.maxParallel));
+                            }
+                            return true;
+                        })
+                        .marginLeft(4)
+                        .verticalCenter())
+                .child(
+                        new TextFieldWidget()
+                                .width(40)
+                                .setTextAlignment(Alignment.CENTER)
+                                .setNumbers(1, this.maxParallel)
+                                .value(parallels)
+                                .setDefaultNumber(1)
+                                .marginLeft(4)
+                                .verticalCenter())
+                .child(new ButtonWidget<>()
+                        .overlay(new DynamicDrawable(() -> {
+                            MouseData mouseData = MouseData.create(-1);
+                            if (mouseData.ctrl() && mouseData.shift()) {
+                                return IKey.str("x16");
+                            } else if (mouseData.ctrl()) {
+                                return IKey.str("x8");
+                            } else if (mouseData.shift()) {
+                                return IKey.str("x4");
+                            } else {
+                                return IKey.str("x2");
+                            }
+                        }))
+                        .width(32)
+                        .height(16)
+                        .onMousePressed((a, b, c) -> {
+                            MouseData mouseData = MouseData.create(c);
+                            if (mouseData.ctrl() && mouseData.shift()) {
+                                parallels.setValue((int) GTMath.clamp(parallels.getValue() * 16, 1, this.maxParallel));
+                            } else if (mouseData.ctrl()) {
+                                parallels.setValue((int) GTMath.clamp(parallels.getValue() * 8, 1, this.maxParallel));
+                            } else if (mouseData.shift()) {
+                                parallels.setValue((int) GTMath.clamp(parallels.getValue() * 4, 1, this.maxParallel));
+                            } else {
+                                parallels.setValue((int) GTMath.clamp(parallels.getValue() * 2, 1, this.maxParallel));
+                            }
+                            return true;
+                        })
+                        .marginLeft(4)
+                        .verticalCenter())
+                .child(IKey.lang("gtceu.machine.parallel_hatch.parallel_ui")
+                        .asWidget()
+                        .marginLeft(4)
+                        .marginRight(4)
+                        .verticalCenter()));
     }
 }
diff --git a/src/main/java/com/gregtechceu/gtceu/common/machine/multiblock/part/PumpHatchPartMachine.java b/src/main/java/com/gregtechceu/gtceu/common/machine/multiblock/part/PumpHatchPartMachine.java
index 7ff7f6a2628..2d1ca82fe38 100644
--- a/src/main/java/com/gregtechceu/gtceu/common/machine/multiblock/part/PumpHatchPartMachine.java
+++ b/src/main/java/com/gregtechceu/gtceu/common/machine/multiblock/part/PumpHatchPartMachine.java
@@ -2,19 +2,10 @@
 
 import com.gregtechceu.gtceu.api.blockentity.BlockEntityCreationInfo;
 import com.gregtechceu.gtceu.api.capability.recipe.IO;
-import com.gregtechceu.gtceu.api.gui.GuiTextures;
-import com.gregtechceu.gtceu.api.gui.UITemplate;
-import com.gregtechceu.gtceu.api.gui.widget.TankWidget;
-import com.gregtechceu.gtceu.api.gui.widget.ToggleButtonWidget;
 import com.gregtechceu.gtceu.api.machine.trait.NotifiableFluidTank;
 import com.gregtechceu.gtceu.common.data.GTMaterials;
 
-import com.lowdragmc.lowdraglib.gui.modular.ModularUI;
-import com.lowdragmc.lowdraglib.gui.widget.ImageWidget;
-import com.lowdragmc.lowdraglib.gui.widget.LabelWidget;
-
 import net.minecraft.MethodsReturnNonnullByDefault;
-import net.minecraft.world.entity.player.Player;
 import net.minecraftforge.fluids.FluidType;
 
 import javax.annotation.ParametersAreNonnullByDefault;
@@ -33,23 +24,25 @@ protected NotifiableFluidTank createTank(int initialCapacity, int slots) {
                 .setFilter(fluidStack -> fluidStack.getFluid().is(GTMaterials.Water.getFluidTag()));
     }
 
-    @Override
-    public ModularUI createUI(Player entityPlayer) {
-        return new ModularUI(176, 166, this, entityPlayer)
-                .background(GuiTextures.BACKGROUND)
-                .widget(new ImageWidget(7, 16, 81, 55, GuiTextures.DISPLAY))
-                .widget(new LabelWidget(11, 20, "gtceu.gui.fluid_amount"))
-                .widget(new LabelWidget(11, 30, () -> String.valueOf(tank.getFluidInTank(0).getAmount()))
-                        .setTextColor(-1).setDropShadow(true))
-                .widget(new LabelWidget(6, 6, getBlockState().getBlock().getDescriptionId()))
-                .widget(new TankWidget(tank.getStorages()[0], 90, 35, true, io.support(IO.IN))
-                        .setBackground(GuiTextures.FLUID_SLOT))
-                .widget(new ToggleButtonWidget(7, 53, 18, 18,
-                        GuiTextures.BUTTON_FLUID_OUTPUT, this::isWorkingEnabled, this::setWorkingEnabled)
-                        .setShouldUseBaseBackground()
-                        .setTooltipText("gtceu.gui.fluid_auto_input.tooltip"))
-                .widget(UITemplate.bindPlayerInventory(entityPlayer.getInventory(), GuiTextures.SLOT, 7, 84, true));
-    }
+    /*
+     * @Override
+     * public ModularUI createUI(Player entityPlayer) {
+     * return new ModularUI(176, 166, this, entityPlayer)
+     * .background(GuiTextures.BACKGROUND)
+     * .widget(new ImageWidget(7, 16, 81, 55, GuiTextures.DISPLAY))
+     * .widget(new LabelWidget(11, 20, "gtceu.gui.fluid_amount"))
+     * .widget(new LabelWidget(11, 30, () -> String.valueOf(tank.getFluidInTank(0).getAmount()))
+     * .setTextColor(-1).setDropShadow(true))
+     * .widget(new LabelWidget(6, 6, getBlockState().getBlock().getDescriptionId()))
+     * .widget(new TankWidget(tank.getStorages()[0], 90, 35, true, io.support(IO.IN))
+     * .setBackground(GuiTextures.FLUID_SLOT))
+     * .widget(new ToggleButtonWidget(7, 53, 18, 18,
+     * GuiTextures.BUTTON_FLUID_OUTPUT, this::isWorkingEnabled, this::setWorkingEnabled)
+     * .setShouldUseBaseBackground()
+     * .setTooltipText("gtceu.gui.fluid_auto_input.tooltip"))
+     * .widget(UITemplate.bindPlayerInventory(entityPlayer.getInventory(), GuiTextures.SLOT, 7, 84, true));
+     * }
+     */
 
     // By returning false here, we don't allow shift-clicking
     // with a screwdriver to swap the IO.
diff --git a/src/main/java/com/gregtechceu/gtceu/common/machine/multiblock/part/RotorHolderPartMachine.java b/src/main/java/com/gregtechceu/gtceu/common/machine/multiblock/part/RotorHolderPartMachine.java
index da988458a43..a670445fbcc 100644
--- a/src/main/java/com/gregtechceu/gtceu/common/machine/multiblock/part/RotorHolderPartMachine.java
+++ b/src/main/java/com/gregtechceu/gtceu/common/machine/multiblock/part/RotorHolderPartMachine.java
@@ -4,13 +4,9 @@
 import com.gregtechceu.gtceu.api.capability.recipe.IO;
 import com.gregtechceu.gtceu.api.data.chemical.material.Material;
 import com.gregtechceu.gtceu.api.data.chemical.material.properties.PropertyKey;
-import com.gregtechceu.gtceu.api.gui.GuiTextures;
-import com.gregtechceu.gtceu.api.gui.fancy.TooltipsPanel;
-import com.gregtechceu.gtceu.api.gui.widget.BlockableSlotWidget;
 import com.gregtechceu.gtceu.api.machine.TickableSubscription;
 import com.gregtechceu.gtceu.api.machine.feature.ITieredMachine;
 import com.gregtechceu.gtceu.api.machine.feature.multiblock.*;
-import com.gregtechceu.gtceu.api.machine.multiblock.MultiblockControllerMachine;
 import com.gregtechceu.gtceu.api.machine.multiblock.part.TieredPartMachine;
 import com.gregtechceu.gtceu.api.machine.trait.NotifiableItemStackHandler;
 import com.gregtechceu.gtceu.api.pattern.util.RelativeDirection;
@@ -20,25 +16,26 @@
 import com.gregtechceu.gtceu.common.data.GTDamageTypes;
 import com.gregtechceu.gtceu.common.data.GTMaterials;
 import com.gregtechceu.gtceu.common.item.behavior.TurbineRotorBehaviour;
+import com.gregtechceu.gtceu.common.mui.GTGuiTextures;
 import com.gregtechceu.gtceu.utils.ExtendedUseOnContext;
 import com.gregtechceu.gtceu.utils.ISubscription;
 
-import com.lowdragmc.lowdraglib.gui.widget.Widget;
-import com.lowdragmc.lowdraglib.gui.widget.WidgetGroup;
-
-import net.minecraft.ChatFormatting;
 import net.minecraft.MethodsReturnNonnullByDefault;
 import net.minecraft.core.Direction;
-import net.minecraft.network.chat.Component;
-import net.minecraft.network.chat.Style;
 import net.minecraft.world.InteractionResult;
 import net.minecraft.world.item.ItemStack;
 
+import brachy.modularui.factory.PosGuiData;
+import brachy.modularui.screen.UISettings;
+import brachy.modularui.value.sync.IntSyncValue;
+import brachy.modularui.value.sync.PanelSyncManager;
+import brachy.modularui.widget.ParentWidget;
+import brachy.modularui.widgets.slot.ItemSlot;
+import brachy.modularui.widgets.slot.ModularSlot;
+import brachy.modularui.widgets.slot.SlotGroup;
 import lombok.Getter;
 import org.jetbrains.annotations.Nullable;
 
-import java.util.List;
-
 import javax.annotation.ParametersAreNonnullByDefault;
 
 import static com.gregtechceu.gtceu.api.machine.property.GTMachineModelProperties.*;
@@ -229,16 +226,23 @@ public InteractionResult onUse(ExtendedUseOnContext context) {
     //////////////////////////////////////
     // ********** GUI ***********//
     //////////////////////////////////////
+
+    // TODO MUI: Might need EIO widget? Not sure
     @Override
-    public Widget createUIWidget() {
-        var group = new WidgetGroup(0, 0, 18 + 16, 18 + 16);
-        var container = new WidgetGroup(4, 4, 18 + 8, 18 + 8);
-        container.addWidget(new BlockableSlotWidget(inventory.storage, 0, 4, 4)
-                .setIsBlocked(() -> rotorSpeed != 0)
-                .setBackground(GuiTextures.SLOT, GuiTextures.TURBINE_OVERLAY));
-        container.setBackground(GuiTextures.BACKGROUND_INVERSE);
-        group.addWidget(container);
-        return group;
+    public void buildMainUI(ParentWidget<?> mainWidget, PosGuiData guiData, PanelSyncManager syncManager,
+                            UISettings settings) {
+        var slot = new ItemSlot()
+                .slot(new ModularSlot(inventory, 0).slotGroup(new SlotGroup("rotor", 1)))
+                .background(GTGuiTextures.SLOT, GTGuiTextures.TURBINE_OVERLAY).center();
+
+        var rotorSync = new IntSyncValue(this::getRotorSpeed);
+        rotorSync.setChangeListener(() -> {
+            boolean canEdit = rotorSync.getIntValue() == 0;
+            slot.getSlot().accessibility(canEdit, canEdit);
+        });
+        syncManager.syncValue("rotor_speed", rotorSync);
+
+        mainWidget.child(slot);
     }
 
     //////////////////////////////////////
@@ -252,24 +256,6 @@ public Widget createUIWidget() {
         return super.modifyRecipe(recipe);
     }
 
-    //////////////////////////////////////
-    // ******* FANCY GUI ********//
-    //////////////////////////////////////
-    @Override
-    public void attachFancyTooltipsToController(MultiblockControllerMachine controller, TooltipsPanel tooltipsPanel) {
-        attachTooltips(tooltipsPanel);
-    }
-
-    @Override
-    public void attachTooltips(TooltipsPanel tooltipsPanel) {
-        tooltipsPanel.attachTooltips(new Basic(
-                () -> GuiTextures.INDICATOR_NO_STEAM.get(false),
-                () -> List.of(Component.translatable("gtceu.multiblock.universal.rotor_obstructed")
-                        .setStyle(Style.EMPTY.withColor(ChatFormatting.RED))),
-                () -> !isFrontFaceFree(),
-                () -> null));
-    }
-
     /**
      *
      * @return the total power boost to output and consumption the rotor holder and rotor provide in %
diff --git a/src/main/java/com/gregtechceu/gtceu/common/machine/multiblock/part/SteamHatchPartMachine.java b/src/main/java/com/gregtechceu/gtceu/common/machine/multiblock/part/SteamHatchPartMachine.java
index c7709eb8edf..ed684a53e79 100644
--- a/src/main/java/com/gregtechceu/gtceu/common/machine/multiblock/part/SteamHatchPartMachine.java
+++ b/src/main/java/com/gregtechceu/gtceu/common/machine/multiblock/part/SteamHatchPartMachine.java
@@ -2,19 +2,11 @@
 
 import com.gregtechceu.gtceu.api.blockentity.BlockEntityCreationInfo;
 import com.gregtechceu.gtceu.api.capability.recipe.IO;
-import com.gregtechceu.gtceu.api.gui.GuiTextures;
-import com.gregtechceu.gtceu.api.gui.UITemplate;
-import com.gregtechceu.gtceu.api.gui.widget.TankWidget;
 import com.gregtechceu.gtceu.api.machine.trait.NotifiableFluidTank;
 import com.gregtechceu.gtceu.common.data.GTMaterials;
 import com.gregtechceu.gtceu.config.ConfigHolder;
 
-import com.lowdragmc.lowdraglib.gui.modular.ModularUI;
-import com.lowdragmc.lowdraglib.gui.widget.ImageWidget;
-import com.lowdragmc.lowdraglib.gui.widget.LabelWidget;
-
 import net.minecraft.MethodsReturnNonnullByDefault;
-import net.minecraft.world.entity.player.Player;
 import net.minecraftforge.fluids.FluidType;
 
 import javax.annotation.ParametersAreNonnullByDefault;
@@ -36,20 +28,22 @@ protected NotifiableFluidTank createTank(int initialCapacity, int slots) {
                 .setFilter(fluidStack -> fluidStack.getFluid().is(GTMaterials.Steam.getFluidTag()));
     }
 
-    @Override
-    public ModularUI createUI(Player entityPlayer) {
-        return new ModularUI(176, 166, this, entityPlayer)
-                .background(GuiTextures.BACKGROUND_STEAM.get(IS_STEEL))
-                .widget(new ImageWidget(7, 16, 81, 55, GuiTextures.DISPLAY_STEAM.get(IS_STEEL)))
-                .widget(new LabelWidget(11, 20, "gtceu.gui.fluid_amount"))
-                .widget(new LabelWidget(11, 30, () -> tank.getFluidInTank(0).getAmount() + "").setTextColor(-1)
-                        .setDropShadow(true))
-                .widget(new LabelWidget(6, 6, getBlockState().getBlock().getDescriptionId()))
-                .widget(new TankWidget(tank.getStorages()[0], 90, 35, true, true)
-                        .setBackground(GuiTextures.FLUID_SLOT))
-                .widget(UITemplate.bindPlayerInventory(entityPlayer.getInventory(),
-                        GuiTextures.SLOT_STEAM.get(IS_STEEL), 7, 84, true));
-    }
+    /*
+     * @Override
+     * public ModularUI createUI(Player entityPlayer) {
+     * return new ModularUI(176, 166, this, entityPlayer)
+     * .background(GuiTextures.BACKGROUND_STEAM.get(IS_STEEL))
+     * .widget(new ImageWidget(7, 16, 81, 55, GuiTextures.DISPLAY_STEAM.get(IS_STEEL)))
+     * .widget(new LabelWidget(11, 20, "gtceu.gui.fluid_amount"))
+     * .widget(new LabelWidget(11, 30, () -> tank.getFluidInTank(0).getAmount() + "").setTextColor(-1)
+     * .setDropShadow(true))
+     * .widget(new LabelWidget(6, 6, getBlockState().getBlock().getDescriptionId()))
+     * .widget(new TankWidget(tank.getStorages()[0], 90, 35, true, true)
+     * .setBackground(GuiTextures.FLUID_SLOT))
+     * .widget(UITemplate.bindPlayerInventory(entityPlayer.getInventory(),
+     * GuiTextures.SLOT_STEAM.get(IS_STEEL), 7, 84, true));
+     * }
+     */
 
     // By returning false here, we don't allow shift-clicking
     // with a screwdriver to swap the IO, since this is a
@@ -59,4 +53,9 @@ public ModularUI createUI(Player entityPlayer) {
     public boolean swapIO() {
         return false;
     }
+
+    @Override
+    public boolean isCircuitSlotEnabled() {
+        return false;
+    }
 }
diff --git a/src/main/java/com/gregtechceu/gtceu/common/machine/multiblock/part/SteamItemBusPartMachine.java b/src/main/java/com/gregtechceu/gtceu/common/machine/multiblock/part/SteamItemBusPartMachine.java
index cd7cb1695a2..b0babdf61d0 100644
--- a/src/main/java/com/gregtechceu/gtceu/common/machine/multiblock/part/SteamItemBusPartMachine.java
+++ b/src/main/java/com/gregtechceu/gtceu/common/machine/multiblock/part/SteamItemBusPartMachine.java
@@ -2,23 +2,12 @@
 
 import com.gregtechceu.gtceu.api.blockentity.BlockEntityCreationInfo;
 import com.gregtechceu.gtceu.api.capability.recipe.IO;
-import com.gregtechceu.gtceu.api.gui.GuiTextures;
-import com.gregtechceu.gtceu.api.gui.UITemplate;
-import com.gregtechceu.gtceu.api.gui.widget.SlotWidget;
-import com.gregtechceu.gtceu.api.gui.widget.ToggleButtonWidget;
 import com.gregtechceu.gtceu.api.machine.MachineDefinition;
 import com.gregtechceu.gtceu.common.data.GTMachines;
-import com.gregtechceu.gtceu.config.ConfigHolder;
-
-import com.lowdragmc.lowdraglib.gui.modular.ModularUI;
-import com.lowdragmc.lowdraglib.gui.widget.LabelWidget;
 
 import net.minecraft.core.BlockPos;
-import net.minecraft.world.entity.player.Player;
 import net.minecraft.world.level.block.state.BlockState;
 
-import org.jetbrains.annotations.NotNull;
-
 public class SteamItemBusPartMachine extends ItemBusPartMachine {
 
     private final String autoTooltipKey;
@@ -28,36 +17,6 @@ public SteamItemBusPartMachine(BlockEntityCreationInfo info, IO io) {
         autoTooltipKey = io == IO.IN ? "gtceu.gui.item_auto_input.tooltip" : "gtceu.gui.item_auto_output.tooltip";
     }
 
-    @NotNull
-    @Override
-    public ModularUI createUI(@NotNull Player entityPlayer) {
-        int rowSize = (int) Math.sqrt(getInventorySize());
-        int xOffset = rowSize == 10 ? 9 : 0;
-        var modular = new ModularUI(176 + xOffset * 2,
-                18 + 18 * rowSize + 105, this, entityPlayer)
-                .background(GuiTextures.BACKGROUND_STEAM.get(ConfigHolder.INSTANCE.machines.steelSteamMultiblocks))
-                .widget(new LabelWidget(10, 5, getBlockState().getBlock().getDescriptionId()))
-                .widget(new ToggleButtonWidget(7 + xOffset, 18 + 18 * rowSize, 18, 18,
-                        GuiTextures.BUTTON_ITEM_OUTPUT, this::isWorkingEnabled, this::setWorkingEnabled)
-                        .setShouldUseBaseBackground() // TODO: Steamify background
-                        .setTooltipText(autoTooltipKey))
-                .widget(UITemplate.bindPlayerInventory(entityPlayer.getInventory(),
-                        GuiTextures.SLOT_STEAM.get(ConfigHolder.INSTANCE.machines.steelSteamMultiblocks),
-                        7 + xOffset, 18 + 18 * rowSize + 24, true));
-
-        for (int y = 0; y < rowSize; y++) {
-            for (int x = 0; x < rowSize; x++) {
-                int index = y * rowSize + x;
-                modular.widget(new SlotWidget(getInventory().storage, index,
-                        (88 - rowSize * 9 + x * 18) + xOffset, 18 + y * 18 + 6, true, io.support(IO.IN))
-                        .setBackgroundTexture(
-                                GuiTextures.SLOT_STEAM.get(ConfigHolder.INSTANCE.machines.steelSteamMultiblocks)));
-            }
-        }
-
-        return modular;
-    }
-
     @Override
     public boolean swapIO() {
         BlockPos blockPos = getBlockPos();
@@ -83,4 +42,9 @@ public boolean swapIO() {
         }
         return true;
     }
+
+    @Override
+    public boolean isCircuitSlotEnabled() {
+        return false;
+    }
 }
diff --git a/src/main/java/com/gregtechceu/gtceu/common/machine/multiblock/part/hpca/HPCABridgePartMachine.java b/src/main/java/com/gregtechceu/gtceu/common/machine/multiblock/part/hpca/HPCABridgePartMachine.java
index 22938b0dbc4..0faf181fb67 100644
--- a/src/main/java/com/gregtechceu/gtceu/common/machine/multiblock/part/hpca/HPCABridgePartMachine.java
+++ b/src/main/java/com/gregtechceu/gtceu/common/machine/multiblock/part/hpca/HPCABridgePartMachine.java
@@ -2,13 +2,13 @@
 
 import com.gregtechceu.gtceu.api.GTValues;
 import com.gregtechceu.gtceu.api.blockentity.BlockEntityCreationInfo;
-import com.gregtechceu.gtceu.api.gui.GuiTextures;
 import com.gregtechceu.gtceu.common.machine.trait.hpca.HPCAComponentTrait;
-
-import com.lowdragmc.lowdraglib.gui.texture.ResourceTexture;
+import com.gregtechceu.gtceu.common.mui.GTGuiTextures;
 
 import net.minecraft.MethodsReturnNonnullByDefault;
 
+import brachy.modularui.api.drawable.IDrawable;
+
 import javax.annotation.ParametersAreNonnullByDefault;
 
 @MethodsReturnNonnullByDefault
@@ -25,7 +25,7 @@ public boolean isAdvanced() {
     }
 
     @Override
-    public ResourceTexture getComponentIcon() {
-        return GuiTextures.HPCA_ICON_BRIDGE_COMPONENT;
+    public IDrawable getComponentIcon() {
+        return GTGuiTextures.HPCA_BRIDGE_COMPONENT;
     }
 }
diff --git a/src/main/java/com/gregtechceu/gtceu/common/machine/multiblock/part/hpca/HPCAComponentPartMachine.java b/src/main/java/com/gregtechceu/gtceu/common/machine/multiblock/part/hpca/HPCAComponentPartMachine.java
index 12efa4a0be8..d2fcb1dac1b 100644
--- a/src/main/java/com/gregtechceu/gtceu/common/machine/multiblock/part/hpca/HPCAComponentPartMachine.java
+++ b/src/main/java/com/gregtechceu/gtceu/common/machine/multiblock/part/hpca/HPCAComponentPartMachine.java
@@ -5,14 +5,13 @@
 import com.gregtechceu.gtceu.common.data.GTBlocks;
 import com.gregtechceu.gtceu.common.machine.trait.hpca.HPCAComponentTrait;
 
-import com.lowdragmc.lowdraglib.gui.texture.ResourceTexture;
-
 import net.minecraft.MethodsReturnNonnullByDefault;
 import net.minecraft.world.InteractionHand;
 import net.minecraft.world.entity.player.Player;
 import net.minecraft.world.item.ItemStack;
 import net.minecraft.world.phys.BlockHitResult;
 
+import brachy.modularui.api.drawable.IDrawable;
 import lombok.Getter;
 
 import java.util.List;
@@ -34,7 +33,7 @@ public HPCAComponentPartMachine(BlockEntityCreationInfo info,
 
     public abstract boolean isAdvanced();
 
-    public abstract ResourceTexture getComponentIcon();
+    public abstract IDrawable getComponentIcon();
 
     @Override
     public boolean shouldOpenUI(Player player, InteractionHand hand, BlockHitResult hit) {
diff --git a/src/main/java/com/gregtechceu/gtceu/common/machine/multiblock/part/hpca/HPCAComputationPartMachine.java b/src/main/java/com/gregtechceu/gtceu/common/machine/multiblock/part/hpca/HPCAComputationPartMachine.java
index ae5f5a9e202..c4c12d679e3 100644
--- a/src/main/java/com/gregtechceu/gtceu/common/machine/multiblock/part/hpca/HPCAComputationPartMachine.java
+++ b/src/main/java/com/gregtechceu/gtceu/common/machine/multiblock/part/hpca/HPCAComputationPartMachine.java
@@ -2,14 +2,13 @@
 
 import com.gregtechceu.gtceu.api.GTValues;
 import com.gregtechceu.gtceu.api.blockentity.BlockEntityCreationInfo;
-import com.gregtechceu.gtceu.api.gui.GuiTextures;
 import com.gregtechceu.gtceu.common.machine.trait.hpca.HPCAComponentTrait;
 import com.gregtechceu.gtceu.common.machine.trait.hpca.HPCAComputationProviderTrait;
-
-import com.lowdragmc.lowdraglib.gui.texture.ResourceTexture;
+import com.gregtechceu.gtceu.common.mui.GTGuiTextures;
 
 import net.minecraft.MethodsReturnNonnullByDefault;
 
+import brachy.modularui.api.drawable.IDrawable;
 import lombok.Getter;
 
 import javax.annotation.ParametersAreNonnullByDefault;
@@ -35,12 +34,12 @@ public static HPCAComponentTrait createHPCATrait(boolean isAdvanced) {
     }
 
     @Override
-    public ResourceTexture getComponentIcon() {
+    public IDrawable getComponentIcon() {
         if (hpcaComponentTrait.isDamaged()) {
-            return advanced ? GuiTextures.HPCA_ICON_DAMAGED_ADVANCED_COMPUTATION_COMPONENT :
-                    GuiTextures.HPCA_ICON_DAMAGED_COMPUTATION_COMPONENT;
+            return advanced ? GTGuiTextures.HPCA_DAMAGED_ADVANCED_COMPUTATION_COMPONENT :
+                    GTGuiTextures.HPCA_DAMAGED_COMPUTATION_COMPONENT;
         }
-        return advanced ? GuiTextures.HPCA_ICON_ADVANCED_COMPUTATION_COMPONENT :
-                GuiTextures.HPCA_ICON_COMPUTATION_COMPONENT;
+        return advanced ? GTGuiTextures.HPCA_ADVANCED_COMPUTATION_COMPONENT :
+                GTGuiTextures.HPCA_COMPUTATION_COMPONENT;
     }
 }
diff --git a/src/main/java/com/gregtechceu/gtceu/common/machine/multiblock/part/hpca/HPCACoolerPartMachine.java b/src/main/java/com/gregtechceu/gtceu/common/machine/multiblock/part/hpca/HPCACoolerPartMachine.java
index e81c2a237e2..87bd24e861f 100644
--- a/src/main/java/com/gregtechceu/gtceu/common/machine/multiblock/part/hpca/HPCACoolerPartMachine.java
+++ b/src/main/java/com/gregtechceu/gtceu/common/machine/multiblock/part/hpca/HPCACoolerPartMachine.java
@@ -2,14 +2,13 @@
 
 import com.gregtechceu.gtceu.api.GTValues;
 import com.gregtechceu.gtceu.api.blockentity.BlockEntityCreationInfo;
-import com.gregtechceu.gtceu.api.gui.GuiTextures;
 import com.gregtechceu.gtceu.common.machine.trait.hpca.HPCAComponentTrait;
 import com.gregtechceu.gtceu.common.machine.trait.hpca.HPCACoolantProviderTrait;
-
-import com.lowdragmc.lowdraglib.gui.texture.ResourceTexture;
+import com.gregtechceu.gtceu.common.mui.GTGuiTextures;
 
 import net.minecraft.MethodsReturnNonnullByDefault;
 
+import brachy.modularui.api.drawable.IDrawable;
 import lombok.Getter;
 
 import javax.annotation.ParametersAreNonnullByDefault;
@@ -35,7 +34,7 @@ public static HPCAComponentTrait createHPCATrait(boolean isAdvanced) {
     }
 
     @Override
-    public ResourceTexture getComponentIcon() {
-        return advanced ? GuiTextures.HPCA_ICON_ACTIVE_COOLER_COMPONENT : GuiTextures.HPCA_ICON_HEAT_SINK_COMPONENT;
+    public IDrawable getComponentIcon() {
+        return advanced ? GTGuiTextures.HPCA_ACTIVE_COOLER_COMPONENT : GTGuiTextures.HPCA_HEAT_SINK_COMPONENT;
     }
 }
diff --git a/src/main/java/com/gregtechceu/gtceu/common/machine/multiblock/part/hpca/HPCAEmptyPartMachine.java b/src/main/java/com/gregtechceu/gtceu/common/machine/multiblock/part/hpca/HPCAEmptyPartMachine.java
index 198abb9d778..543fa4a166b 100644
--- a/src/main/java/com/gregtechceu/gtceu/common/machine/multiblock/part/hpca/HPCAEmptyPartMachine.java
+++ b/src/main/java/com/gregtechceu/gtceu/common/machine/multiblock/part/hpca/HPCAEmptyPartMachine.java
@@ -1,13 +1,13 @@
 package com.gregtechceu.gtceu.common.machine.multiblock.part.hpca;
 
 import com.gregtechceu.gtceu.api.blockentity.BlockEntityCreationInfo;
-import com.gregtechceu.gtceu.api.gui.GuiTextures;
 import com.gregtechceu.gtceu.common.machine.trait.hpca.HPCAComponentTrait;
-
-import com.lowdragmc.lowdraglib.gui.texture.ResourceTexture;
+import com.gregtechceu.gtceu.common.mui.GTGuiTextures;
 
 import net.minecraft.MethodsReturnNonnullByDefault;
 
+import brachy.modularui.api.drawable.IDrawable;
+
 import javax.annotation.ParametersAreNonnullByDefault;
 
 @MethodsReturnNonnullByDefault
@@ -24,7 +24,7 @@ public boolean isAdvanced() {
     }
 
     @Override
-    public ResourceTexture getComponentIcon() {
-        return GuiTextures.HPCA_ICON_EMPTY_COMPONENT;
+    public IDrawable getComponentIcon() {
+        return GTGuiTextures.HPCA_EMPTY_COMPONENT;
     }
 }
diff --git a/src/main/java/com/gregtechceu/gtceu/common/machine/multiblock/part/monitor/AdvancedMonitorPartMachine.java b/src/main/java/com/gregtechceu/gtceu/common/machine/multiblock/part/monitor/AdvancedMonitorPartMachine.java
index f7043125950..0a14d74bfc4 100644
--- a/src/main/java/com/gregtechceu/gtceu/common/machine/multiblock/part/monitor/AdvancedMonitorPartMachine.java
+++ b/src/main/java/com/gregtechceu/gtceu/common/machine/multiblock/part/monitor/AdvancedMonitorPartMachine.java
@@ -2,16 +2,16 @@
 
 import com.gregtechceu.gtceu.api.blockentity.BlockEntityCreationInfo;
 import com.gregtechceu.gtceu.api.machine.TickableSubscription;
-import com.gregtechceu.gtceu.api.pattern.util.RelativeDirection;
 import com.gregtechceu.gtceu.api.sync_system.annotations.SaveField;
 import com.gregtechceu.gtceu.utils.ExtendedUseOnContext;
 
 import net.minecraft.MethodsReturnNonnullByDefault;
-import net.minecraft.core.Direction;
 import net.minecraft.world.InteractionResult;
 
 import lombok.Getter;
+import lombok.Setter;
 import org.jetbrains.annotations.Nullable;
+import org.joml.Vector2d;
 
 import javax.annotation.ParametersAreNonnullByDefault;
 
@@ -31,6 +31,10 @@ public class AdvancedMonitorPartMachine extends MonitorPartMachine {
     @SaveField
     private boolean resetClickedNextTick = false;
 
+    @Getter
+    @Setter
+    private boolean clickedThisFrame = false;
+
     @Nullable
     private TickableSubscription clickResetSubscription;
 
@@ -43,14 +47,10 @@ public InteractionResult onUse(ExtendedUseOnContext context) {
         if (context.getClickedFace() != getFrontFacing()) return super.onUse(context);
         var hitLocation = context.getHitResult().getLocation();
         clicked = true;
-        clickPosX = hitLocation
-                .get(RelativeDirection.RIGHT.getRelative(getFrontFacing(), getUpwardsFacing(), false).getAxis());
-        clickPosY = hitLocation
-                .get(getFrontFacing().getAxis().isVertical() ? Direction.Axis.X : Direction.Axis.Y);
-        clickPosX -= Math.floor(clickPosX);
-        if (clickPosX < 0) clickPosX++;
-        clickPosY -= Math.floor(clickPosY);
-        if (clickPosY < 0) clickPosY++;
+        clickedThisFrame = true;
+        Vector2d clickPos = getMousePos(context.getHitResult());
+        clickPosX = clickPos.x();
+        clickPosY = clickPos.y();
         return InteractionResult.SUCCESS;
     }
 
diff --git a/src/main/java/com/gregtechceu/gtceu/common/machine/multiblock/part/monitor/MonitorPartMachine.java b/src/main/java/com/gregtechceu/gtceu/common/machine/multiblock/part/monitor/MonitorPartMachine.java
index 6053638864f..50d7e03a399 100644
--- a/src/main/java/com/gregtechceu/gtceu/common/machine/multiblock/part/monitor/MonitorPartMachine.java
+++ b/src/main/java/com/gregtechceu/gtceu/common/machine/multiblock/part/monitor/MonitorPartMachine.java
@@ -1,14 +1,17 @@
 package com.gregtechceu.gtceu.common.machine.multiblock.part.monitor;
 
-import com.gregtechceu.gtceu.GTCEu;
 import com.gregtechceu.gtceu.api.blockentity.BlockEntityCreationInfo;
+import com.gregtechceu.gtceu.api.pattern.util.RelativeDirection;
+import com.gregtechceu.gtceu.common.mui.GTGuiTextures;
 
-import com.lowdragmc.lowdraglib.gui.texture.IGuiTexture;
-import com.lowdragmc.lowdraglib.gui.texture.ResourceTexture;
-
+import net.minecraft.core.Direction;
 import net.minecraft.world.InteractionHand;
 import net.minecraft.world.entity.player.Player;
 import net.minecraft.world.phys.BlockHitResult;
+import net.minecraft.world.phys.HitResult;
+
+import brachy.modularui.api.drawable.IDrawable;
+import org.joml.Vector2d;
 
 public class MonitorPartMachine extends MonitorComponentPartMachine {
 
@@ -22,12 +25,29 @@ public boolean isMonitor() {
     }
 
     @Override
-    public IGuiTexture getComponentIcon() {
-        return ResourceTexture.fromSpirit(GTCEu.id("item/computer_monitor_cover"));
+    public IDrawable getIcon() {
+        return GTGuiTextures.MONITOR;
     }
 
     @Override
     public boolean shouldOpenUI(Player player, InteractionHand hand, BlockHitResult hit) {
         return false;
     }
+
+    public Vector2d getMousePos(HitResult hitResult) {
+        if (hitResult instanceof BlockHitResult hit) {
+            Direction direction = RelativeDirection.RIGHT.getRelative(getFrontFacing(), getUpwardsFacing(), false);
+            double x = hit.getLocation().get(direction.getAxis());
+            if (direction.getAxisDirection().getStep() == 1) {
+                x = 1 - x;
+            }
+            double y = hit.getLocation()
+                    .get(getFrontFacing().getAxis().isVertical() ? Direction.Axis.X : Direction.Axis.Y);
+            x -= Math.floor(x);
+            if (x < 0) x++;
+            y -= Math.floor(y);
+            if (y < 0) y++;
+            return new Vector2d(x, y);
+        } else return new Vector2d();
+    }
 }
diff --git a/src/main/java/com/gregtechceu/gtceu/common/machine/multiblock/primitive/CokeOvenMachine.java b/src/main/java/com/gregtechceu/gtceu/common/machine/multiblock/primitive/CokeOvenMachine.java
index f0e15368744..32e1a8b0429 100644
--- a/src/main/java/com/gregtechceu/gtceu/common/machine/multiblock/primitive/CokeOvenMachine.java
+++ b/src/main/java/com/gregtechceu/gtceu/common/machine/multiblock/primitive/CokeOvenMachine.java
@@ -2,20 +2,12 @@
 
 import com.gregtechceu.gtceu.api.GTValues;
 import com.gregtechceu.gtceu.api.blockentity.BlockEntityCreationInfo;
-import com.gregtechceu.gtceu.api.gui.GuiTextures;
-import com.gregtechceu.gtceu.api.gui.UITemplate;
-import com.gregtechceu.gtceu.api.gui.widget.SlotWidget;
-import com.gregtechceu.gtceu.api.gui.widget.TankWidget;
-import com.gregtechceu.gtceu.api.machine.feature.IUIMachine;
+import com.gregtechceu.gtceu.api.machine.feature.IMuiMachine;
+import com.gregtechceu.gtceu.api.machine.mui.MachineUIPanelBuilder;
+import com.gregtechceu.gtceu.common.mui.GTGuiTextures;
 import com.gregtechceu.gtceu.config.ConfigHolder;
 import com.gregtechceu.gtceu.utils.ExtendedUseOnContext;
 
-import com.lowdragmc.lowdraglib.gui.modular.ModularUI;
-import com.lowdragmc.lowdraglib.gui.texture.GuiTextureGroup;
-import com.lowdragmc.lowdraglib.gui.texture.ProgressTexture;
-import com.lowdragmc.lowdraglib.gui.widget.LabelWidget;
-import com.lowdragmc.lowdraglib.gui.widget.ProgressWidget;
-
 import net.minecraft.MethodsReturnNonnullByDefault;
 import net.minecraft.core.BlockPos;
 import net.minecraft.core.Direction;
@@ -24,39 +16,79 @@
 import net.minecraft.sounds.SoundSource;
 import net.minecraft.util.RandomSource;
 import net.minecraft.world.InteractionResult;
-import net.minecraft.world.entity.player.Player;
 import net.minecraftforge.fluids.FluidUtil;
 
+import brachy.modularui.api.ITheme;
+import brachy.modularui.factory.PosGuiData;
+import brachy.modularui.screen.UISettings;
+import brachy.modularui.theme.ThemeAPI;
+import brachy.modularui.value.sync.DoubleSyncValue;
+import brachy.modularui.value.sync.FluidSlotSyncHandler;
+import brachy.modularui.value.sync.ItemSlotSyncHandler;
+import brachy.modularui.value.sync.PanelSyncManager;
+import brachy.modularui.widget.ParentWidget;
+import brachy.modularui.widgets.ProgressWidget;
+import brachy.modularui.widgets.layout.Flow;
+import brachy.modularui.widgets.slot.*;
+
 import javax.annotation.ParametersAreNonnullByDefault;
 
+import static com.gregtechceu.gtceu.common.mui.GTMuiWidgets.createTankWidget;
+
 @ParametersAreNonnullByDefault
 @MethodsReturnNonnullByDefault
-public class CokeOvenMachine extends PrimitiveWorkableMachine implements IUIMachine {
+public class CokeOvenMachine extends PrimitiveWorkableMachine implements IMuiMachine {
 
     public CokeOvenMachine(BlockEntityCreationInfo info) {
         super(info);
     }
 
     @Override
-    public ModularUI createUI(Player entityPlayer) {
-        return new ModularUI(176, 166, this, entityPlayer)
-                .background(GuiTextures.PRIMITIVE_BACKGROUND)
-                .widget(new LabelWidget(5, 5, getBlockState().getBlock().getDescriptionId()))
-                .widget(new SlotWidget(importItems.storage, 0, 52, 30, true, true)
-                        .setBackgroundTexture(
-                                new GuiTextureGroup(GuiTextures.PRIMITIVE_SLOT, GuiTextures.PRIMITIVE_FURNACE_OVERLAY)))
-                .widget(new ProgressWidget(recipeLogic::getProgressPercent, 76, 32, 20, 15,
-                        GuiTextures.PRIMITIVE_BLAST_FURNACE_PROGRESS_BAR))
-                .widget(new SlotWidget(exportItems.storage, 0, 103, 30, true, false)
-                        .setBackgroundTexture(
-                                new GuiTextureGroup(GuiTextures.PRIMITIVE_SLOT, GuiTextures.PRIMITIVE_FURNACE_OVERLAY)))
-                .widget(new TankWidget(exportFluids.getStorages()[0], 134, 13, 20, 58, true, false)
-                        .setBackground(GuiTextures.PRIMITIVE_LARGE_FLUID_TANK)
-                        .setFillDirection(ProgressTexture.FillDirection.DOWN_TO_UP)
-                        .setShowAmountOverlay(false)
-                        .setOverlay(GuiTextures.PRIMITIVE_LARGE_FLUID_TANK_OVERLAY))
-                .widget(UITemplate.bindPlayerInventory(entityPlayer.getInventory(), GuiTextures.PRIMITIVE_SLOT, 7, 84,
-                        true));
+    public MachineUIPanelBuilder getPanelBuilder(PosGuiData data, PanelSyncManager syncManager, UISettings settings) {
+        return MachineUIPanelBuilder.defaultPanelBuilder(this).addTraitConfigurators(false)
+                .addDefaultConfigurators(false);
+    }
+
+    @Override
+    public void buildMainUI(ParentWidget<?> mainWidget, PosGuiData guiData, PanelSyncManager syncManager,
+                            UISettings settings) {
+        ITheme uiTheme = ThemeAPI.INSTANCE.getTheme(getDefinition().getThemeId());
+
+        DoubleSyncValue progressPercent = syncManager.getOrCreateSyncHandler("progressPercent", DoubleSyncValue.class,
+                () -> new DoubleSyncValue(() -> {
+                    if (recipeLogic == null) return -1f;
+                    return recipeLogic.getProgressPercent();
+                }));
+
+        Flow row = Flow.row().coverChildren();
+
+        row.child(new ItemSlot().syncHandler(new ItemSlotSyncHandler(
+                new ModularSlot(importItems.storage, 0)
+                        .slotGroup(new SlotGroup("import_items", 1))))
+                .background(uiTheme.getItemSlotTheme().theme().getBackground(),
+                        GTGuiTextures.PRIMITIVE_FURNACE_OVERLAY))
+                .child(new ProgressWidget()
+                        .value(progressPercent)
+                        .size(20, 15)
+                        .texture(GTGuiTextures.PRIMITIVE_BLAST_FURNACE_PROGRESS_BAR, 18)
+                        .margin(4, 0))
+
+                .child(new ItemSlot().syncHandler(new ItemSlotSyncHandler(
+                        new ModularSlot(exportItems.storage, 0)
+                                .slotGroup(new SlotGroup("export_items", 1))
+                                .accessibility(false, true)))
+                        .background(uiTheme.getItemSlotTheme().theme().getBackground(),
+                                GTGuiTextures.PRIMITIVE_FURNACE_OVERLAY))
+
+                .child(createTankWidget()
+                        .overlay(GTGuiTextures.PRIMITIVE_LARGE_FLUID_TANK_OVERLAY)
+                        .background(GTGuiTextures.PRIMITIVE_LARGE_FLUID_TANK)
+                        .syncHandler(new FluidSlotSyncHandler(
+                                exportFluids.getStorages()[0])
+                                .canFillSlot(false))
+                        .marginLeft(20));
+
+        mainWidget.child(row.center());
     }
 
     @Override
diff --git a/src/main/java/com/gregtechceu/gtceu/common/machine/multiblock/primitive/PrimitiveBlastFurnaceMachine.java b/src/main/java/com/gregtechceu/gtceu/common/machine/multiblock/primitive/PrimitiveBlastFurnaceMachine.java
index b87e924fc7d..4a19cd40a88 100644
--- a/src/main/java/com/gregtechceu/gtceu/common/machine/multiblock/primitive/PrimitiveBlastFurnaceMachine.java
+++ b/src/main/java/com/gregtechceu/gtceu/common/machine/multiblock/primitive/PrimitiveBlastFurnaceMachine.java
@@ -4,25 +4,19 @@
 import com.gregtechceu.gtceu.api.blockentity.BlockEntityCreationInfo;
 import com.gregtechceu.gtceu.api.capability.recipe.IO;
 import com.gregtechceu.gtceu.api.capability.recipe.ItemRecipeCapability;
-import com.gregtechceu.gtceu.api.gui.GuiTextures;
-import com.gregtechceu.gtceu.api.gui.UITemplate;
-import com.gregtechceu.gtceu.api.gui.widget.SlotWidget;
 import com.gregtechceu.gtceu.api.machine.TickableSubscription;
-import com.gregtechceu.gtceu.api.machine.feature.IUIMachine;
+import com.gregtechceu.gtceu.api.machine.feature.IMuiMachine;
+import com.gregtechceu.gtceu.api.machine.mui.MachineUIPanelBuilder;
 import com.gregtechceu.gtceu.api.machine.trait.NotifiableItemStackHandler;
 import com.gregtechceu.gtceu.api.machine.trait.RecipeLogic;
 import com.gregtechceu.gtceu.api.pattern.util.RelativeDirection;
 import com.gregtechceu.gtceu.api.sync_system.annotations.RerenderOnChanged;
 import com.gregtechceu.gtceu.api.sync_system.annotations.SyncToClient;
 import com.gregtechceu.gtceu.common.machine.trait.multiblock.MultiblockFluidRendererTrait;
+import com.gregtechceu.gtceu.common.mui.GTGuiTextures;
 import com.gregtechceu.gtceu.config.ConfigHolder;
 import com.gregtechceu.gtceu.utils.GTUtil;
 
-import com.lowdragmc.lowdraglib.gui.modular.ModularUI;
-import com.lowdragmc.lowdraglib.gui.texture.GuiTextureGroup;
-import com.lowdragmc.lowdraglib.gui.widget.LabelWidget;
-import com.lowdragmc.lowdraglib.gui.widget.ProgressWidget;
-
 import net.minecraft.MethodsReturnNonnullByDefault;
 import net.minecraft.core.BlockPos;
 import net.minecraft.core.Direction;
@@ -30,14 +24,28 @@
 import net.minecraft.sounds.SoundEvents;
 import net.minecraft.sounds.SoundSource;
 import net.minecraft.util.RandomSource;
-import net.minecraft.world.entity.player.Player;
 import net.minecraft.world.level.block.state.BlockState;
 import net.minecraft.world.phys.AABB;
 import net.minecraftforge.api.distmarker.Dist;
 import net.minecraftforge.api.distmarker.OnlyIn;
 
+import brachy.modularui.api.ITheme;
+import brachy.modularui.factory.PosGuiData;
+import brachy.modularui.screen.UISettings;
+import brachy.modularui.theme.ThemeAPI;
+import brachy.modularui.value.sync.DoubleSyncValue;
+import brachy.modularui.value.sync.ItemSlotSyncHandler;
+import brachy.modularui.value.sync.PanelSyncManager;
+import brachy.modularui.widget.ParentWidget;
+import brachy.modularui.widgets.ProgressWidget;
+import brachy.modularui.widgets.SlotGroupWidget;
+import brachy.modularui.widgets.layout.Flow;
+import brachy.modularui.widgets.slot.ItemSlot;
+import brachy.modularui.widgets.slot.ModularSlot;
+import brachy.modularui.widgets.slot.SlotGroup;
 import lombok.Getter;
 
+import java.util.Arrays;
 import java.util.Collections;
 import java.util.Set;
 
@@ -46,7 +54,7 @@
 
 @ParametersAreNonnullByDefault
 @MethodsReturnNonnullByDefault
-public class PrimitiveBlastFurnaceMachine extends PrimitiveWorkableMachine implements IUIMachine {
+public class PrimitiveBlastFurnaceMachine extends PrimitiveWorkableMachine implements IMuiMachine {
 
     private @Nullable TickableSubscription hurtSubscription;
 
@@ -128,32 +136,77 @@ public void clientTick() {
     }
 
     @Override
-    public ModularUI createUI(Player entityPlayer) {
-        return new ModularUI(176, 166, this, entityPlayer)
-                .background(GuiTextures.PRIMITIVE_BACKGROUND)
-                .widget(new LabelWidget(5, 5, getBlockState().getBlock().getDescriptionId()))
-                .widget(new SlotWidget(importItems.storage, 0, 52, 20, true, true)
-                        .setBackgroundTexture(
-                                new GuiTextureGroup(GuiTextures.PRIMITIVE_SLOT, GuiTextures.PRIMITIVE_INGOT_OVERLAY)))
-                .widget(new SlotWidget(importItems.storage, 1, 52, 38, true, true)
-                        .setBackgroundTexture(
-                                new GuiTextureGroup(GuiTextures.PRIMITIVE_SLOT, GuiTextures.PRIMITIVE_DUST_OVERLAY)))
-                .widget(new SlotWidget(importItems.storage, 2, 52, 56, true, true)
-                        .setBackgroundTexture(
-                                new GuiTextureGroup(GuiTextures.PRIMITIVE_SLOT, GuiTextures.PRIMITIVE_FURNACE_OVERLAY)))
-                .widget(new ProgressWidget(recipeLogic::getProgressPercent, 77, 39, 20, 15,
-                        GuiTextures.PRIMITIVE_BLAST_FURNACE_PROGRESS_BAR))
-                .widget(new SlotWidget(exportItems.storage, 0, 104, 38, true, false)
-                        .setBackgroundTexture(
-                                new GuiTextureGroup(GuiTextures.PRIMITIVE_SLOT, GuiTextures.PRIMITIVE_INGOT_OVERLAY)))
-                .widget(new SlotWidget(exportItems.storage, 1, 122, 38, true, false)
-                        .setBackgroundTexture(
-                                new GuiTextureGroup(GuiTextures.PRIMITIVE_SLOT, GuiTextures.PRIMITIVE_DUST_OVERLAY)))
-                .widget(new SlotWidget(exportItems.storage, 2, 140, 38, true, false)
-                        .setBackgroundTexture(
-                                new GuiTextureGroup(GuiTextures.PRIMITIVE_SLOT, GuiTextures.PRIMITIVE_DUST_OVERLAY)))
-                .widget(UITemplate.bindPlayerInventory(entityPlayer.getInventory(),
-                        GuiTextures.PRIMITIVE_SLOT, 7, 84, true));
+    public MachineUIPanelBuilder getPanelBuilder(PosGuiData data, PanelSyncManager syncManager, UISettings settings) {
+        return MachineUIPanelBuilder.defaultPanelBuilder(this).addTraitConfigurators(false)
+                .addDefaultConfigurators(false);
+    }
+
+    @Override
+    public void buildMainUI(ParentWidget<?> mainWidget, PosGuiData guiData, PanelSyncManager syncManager,
+                            UISettings settings) {
+        ITheme theme = ThemeAPI.INSTANCE.getTheme(getDefinition().getThemeId());
+
+        DoubleSyncValue progressPercent = syncManager.getOrCreateSyncHandler("progressPercent", DoubleSyncValue.class,
+                () -> new DoubleSyncValue(() -> {
+                    if (recipeLogic == null) return -1f;
+                    return recipeLogic.getProgressPercent();
+                }));
+
+        var row = Flow.row().coverChildren().center();
+
+        row.child(createImportItemSlot(syncManager, theme))
+                .child(new ProgressWidget()
+                        .value(progressPercent)
+                        .size(20, 15)
+                        .texture(GTGuiTextures.PRIMITIVE_BLAST_FURNACE_PROGRESS_BAR, 0)
+                        .margin(5, 5, 0, 0))
+                .child(createExportItemSlot(syncManager, theme));
+
+        mainWidget.child(row);
+    }
+
+    private SlotGroupWidget createImportItemSlot(PanelSyncManager syncManager, ITheme theme) {
+        int size = importItems.storage.getSlots();
+        SlotGroup slotGroup = new SlotGroup("import", size);
+        String[] matrix = new String[size];
+        char key = 'I';
+        Arrays.fill(matrix, String.valueOf(key));
+        return SlotGroupWidget.builder()
+                .matrix(matrix)
+                .key(key, i -> {
+                    ModularSlot slot = new ModularSlot(importItems.storage, i);
+                    ItemSlotSyncHandler syncHandler = new ItemSlotSyncHandler(slot.slotGroup(slotGroup));
+                    syncManager.syncValue("import", i, syncHandler);
+                    return new ItemSlot()
+                            .syncHandler("import", i)
+                            .background(theme.getItemSlotTheme().theme().getBackground(),
+                                    (i == 0) ? GTGuiTextures.PRIMITIVE_INGOT_OVERLAY : (i == 1) ?
+                                            GTGuiTextures.PRIMITIVE_DUST_OVERLAY :
+                                            GTGuiTextures.PRIMITIVE_FURNACE_OVERLAY);
+                })
+                .build();
+    }
+
+    private SlotGroupWidget createExportItemSlot(PanelSyncManager syncManager, ITheme theme) {
+        int size = exportItems.storage.getSlots();
+        SlotGroup slotGroup = new SlotGroup("export", size);
+        String[] matrix = new String[1];
+        char key = 'I';
+        matrix[0] = String.valueOf(key).repeat(size);
+        return SlotGroupWidget.builder()
+                .matrix(matrix)
+                .key(key, i -> {
+                    ModularSlot slot = new ModularSlot(exportItems.storage, i);
+                    slot.accessibility(false, true);
+                    ItemSlotSyncHandler syncHandler = new ItemSlotSyncHandler(slot.slotGroup(slotGroup));
+                    syncManager.syncValue("export", i, syncHandler);
+                    return new ItemSlot()
+                            .syncHandler("export", i)
+                            .background(theme.getItemSlotTheme().theme().getBackground(),
+                                    (i == 0) ? GTGuiTextures.PRIMITIVE_INGOT_OVERLAY :
+                                            GTGuiTextures.PRIMITIVE_DUST_OVERLAY);
+                })
+                .build();
     }
 
     @Override
diff --git a/src/main/java/com/gregtechceu/gtceu/common/machine/multiblock/primitive/PrimitiveFancyUIWorkableMachine.java b/src/main/java/com/gregtechceu/gtceu/common/machine/multiblock/primitive/PrimitiveFancyUIWorkableMachine.java
deleted file mode 100644
index 1dc01efe414..00000000000
--- a/src/main/java/com/gregtechceu/gtceu/common/machine/multiblock/primitive/PrimitiveFancyUIWorkableMachine.java
+++ /dev/null
@@ -1,11 +0,0 @@
-package com.gregtechceu.gtceu.common.machine.multiblock.primitive;
-
-import com.gregtechceu.gtceu.api.blockentity.BlockEntityCreationInfo;
-import com.gregtechceu.gtceu.api.machine.feature.IFancyUIMachine;
-
-public class PrimitiveFancyUIWorkableMachine extends PrimitiveWorkableMachine implements IFancyUIMachine {
-
-    public PrimitiveFancyUIWorkableMachine(BlockEntityCreationInfo info) {
-        super(info);
-    }
-}
diff --git a/src/main/java/com/gregtechceu/gtceu/common/machine/multiblock/steam/LargeBoilerMachine.java b/src/main/java/com/gregtechceu/gtceu/common/machine/multiblock/steam/LargeBoilerMachine.java
index 24291ddd09c..b9c18ec68cb 100644
--- a/src/main/java/com/gregtechceu/gtceu/common/machine/multiblock/steam/LargeBoilerMachine.java
+++ b/src/main/java/com/gregtechceu/gtceu/common/machine/multiblock/steam/LargeBoilerMachine.java
@@ -3,10 +3,10 @@
 import com.gregtechceu.gtceu.api.GTValues;
 import com.gregtechceu.gtceu.api.blockentity.BlockEntityCreationInfo;
 import com.gregtechceu.gtceu.api.capability.recipe.*;
-import com.gregtechceu.gtceu.api.gui.GuiTextures;
 import com.gregtechceu.gtceu.api.machine.MetaMachine;
 import com.gregtechceu.gtceu.api.machine.TickableSubscription;
-import com.gregtechceu.gtceu.api.machine.feature.multiblock.IDisplayUIMachine;
+import com.gregtechceu.gtceu.api.machine.feature.IMuiMachine;
+import com.gregtechceu.gtceu.api.machine.feature.IVoidable;
 import com.gregtechceu.gtceu.api.machine.multiblock.WorkableMultiblockMachine;
 import com.gregtechceu.gtceu.api.machine.trait.RecipeLogic;
 import com.gregtechceu.gtceu.api.recipe.GTRecipe;
@@ -16,29 +16,41 @@
 import com.gregtechceu.gtceu.api.sync_system.annotations.SaveField;
 import com.gregtechceu.gtceu.api.sync_system.annotations.SyncToClient;
 import com.gregtechceu.gtceu.common.data.GTMaterials;
+import com.gregtechceu.gtceu.common.mui.GTGuiTextures;
 import com.gregtechceu.gtceu.config.ConfigHolder;
 import com.gregtechceu.gtceu.utils.GTUtil;
 
-import com.lowdragmc.lowdraglib.gui.texture.IGuiTexture;
-import com.lowdragmc.lowdraglib.gui.util.ClickData;
-import com.lowdragmc.lowdraglib.gui.widget.ComponentPanelWidget;
-
 import net.minecraft.ChatFormatting;
 import net.minecraft.core.Direction;
 import net.minecraft.network.chat.Component;
-import net.minecraft.network.chat.HoverEvent;
-import net.minecraft.network.chat.Style;
 import net.minecraft.server.TickTask;
 import net.minecraft.server.level.ServerLevel;
 import net.minecraft.util.Mth;
 import net.minecraft.world.level.material.Fluids;
 
+import brachy.modularui.api.drawable.IKey;
+import brachy.modularui.drawable.Icon;
+import brachy.modularui.factory.PosGuiData;
+import brachy.modularui.screen.UISettings;
+import brachy.modularui.utils.Alignment;
+import brachy.modularui.utils.Color;
+import brachy.modularui.utils.MouseData;
+import brachy.modularui.value.sync.BooleanSyncValue;
+import brachy.modularui.value.sync.IntSyncValue;
+import brachy.modularui.value.sync.PanelSyncManager;
+import brachy.modularui.value.sync.StringSyncValue;
+import brachy.modularui.widget.ParentWidget;
+import brachy.modularui.widget.Widget;
+import brachy.modularui.widgets.ButtonWidget;
+import brachy.modularui.widgets.ListWidget;
+import brachy.modularui.widgets.layout.Flow;
+import brachy.modularui.widgets.textfield.TextFieldWidget;
 import lombok.Getter;
 import org.jetbrains.annotations.Nullable;
 
 import java.util.*;
 
-public class LargeBoilerMachine extends WorkableMultiblockMachine implements IDisplayUIMachine {
+public class LargeBoilerMachine extends WorkableMultiblockMachine implements IMuiMachine, IVoidable {
 
     public static final int TICKS_PER_STEAM_GENERATION = 5;
 
@@ -196,40 +208,142 @@ public static ModifierFunction recipeModifier(MetaMachine machine, GTRecipe reci
         return ModifierFunction.IDENTITY;
     }
 
-    public void addDisplayText(List<Component> textList) {
-        IDisplayUIMachine.super.addDisplayText(textList);
-        if (isFormed()) {
-            textList.add(Component.translatable("gtceu.multiblock.large_boiler.temperature",
-                    currentTemperature + 274, maxTemperature + 274));
-            textList.add(Component.translatable("gtceu.multiblock.large_boiler.steam_output",
-                    steamGenerated / TICKS_PER_STEAM_GENERATION));
-
-            var throttleText = Component.translatable("gtceu.multiblock.large_boiler.throttle",
-                    ChatFormatting.AQUA.toString() + getThrottle() + "%")
-                    .withStyle(Style.EMPTY.withHoverEvent(new HoverEvent(HoverEvent.Action.SHOW_TEXT,
-                            Component.translatable("gtceu.multiblock.large_boiler.throttle.tooltip"))));
-            textList.add(throttleText);
-
-            var buttonText = Component.translatable("gtceu.multiblock.large_boiler.throttle_modify");
-            buttonText.append(" ");
-            buttonText.append(ComponentPanelWidget.withButton(Component.literal("[-]"), "sub"));
-            buttonText.append(" ");
-            buttonText.append(ComponentPanelWidget.withButton(Component.literal("[+]"), "add"));
-            textList.add(buttonText);
+    @Override
+    public void buildMainUI(ParentWidget<?> mainWidget, PosGuiData guiData, PanelSyncManager syncManager,
+                            UISettings settings) {
+        mainWidget.child(new ParentWidget<>()
+                .widthRel(0.95f)
+                .heightRel(.65f)
+                .margin(4, 0)
+                .left(3).top(2)
+                .horizontalCenter()
+                .child(Flow.row()
+                        .child(getMainTextPanel(syncManager, 186, 146))));
+    }
+
+    public Widget<?> getMainTextPanel(PanelSyncManager syncManager, int width, int height) {
+        var parentWidget = new ParentWidget<>();
+        var listWidget = new ListWidget<>();
+        listWidget
+                .width(width - 6)
+                .height(height - 6)
+                .childSeparator(Icon.EMPTY_2PX)
+                .crossAxisAlignment(Alignment.CrossAxis.START)
+                .posRel(Alignment.CenterLeft)
+                .left(3)
+                .top(3);
+        parentWidget.size(width, height)
+                .background(GTGuiTextures.DISPLAY);
+
+        // Machine generic sync handlers
+        BooleanSyncValue isFormed = syncManager.getOrCreateSyncHandler("isFormed", BooleanSyncValue.class,
+                () -> new BooleanSyncValue(this::isFormed));
+
+        // Large Boiler specific sync handlers
+        // These will not be called anywhere else, so we can create them directly instead of using
+        // getOrCreateSyncHandler
+
+        IntSyncValue currentTemperature = new IntSyncValue(this::getCurrentTemperature);
+        syncManager.syncValue("currentTemperature", currentTemperature);
+
+        IntSyncValue maxTemperature = new IntSyncValue(this::getMaxTemperature);
+        syncManager.syncValue("maxTemperature", maxTemperature);
+
+        IntSyncValue steamGenerated = new IntSyncValue(() -> this.steamGenerated);
+        syncManager.syncValue("steamGenerated", steamGenerated);
+
+        IntSyncValue throttle = new IntSyncValue(() -> this.throttle, newValue -> this.throttle = newValue);
+        syncManager.syncValue("throttle", throttle);
+
+        listWidget
+                .child(IKey.dynamic(() -> {
+                    if (!isFormed.getBoolValue()) return Component.empty();
+                    return Component.translatable("gtceu.multiblock.large_boiler.temperature",
+                            currentTemperature.getIntValue() + 274, maxTemperature.getIntValue() + 274)
+                            .withStyle(ChatFormatting.WHITE);
+                })
+                        .asWidget())
+                .child(IKey.dynamic(() -> {
+                    if (!isFormed.getBoolValue()) return Component.empty();
+                    return Component.translatable("gtceu.multiblock.large_boiler.steam_output",
+                            steamGenerated.getIntValue() / TICKS_PER_STEAM_GENERATION).withStyle(ChatFormatting.WHITE);
+                })
+                        .asWidget())
+                .child(IKey.lang(Component.translatable("gtceu.multiblock.large_boiler.throttle_modify")
+                        .withStyle(ChatFormatting.WHITE))
+                        .asWidget())
+                .child(createIntInputWithButtons(throttle))
+
+                .setEnabledIf((widget) -> isFormed.getBoolValue());
+        parentWidget.child(listWidget);
+        return parentWidget;
+    }
+
+    public static ParentWidget<?> createIntInputWithButtons(IntSyncValue syncValue) {
+        StringSyncValue formattedValue = new StringSyncValue(syncValue::getStringValue,
+                syncValue::setStringValue);
+
+        var textField = new TextFieldWidget() {
+
+            @Override
+            public boolean onMouseScrolled(double mouseX, double mouseY, double delta) {
+                int inc = (int) delta;
+                int val = Mth.clamp(syncValue.getIntValue() + inc, 25, 100);
+                syncValue.setIntValue(val, true, true);
+                return true;
+            }
         }
+                .left(18).right(18)
+                .setTextAlignment(Alignment.Center)
+                .setTextColor(Color.WHITE.darker(1))
+                .setNumbers(25, 100)
+                .value(formattedValue);
+
+        return Flow.row()
+                .coverChildrenHeight()
+                .marginBottom(2)
+                .widthRel(1.0f)
+                .child(new ButtonWidget<>()
+                        .left(0).width(18)
+                        .onMousePressed((x, y, button) -> {
+                            int val = syncValue.getIntValue() - getIncrementValue(MouseData.create(button));
+                            val = Mth.clamp(val, 25, 100);
+                            syncValue.setIntValue(val, true, true);
+                            return true;
+                        })
+                        .onUpdateListener(w -> w.overlay(createAdjustOverlay(false))))
+                .child(textField)
+                .child(new ButtonWidget<>()
+                        .right(0).width(18)
+                        .onMousePressed((x, y, button) -> {
+                            int val = syncValue.getIntValue() + getIncrementValue(MouseData.create(button));
+                            val = Mth.clamp(val, 25, 100);
+                            syncValue.setIntValue(val, true, true);
+                            return true;
+                        })
+                        .onUpdateListener(w -> w.overlay(createAdjustOverlay(true))));
     }
 
-    public void handleDisplayClick(String componentData, ClickData clickData) {
-        if (!clickData.isRemote) {
-            int result = componentData.equals("add") ? 5 : -5;
-            this.throttle = Mth.clamp(throttle + result, 25, 100);
-            this.getRecipeLogic().modifyFuelBurnTime(this.throttle);
+    private static IKey createAdjustOverlay(boolean increment) {
+        final StringBuilder builder = new StringBuilder();
+        builder.append(increment ? '+' : '-');
+        builder.append(getIncrementValue(MouseData.create(-1)));
+
+        float scale = 1f;
+        if (builder.length() == 3) {
+            scale = 0.8f;
+        } else if (builder.length() == 4) {
+            scale = 0.6f;
+        } else if (builder.length() > 4) {
+            scale = 0.5f;
         }
+        return IKey.str(builder.toString())
+                .color(Color.WHITE.main)
+                .scale(scale);
     }
 
-    @Override
-    public IGuiTexture getScreenTexture() {
-        return GuiTextures.DISPLAY_STEAM.get(maxTemperature > 800);
+    private static int getIncrementValue(MouseData data) {
+        return data.shift() ? 5 : 1;
     }
 
     public static class LargeBoilerRecipeLogic extends RecipeLogic {
diff --git a/src/main/java/com/gregtechceu/gtceu/common/machine/multiblock/steam/SteamParallelMultiblockMachine.java b/src/main/java/com/gregtechceu/gtceu/common/machine/multiblock/steam/SteamParallelMultiblockMachine.java
index 41b5c56bc50..efdb67aff23 100644
--- a/src/main/java/com/gregtechceu/gtceu/common/machine/multiblock/steam/SteamParallelMultiblockMachine.java
+++ b/src/main/java/com/gregtechceu/gtceu/common/machine/multiblock/steam/SteamParallelMultiblockMachine.java
@@ -4,10 +4,8 @@
 import com.gregtechceu.gtceu.api.blockentity.BlockEntityCreationInfo;
 import com.gregtechceu.gtceu.api.capability.recipe.FluidRecipeCapability;
 import com.gregtechceu.gtceu.api.capability.recipe.IO;
-import com.gregtechceu.gtceu.api.gui.GuiTextures;
-import com.gregtechceu.gtceu.api.gui.UITemplate;
 import com.gregtechceu.gtceu.api.machine.MetaMachine;
-import com.gregtechceu.gtceu.api.machine.feature.multiblock.IDisplayUIMachine;
+import com.gregtechceu.gtceu.api.machine.feature.IMuiMachine;
 import com.gregtechceu.gtceu.api.machine.multiblock.PartAbility;
 import com.gregtechceu.gtceu.api.machine.multiblock.WorkableMultiblockMachine;
 import com.gregtechceu.gtceu.api.machine.steam.SteamEnergyRecipeHandler;
@@ -19,39 +17,37 @@
 import com.gregtechceu.gtceu.api.recipe.modifier.ModifierFunction;
 import com.gregtechceu.gtceu.api.recipe.modifier.ParallelLogic;
 import com.gregtechceu.gtceu.api.recipe.modifier.RecipeModifier;
+import com.gregtechceu.gtceu.api.sync_system.annotations.SyncToClient;
 import com.gregtechceu.gtceu.common.data.GTMaterials;
+import com.gregtechceu.gtceu.common.mui.GTMultiblockTextUtil;
 import com.gregtechceu.gtceu.config.ConfigHolder;
 
-import com.lowdragmc.lowdraglib.gui.modular.ModularUI;
-import com.lowdragmc.lowdraglib.gui.texture.IGuiTexture;
-import com.lowdragmc.lowdraglib.gui.widget.ComponentPanelWidget;
-import com.lowdragmc.lowdraglib.gui.widget.DraggableScrollableWidgetGroup;
-import com.lowdragmc.lowdraglib.gui.widget.LabelWidget;
-
-import net.minecraft.ChatFormatting;
 import net.minecraft.MethodsReturnNonnullByDefault;
-import net.minecraft.network.chat.Component;
-import net.minecraft.network.chat.Style;
-import net.minecraft.world.entity.player.Player;
 
+import brachy.modularui.drawable.GuiTextures;
+import brachy.modularui.drawable.Icon;
+import brachy.modularui.factory.PosGuiData;
+import brachy.modularui.screen.UISettings;
+import brachy.modularui.utils.Alignment;
+import brachy.modularui.value.sync.PanelSyncManager;
+import brachy.modularui.widget.ParentWidget;
+import brachy.modularui.widgets.ListWidget;
 import lombok.Getter;
 import lombok.Setter;
-import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 
-import java.util.List;
-
 import javax.annotation.ParametersAreNonnullByDefault;
 
 @ParametersAreNonnullByDefault
 @MethodsReturnNonnullByDefault
-public class SteamParallelMultiblockMachine extends WorkableMultiblockMachine implements IDisplayUIMachine {
+public class SteamParallelMultiblockMachine extends WorkableMultiblockMachine implements IMuiMachine {
 
     @Getter
     @Setter
     private int maxParallels;
 
     @Nullable
+    @SyncToClient
     private SteamEnergyRecipeHandler steamEnergy = null;
 
     // if in millibuckets, this is 2.0, Meaning 2mb of steam -> 1 EU
@@ -78,6 +74,7 @@ public void onStructureFormed() {
                     if (!(fluidHandler instanceof NotifiableFluidTank nft)) continue;
                     if (nft.isFluidValid(0, GTMaterials.Steam.getFluid(1))) {
                         steamEnergy = new SteamEnergyRecipeHandler(nft, getConversionRate());
+                        syncDataHolder.markClientSyncFieldDirty("steamEnergy");
                         addHandlerList(RecipeHandlerList.of(IO.IN, steamEnergy));
                         return;
                     }
@@ -108,7 +105,7 @@ public double getConversionRate() {
      * @param recipe  recipe
      * @return A {@link ModifierFunction} for the given Steam Multiblock Machine and recipe
      */
-    public static ModifierFunction recipeModifier(@NotNull MetaMachine machine, @NotNull GTRecipe recipe) {
+    public static ModifierFunction recipeModifier(MetaMachine machine, GTRecipe recipe) {
         if (!(machine instanceof SteamParallelMultiblockMachine steamMachine)) {
             return RecipeModifier.nullWrongType(SteamParallelMultiblockMachine.class, machine);
         }
@@ -129,55 +126,22 @@ public static ModifierFunction recipeModifier(@NotNull MetaMachine machine, @Not
     }
 
     @Override
-    public void addDisplayText(List<Component> textList) {
-        IDisplayUIMachine.super.addDisplayText(textList);
-        if (isFormed()) {
-            if (steamEnergy != null && steamEnergy.getCapacity() > 0) {
-                long steamStored = steamEnergy.getStored();
-                textList.add(Component.translatable("gtceu.multiblock.steam.steam_stored", steamStored,
-                        steamEnergy.getCapacity()));
-            }
-
-            if (!isWorkingEnabled()) {
-                textList.add(Component.translatable("gtceu.multiblock.work_paused"));
-
-            } else if (isActive()) {
-                textList.add(Component.translatable("gtceu.multiblock.running"));
-                if (maxParallels > 1) textList.add(Component.translatable("gtceu.multiblock.parallel", maxParallels));
-                int currentProgress = (int) (recipeLogic.getProgressPercent() * 100);
-                double maxInSec = (float) recipeLogic.getDuration() / 20.0f;
-                double currentInSec = (float) recipeLogic.getProgress() / 20.0f;
-                textList.add(
-                        Component.translatable("gtceu.multiblock.progress", String.format("%.2f", (float) currentInSec),
-                                String.format("%.2f", (float) maxInSec), currentProgress));
-            } else {
-                textList.add(Component.translatable("gtceu.multiblock.idling"));
-            }
-
-            if (recipeLogic.isWaiting()) {
-                textList.add(Component.translatable("gtceu.multiblock.steam.low_steam")
-                        .setStyle(Style.EMPTY.withColor(ChatFormatting.RED)));
-            }
-        }
-    }
-
-    @Override
-    public IGuiTexture getScreenTexture() {
-        return GuiTextures.DISPLAY_STEAM.get(ConfigHolder.INSTANCE.machines.steelSteamMultiblocks);
-    }
-
-    @Override
-    public ModularUI createUI(Player entityPlayer) {
-        var screen = new DraggableScrollableWidgetGroup(7, 4, 162, 121).setBackground(getScreenTexture());
-        screen.addWidget(new LabelWidget(4, 5, self().getBlockState().getBlock().getDescriptionId()));
-        screen.addWidget(new ComponentPanelWidget(4, 17, this::addDisplayText)
-                .setMaxWidthLimit(150)
-                .clickHandler(this::handleDisplayClick));
-        return new ModularUI(176, 216, this, entityPlayer)
-                .background(GuiTextures.BACKGROUND_STEAM.get(ConfigHolder.INSTANCE.machines.steelSteamMultiblocks))
-                .widget(screen)
-                .widget(UITemplate.bindPlayerInventory(entityPlayer.getInventory(),
-                        GuiTextures.SLOT_STEAM.get(ConfigHolder.INSTANCE.machines.steelSteamMultiblocks), 7, 134,
-                        true));
+    public void buildMainUI(ParentWidget<?> mainWidget, PosGuiData guiData, PanelSyncManager syncManager,
+                            UISettings settings) {
+        mainWidget.size(170, 70).background(GuiTextures.DISPLAY);
+
+        var listWidget = new ListWidget<>()
+                .width(170 - 6)
+                .height(70 - 6)
+                .childSeparator(Icon.EMPTY_2PX)
+                .crossAxisAlignment(Alignment.CrossAxis.START)
+                .posRel(Alignment.CenterLeft);
+
+        listWidget.child(GTMultiblockTextUtil.addSteamUsageLine(this.steamEnergy, syncManager))
+                .child(GTMultiblockTextUtil.addProgressLine(this, syncManager))
+                .child(GTMultiblockTextUtil.addParallelLine(this, syncManager))
+                .child(GTMultiblockTextUtil.addOutputLines(this, syncManager));
+
+        mainWidget.child(listWidget.left(3).top(3));
     }
 }
diff --git a/src/main/java/com/gregtechceu/gtceu/common/machine/steam/SteamLiquidBoilerMachine.java b/src/main/java/com/gregtechceu/gtceu/common/machine/steam/SteamLiquidBoilerMachine.java
index 8cb8757aeff..5c78be6f3b4 100644
--- a/src/main/java/com/gregtechceu/gtceu/common/machine/steam/SteamLiquidBoilerMachine.java
+++ b/src/main/java/com/gregtechceu/gtceu/common/machine/steam/SteamLiquidBoilerMachine.java
@@ -3,26 +3,32 @@
 import com.gregtechceu.gtceu.api.blockentity.BlockEntityCreationInfo;
 import com.gregtechceu.gtceu.api.capability.recipe.FluidRecipeCapability;
 import com.gregtechceu.gtceu.api.capability.recipe.IO;
-import com.gregtechceu.gtceu.api.gui.GuiTextures;
-import com.gregtechceu.gtceu.api.gui.widget.TankWidget;
 import com.gregtechceu.gtceu.api.machine.steam.SteamBoilerMachine;
 import com.gregtechceu.gtceu.api.machine.trait.NotifiableFluidTank;
 import com.gregtechceu.gtceu.api.sync_system.annotations.SaveField;
+import com.gregtechceu.gtceu.common.mui.GTGuiTextures;
 import com.gregtechceu.gtceu.config.ConfigHolder;
 import com.gregtechceu.gtceu.utils.ExtendedUseOnContext;
 
-import com.lowdragmc.lowdraglib.gui.modular.ModularUI;
-import com.lowdragmc.lowdraglib.gui.texture.ProgressTexture;
-
 import net.minecraft.MethodsReturnNonnullByDefault;
 import net.minecraft.core.particles.ParticleTypes;
 import net.minecraft.util.RandomSource;
 import net.minecraft.world.InteractionResult;
-import net.minecraft.world.entity.player.Player;
 import net.minecraft.world.level.material.Fluid;
 import net.minecraftforge.fluids.FluidType;
 import net.minecraftforge.fluids.FluidUtil;
 
+import brachy.modularui.drawable.UITexture;
+import brachy.modularui.factory.PosGuiData;
+import brachy.modularui.screen.UISettings;
+import brachy.modularui.utils.Alignment;
+import brachy.modularui.value.sync.DoubleSyncValue;
+import brachy.modularui.value.sync.FluidSlotSyncHandler;
+import brachy.modularui.value.sync.PanelSyncManager;
+import brachy.modularui.widget.ParentWidget;
+import brachy.modularui.widgets.ProgressWidget;
+import brachy.modularui.widgets.layout.Flow;
+import brachy.modularui.widgets.slot.FluidSlot;
 import it.unimi.dsi.fastutil.objects.Object2BooleanMap;
 import it.unimi.dsi.fastutil.objects.Object2BooleanOpenHashMap;
 
@@ -68,12 +74,34 @@ protected long getBaseSteamOutput() {
     }
 
     @Override
-    public ModularUI createUI(Player entityPlayer) {
-        return super.createUI(entityPlayer)
-                .widget(new TankWidget(fuelTank.getStorages()[0], 119, 26, 10, 54, true, true)
-                        .setShowAmount(false)
-                        .setFillDirection(ProgressTexture.FillDirection.DOWN_TO_UP)
-                        .setBackground(GuiTextures.PROGRESS_BAR_BOILER_EMPTY.get(isHighPressure)));
+    public void buildMainUI(ParentWidget<?> mainWidget, PosGuiData guiData, PanelSyncManager syncManager,
+                            UISettings settings) {
+        super.buildMainUI(mainWidget, guiData, syncManager, settings);
+
+        UITexture progressTexture = isHighPressure() ? GTGuiTextures.PROGRESS_BAR_BOILER_FUEL_STEEL :
+                GTGuiTextures.PROGRESS_BAR_BOILER_FUEL_BRONZE;
+
+        DoubleSyncValue progressPercent = syncManager.getOrCreateSyncHandler("progressPercent", DoubleSyncValue.class,
+                () -> new DoubleSyncValue(() -> {
+                    if (recipeLogic == null) return -1f;
+                    return recipeLogic.getProgressPercent();
+                }));
+
+        mainWidget.child(Flow.row()
+                .coverChildren()
+                .right(12).top(12)
+                .childPadding(4)
+                .crossAxisAlignment(Alignment.CrossAxis.CENTER)
+                .child(new ProgressWidget()
+                        .size(18)
+                        .texture(progressTexture, 18)
+                        .value(progressPercent)
+                        .direction(ProgressWidget.Direction.UP)
+                        .setEnabledIf((w) -> progressPercent.getFloatValue() > -1f))
+                .child(new FluidSlot()
+                        .syncHandler(new FluidSlotSyncHandler(fuelTank.getStorages()[0])
+                                .canFillSlot(true).canDrainSlot(true))
+                        .size(14, 54)));
     }
 
     @Override
diff --git a/src/main/java/com/gregtechceu/gtceu/common/machine/steam/SteamMinerMachine.java b/src/main/java/com/gregtechceu/gtceu/common/machine/steam/SteamMinerMachine.java
index ef6e016237a..b00bb81747f 100644
--- a/src/main/java/com/gregtechceu/gtceu/common/machine/steam/SteamMinerMachine.java
+++ b/src/main/java/com/gregtechceu/gtceu/common/machine/steam/SteamMinerMachine.java
@@ -4,39 +4,41 @@
 import com.gregtechceu.gtceu.api.capability.IControllable;
 import com.gregtechceu.gtceu.api.capability.IMiner;
 import com.gregtechceu.gtceu.api.capability.recipe.IO;
-import com.gregtechceu.gtceu.api.gui.GuiTextures;
-import com.gregtechceu.gtceu.api.gui.UITemplate;
-import com.gregtechceu.gtceu.api.gui.widget.PredicatedImageWidget;
-import com.gregtechceu.gtceu.api.gui.widget.SlotWidget;
 import com.gregtechceu.gtceu.api.machine.TickableSubscription;
 import com.gregtechceu.gtceu.api.machine.feature.*;
+import com.gregtechceu.gtceu.api.machine.mui.MachineUIPanelBuilder;
 import com.gregtechceu.gtceu.api.machine.steam.SteamWorkableMachine;
 import com.gregtechceu.gtceu.api.machine.trait.NotifiableItemStackHandler;
 import com.gregtechceu.gtceu.api.sync_system.annotations.SaveField;
 import com.gregtechceu.gtceu.common.item.behavior.PortableScannerBehavior;
 import com.gregtechceu.gtceu.common.machine.trait.ExhaustVentMachineTrait;
 import com.gregtechceu.gtceu.common.machine.trait.miner.SteamMinerLogic;
+import com.gregtechceu.gtceu.common.mui.GTGuiTextures;
+import com.gregtechceu.gtceu.common.mui.GTMuiMachineUtil;
 import com.gregtechceu.gtceu.utils.GTTransferUtils;
 import com.gregtechceu.gtceu.utils.ISubscription;
 
-import com.lowdragmc.lowdraglib.gui.modular.ModularUI;
-import com.lowdragmc.lowdraglib.gui.widget.ComponentPanelWidget;
-import com.lowdragmc.lowdraglib.gui.widget.ImageWidget;
-import com.lowdragmc.lowdraglib.gui.widget.LabelWidget;
-
 import net.minecraft.ChatFormatting;
 import net.minecraft.MethodsReturnNonnullByDefault;
 import net.minecraft.core.BlockPos;
 import net.minecraft.core.Direction;
 import net.minecraft.network.chat.Component;
+import net.minecraft.network.chat.Style;
 import net.minecraft.server.TickTask;
 import net.minecraft.server.level.ServerLevel;
-import net.minecraft.world.entity.player.Player;
 import net.minecraft.world.level.block.Block;
 import net.minecraftforge.fluids.capability.IFluidHandler;
 
+import brachy.modularui.api.drawable.IKey;
+import brachy.modularui.factory.PosGuiData;
+import brachy.modularui.screen.UISettings;
+import brachy.modularui.utils.Alignment;
+import brachy.modularui.utils.Color;
+import brachy.modularui.value.sync.PanelSyncManager;
+import brachy.modularui.widget.ParentWidget;
+import brachy.modularui.widgets.TextWidget;
+import brachy.modularui.widgets.layout.Flow;
 import lombok.Getter;
-import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 
 import java.util.ArrayList;
@@ -48,7 +50,7 @@
 @ParametersAreNonnullByDefault
 @MethodsReturnNonnullByDefault
 public class SteamMinerMachine extends SteamWorkableMachine implements IControllable,
-                               IUIMachine, IDataInfoProvider, IMiner {
+                               IDataInfoProvider, IMiner, IMuiMachine {
 
     @SaveField
     public final NotifiableItemStackHandler importItems;
@@ -141,53 +143,60 @@ protected void autoOutput() {
     //////////////////////////////////////
     // *********** GUI ***********//
     //////////////////////////////////////
-    @Override
-    public ModularUI createUI(Player entityPlayer) {
-        int rowSize = (int) Math.sqrt(inventorySize);
-
-        ModularUI builder = new ModularUI(175, 176, this, entityPlayer)
-                .background(GuiTextures.BACKGROUND_STEAM.get(isHighPressure()));
-        builder.widget(UITemplate.bindPlayerInventory(entityPlayer.getInventory(),
-                GuiTextures.SLOT_STEAM.get(isHighPressure()), 7,
-                94, true));
-
-        for (int y = 0; y < rowSize; y++) {
-            for (int x = 0; x < rowSize; x++) {
-                int index = y * rowSize + x;
-                builder.widget(new SlotWidget(exportItems, index, 142 - rowSize * 9 + x * 18, 18 + y * 18, true, false)
-                        .setBackgroundTexture(GuiTextures.SLOT_STEAM.get(isHighPressure())));
-            }
-        }
 
-        builder.widget(new LabelWidget(5, 5, getBlockState().getBlock().getDescriptionId()));
-        builder.widget(new PredicatedImageWidget(79, 42, 18, 18, GuiTextures.INDICATOR_NO_STEAM.get(isHighPressure()))
-                .setPredicate(() -> !drainInput(true)));
-        builder.widget(new ImageWidget(7, 16, 105, 75, GuiTextures.DISPLAY_STEAM.get(isHighPressure())));
-        builder.widget(new ComponentPanelWidget(10, 19, this::addDisplayText)
-                .setMaxWidthLimit(84));
-        builder.widget(new ComponentPanelWidget(70, 19, this::addDisplayText2)
-                .setMaxWidthLimit(84));
+    @Override
+    public MachineUIPanelBuilder getPanelBuilder(PosGuiData data, PanelSyncManager syncManager, UISettings settings) {
+        return MachineUIPanelBuilder.defaultSteamMachineBuilder(this);
+    }
 
-        return builder;
+    @Override
+    public void buildMainUI(ParentWidget<?> mainWidget, PosGuiData guiData, PanelSyncManager syncManager,
+                            UISettings settings) {
+        mainWidget.width(200)
+                .child(Flow.row()
+                        .coverChildrenHeight()
+                        .margin(5)
+                        .childPadding(5)
+                        .width(200)
+                        .child(Flow.column()
+                                .crossAxisAlignment(Alignment.CrossAxis.START)
+                                .padding(5)
+                                .background(GTGuiTextures.DISPLAY)
+                                .widthRel(.6f)
+                                .coverChildrenHeight()
+                                .child(new TextWidget<>(IKey.dynamic(() -> {
+                                    List<Component> text = new ArrayList<>();
+                                    addDisplayText(text);
+                                    return text.stream()
+                                            .map(Component::copy)
+                                            .reduce((a, b) -> a.append("\n").append(b))
+                                            .orElse(Component.empty());
+                                })).color(Color.WHITE.main)))
+                        .child(GTMuiMachineUtil.createSquareSlotGroupFromInventory(exportItems, "export_inv",
+                                syncManager).posRel(0.875f, 0.5f)));
     }
 
-    void addDisplayText(List<Component> textList) {
+    private void addDisplayText(List<Component> textList) {
         int workingArea = IMiner.getWorkingArea(getRecipeLogic().getCurrentRadius());
-        textList.add(Component.translatable("gtceu.machine.miner.startx", this.getRecipeLogic().getX()));
-        textList.add(Component.translatable("gtceu.machine.miner.starty", this.getRecipeLogic().getY()));
-        textList.add(Component.translatable("gtceu.machine.miner.startz", this.getRecipeLogic().getZ()));
+        textList.add(recipeLogic.getCustomProgressLine());
+        textList.add(
+                Component.translatable("gtceu.machine.miner.x", getRecipeLogic().getX(), getRecipeLogic().getMineX()));
+        textList.add(
+                Component.translatable("gtceu.machine.miner.y", getRecipeLogic().getY(), getRecipeLogic().getMineY()));
+        textList.add(
+                Component.translatable("gtceu.machine.miner.x", getRecipeLogic().getZ(), getRecipeLogic().getMineZ()));
         textList.add(Component.translatable("gtceu.universal.tooltip.working_area", workingArea, workingArea));
-        if (this.getRecipeLogic().isDone())
+        if (getRecipeLogic().isDone())
             textList.add(Component.translatable("gtceu.multiblock.large_miner.done")
-                    .withStyle(ChatFormatting.GREEN));
-        else if (this.getRecipeLogic().isWorking())
+                    .setStyle(Style.EMPTY.withColor(ChatFormatting.GREEN)));
+        else if (getRecipeLogic().isWorking())
             textList.add(Component.translatable("gtceu.multiblock.large_miner.working")
-                    .withStyle(ChatFormatting.GOLD));
+                    .setStyle(Style.EMPTY.withColor(ChatFormatting.GOLD)));
         else if (!this.isWorkingEnabled())
             textList.add(Component.translatable("gtceu.multiblock.work_paused"));
         if (getRecipeLogic().isInventoryFull())
             textList.add(Component.translatable("gtceu.multiblock.large_miner.invfull")
-                    .withStyle(ChatFormatting.RED));
+                    .setStyle(Style.EMPTY.withColor(ChatFormatting.RED)));
         if (exhaustVentTrait.isVentingBlocked())
             textList.add(Component.translatable("gtceu.multiblock.large_miner.vent")
                     .withStyle(ChatFormatting.RED));
@@ -196,12 +205,6 @@ else if (!drainInput(true))
                     .withStyle(ChatFormatting.RED));
     }
 
-    void addDisplayText2(List<Component> textList) {
-        textList.add(Component.translatable("gtceu.machine.miner.minex", this.getRecipeLogic().getMineX()));
-        textList.add(Component.translatable("gtceu.machine.miner.miney", this.getRecipeLogic().getMineY()));
-        textList.add(Component.translatable("gtceu.machine.miner.minez", this.getRecipeLogic().getMineZ()));
-    }
-
     @Override
     public boolean drainInput(boolean simulate) {
         long resultSteam = steamTank.getFluidInTank(0).getAmount() - energyPerTick;
@@ -213,7 +216,6 @@ public boolean drainInput(boolean simulate) {
         return false;
     }
 
-    @NotNull
     @Override
     public List<Component> getDataInfo(PortableScannerBehavior.DisplayMode mode) {
         if (mode == PortableScannerBehavior.DisplayMode.SHOW_ALL ||
diff --git a/src/main/java/com/gregtechceu/gtceu/common/machine/steam/SteamSolarBoiler.java b/src/main/java/com/gregtechceu/gtceu/common/machine/steam/SteamSolarBoiler.java
index f721b926bc6..1149d7b5368 100644
--- a/src/main/java/com/gregtechceu/gtceu/common/machine/steam/SteamSolarBoiler.java
+++ b/src/main/java/com/gregtechceu/gtceu/common/machine/steam/SteamSolarBoiler.java
@@ -1,19 +1,23 @@
 package com.gregtechceu.gtceu.common.machine.steam;
 
 import com.gregtechceu.gtceu.api.blockentity.BlockEntityCreationInfo;
-import com.gregtechceu.gtceu.api.gui.GuiTextures;
 import com.gregtechceu.gtceu.api.machine.steam.SteamBoilerMachine;
 import com.gregtechceu.gtceu.api.machine.trait.RecipeLogic;
+import com.gregtechceu.gtceu.common.mui.GTGuiTextures;
 import com.gregtechceu.gtceu.config.ConfigHolder;
 import com.gregtechceu.gtceu.utils.GTUtil;
 
-import com.lowdragmc.lowdraglib.gui.modular.ModularUI;
-import com.lowdragmc.lowdraglib.gui.widget.ProgressWidget;
-
 import net.minecraft.MethodsReturnNonnullByDefault;
 import net.minecraft.core.Direction;
 import net.minecraft.util.RandomSource;
-import net.minecraft.world.entity.player.Player;
+
+import brachy.modularui.drawable.UITexture;
+import brachy.modularui.factory.PosGuiData;
+import brachy.modularui.screen.UISettings;
+import brachy.modularui.value.sync.DoubleSyncValue;
+import brachy.modularui.value.sync.PanelSyncManager;
+import brachy.modularui.widget.ParentWidget;
+import brachy.modularui.widgets.ProgressWidget;
 
 import java.util.Objects;
 
@@ -66,17 +70,23 @@ protected int getCoolDownRate() {
     }
 
     @Override
-    public ModularUI createUI(Player entityPlayer) {
-        return super.createUI(entityPlayer)
-                .widget(new ProgressWidget(
-                        () -> GTUtil.canSeeSunClearly(Objects.requireNonNull(getLevel()), getBlockPos()) ? 1.0 : 0.0,
-                        114,
-                        44, 20,
-                        20)
-                        .setProgressTexture(
-                                GuiTextures.PROGRESS_BAR_SOLAR_STEAM.get(isHighPressure).getSubTexture(0, 0, 1, 0.5),
-                                GuiTextures.PROGRESS_BAR_SOLAR_STEAM.get(isHighPressure).getSubTexture(0, 0.5, 1,
-                                        0.5)));
+    public void buildMainUI(ParentWidget<?> mainWidget, PosGuiData guiData, PanelSyncManager syncManager,
+                            UISettings settings) {
+        super.buildMainUI(mainWidget, guiData, syncManager, settings);
+
+        UITexture progressTexture = isHighPressure() ? GTGuiTextures.PROGRESS_BAR_SOLAR_STEEL :
+                GTGuiTextures.PROGRESS_BAR_SOLAR_BRONZE;
+
+        DoubleSyncValue canSeeSun = syncManager.getOrCreateSyncHandler("canSeeSun", DoubleSyncValue.class,
+                () -> new DoubleSyncValue(() -> {
+                    if (GTUtil.canSeeSunClearly(getLevel(), getBlockPos())) return 1.0f;
+                    return 0.0f;
+                }));
+
+        mainWidget.child(new ProgressWidget()
+                .size(18)
+                .texture(progressTexture, 20)
+                .value(canSeeSun));
     }
 
     @Override
diff --git a/src/main/java/com/gregtechceu/gtceu/common/machine/steam/SteamSolidBoilerMachine.java b/src/main/java/com/gregtechceu/gtceu/common/machine/steam/SteamSolidBoilerMachine.java
index 8af41202da5..44b5d089ae1 100644
--- a/src/main/java/com/gregtechceu/gtceu/common/machine/steam/SteamSolidBoilerMachine.java
+++ b/src/main/java/com/gregtechceu/gtceu/common/machine/steam/SteamSolidBoilerMachine.java
@@ -6,25 +6,28 @@
 import com.gregtechceu.gtceu.api.capability.recipe.ItemRecipeCapability;
 import com.gregtechceu.gtceu.api.data.chemical.ChemicalHelper;
 import com.gregtechceu.gtceu.api.data.tag.TagPrefix;
-import com.gregtechceu.gtceu.api.gui.GuiTextures;
-import com.gregtechceu.gtceu.api.gui.widget.SlotWidget;
 import com.gregtechceu.gtceu.api.machine.steam.SteamBoilerMachine;
 import com.gregtechceu.gtceu.api.machine.trait.NotifiableItemStackHandler;
 import com.gregtechceu.gtceu.api.sync_system.annotations.SaveField;
 import com.gregtechceu.gtceu.common.data.GTMaterials;
+import com.gregtechceu.gtceu.common.mui.GTGuiTextures;
 import com.gregtechceu.gtceu.config.ConfigHolder;
 
-import com.lowdragmc.lowdraglib.gui.modular.ModularUI;
-import com.lowdragmc.lowdraglib.gui.texture.GuiTextureGroup;
-import com.lowdragmc.lowdraglib.gui.texture.ProgressTexture;
-import com.lowdragmc.lowdraglib.gui.widget.ProgressWidget;
-
 import net.minecraft.MethodsReturnNonnullByDefault;
-import net.minecraft.world.entity.player.Player;
 import net.minecraft.world.item.Item;
 import net.minecraft.world.item.ItemStack;
 import net.minecraftforge.fluids.FluidUtil;
 
+import brachy.modularui.drawable.UITexture;
+import brachy.modularui.factory.PosGuiData;
+import brachy.modularui.screen.UISettings;
+import brachy.modularui.value.sync.DoubleSyncValue;
+import brachy.modularui.value.sync.PanelSyncManager;
+import brachy.modularui.widget.ParentWidget;
+import brachy.modularui.widgets.ProgressWidget;
+import brachy.modularui.widgets.layout.Flow;
+import brachy.modularui.widgets.slot.ItemSlot;
+import brachy.modularui.widgets.slot.ModularSlot;
 import it.unimi.dsi.fastutil.objects.Object2BooleanMap;
 import it.unimi.dsi.fastutil.objects.Object2BooleanOpenHashMap;
 
@@ -114,18 +117,32 @@ public static ItemStack getBurningFuelRemainder(ItemStack fuelStack) {
     }
 
     @Override
-    public ModularUI createUI(Player entityPlayer) {
-        return super.createUI(entityPlayer)
-                .widget(new SlotWidget(this.fuelHandler.storage, 0, 115, 62)
-                        .setBackgroundTexture(new GuiTextureGroup(GuiTextures.SLOT_STEAM.get(isHighPressure),
-                                GuiTextures.COAL_OVERLAY_STEAM.get(isHighPressure))))
-                .widget(new SlotWidget(this.ashHandler.storage, 0, 115, 26, true, false)
-                        .setBackgroundTexture(new GuiTextureGroup(GuiTextures.SLOT_STEAM.get(isHighPressure),
-                                GuiTextures.DUST_OVERLAY_STEAM.get(isHighPressure))))
-                .widget(new ProgressWidget(recipeLogic::getProgressPercent, 115, 44, 18, 18)
-                        .setProgressTexture(
-                                GuiTextures.PROGRESS_BAR_BOILER_FUEL.get(isHighPressure).getSubTexture(0, 0, 1, 0.5),
-                                GuiTextures.PROGRESS_BAR_BOILER_FUEL.get(isHighPressure).getSubTexture(0, 0.5, 1, 0.5))
-                        .setFillDirection(ProgressTexture.FillDirection.DOWN_TO_UP));
+    public void buildMainUI(ParentWidget<?> mainWidget, PosGuiData guiData, PanelSyncManager syncManager,
+                            UISettings settings) {
+        super.buildMainUI(mainWidget, guiData, syncManager, settings);
+
+        UITexture progressTexture = isHighPressure() ? GTGuiTextures.PROGRESS_BAR_BOILER_FUEL_STEEL :
+                GTGuiTextures.PROGRESS_BAR_BOILER_FUEL_BRONZE;
+
+        DoubleSyncValue progressPercent = syncManager.getOrCreateSyncHandler("progressPercent", DoubleSyncValue.class,
+                () -> new DoubleSyncValue(() -> {
+                    if (recipeLogic == null) return -1f;
+                    return recipeLogic.getProgressPercent();
+                }));
+
+        mainWidget.child(Flow.col()
+                .coverChildren()
+                .right(18).top(7)
+                .childPadding(4)
+                .reverseLayout(true)
+                .child(new ItemSlot()
+                        .slot(new ModularSlot(this.fuelHandler, 0)))
+                .child(new ProgressWidget()
+                        .size(18)
+                        .texture(progressTexture, 18)
+                        .value(progressPercent)
+                        .direction(ProgressWidget.Direction.UP))
+                .child(new ItemSlot()
+                        .slot(new ModularSlot(this.ashHandler, 0))));
     }
 }
diff --git a/src/main/java/com/gregtechceu/gtceu/common/machine/storage/BufferMachine.java b/src/main/java/com/gregtechceu/gtceu/common/machine/storage/BufferMachine.java
index dde00c951db..23f93c7517e 100644
--- a/src/main/java/com/gregtechceu/gtceu/common/machine/storage/BufferMachine.java
+++ b/src/main/java/com/gregtechceu/gtceu/common/machine/storage/BufferMachine.java
@@ -2,31 +2,29 @@
 
 import com.gregtechceu.gtceu.api.blockentity.BlockEntityCreationInfo;
 import com.gregtechceu.gtceu.api.capability.recipe.IO;
-import com.gregtechceu.gtceu.api.gui.GuiTextures;
-import com.gregtechceu.gtceu.api.gui.widget.SlotWidget;
-import com.gregtechceu.gtceu.api.gui.widget.TankWidget;
 import com.gregtechceu.gtceu.api.machine.TieredMachine;
-import com.gregtechceu.gtceu.api.machine.feature.IFancyUIMachine;
+import com.gregtechceu.gtceu.api.machine.feature.IMuiMachine;
 import com.gregtechceu.gtceu.api.machine.trait.NotifiableFluidTank;
 import com.gregtechceu.gtceu.api.machine.trait.NotifiableItemStackHandler;
 import com.gregtechceu.gtceu.api.sync_system.annotations.SaveField;
 import com.gregtechceu.gtceu.api.sync_system.annotations.SyncToClient;
 import com.gregtechceu.gtceu.common.machine.trait.AutoOutputTrait;
 
-import com.lowdragmc.lowdraglib.gui.widget.Widget;
-import com.lowdragmc.lowdraglib.gui.widget.WidgetGroup;
-
-import net.minecraft.MethodsReturnNonnullByDefault;
-
+import brachy.modularui.factory.PosGuiData;
+import brachy.modularui.screen.UISettings;
+import brachy.modularui.value.sync.PanelSyncManager;
+import brachy.modularui.value.sync.SyncHandlers;
+import brachy.modularui.widget.ParentWidget;
+import brachy.modularui.widgets.SlotGroupWidget;
+import brachy.modularui.widgets.slot.FluidSlot;
+import brachy.modularui.widgets.slot.ItemSlot;
+import brachy.modularui.widgets.slot.ModularSlot;
+import brachy.modularui.widgets.slot.SlotGroup;
 import lombok.Getter;
 
 import java.util.List;
 
-import javax.annotation.ParametersAreNonnullByDefault;
-
-@ParametersAreNonnullByDefault
-@MethodsReturnNonnullByDefault
-public class BufferMachine extends TieredMachine implements IFancyUIMachine {
+public class BufferMachine extends TieredMachine implements IMuiMachine {
 
     public static final int TANK_SIZE = 64000;
 
@@ -65,30 +63,32 @@ public static int getTankSize(int tier) {
     // ********** GUI *********** //
     ////////////////////////////////
 
+    // TODO MUI: Needs EIO widget
     @Override
-    public Widget createUIWidget() {
-        int invTier = getTankSize(tier);
-        var group = new WidgetGroup(0, 0, 18 * (invTier + 1) + 16, 18 * invTier + 16);
-        var container = new WidgetGroup(4, 4, 18 * (invTier + 1) + 8, 18 * invTier + 8);
-
-        int index = 0;
-        for (int y = 0; y < invTier; y++) {
-            for (int x = 0; x < invTier; x++) {
-                container.addWidget(new SlotWidget(
-                        getInventory().storage, index++, 4 + x * 18, 4 + y * 18, true, true)
-                        .setBackgroundTexture(GuiTextures.SLOT));
-            }
+    public void buildMainUI(ParentWidget<?> mainWidget, PosGuiData guiData, PanelSyncManager syncManager,
+                            UISettings settings) {
+        for (int i = 0; i < tank.getTanks(); i++) {
+            syncManager.syncValue("fluids", i, SyncHandlers.fluidSlot(tank.getStorages()[i]));
         }
 
-        index = 0;
-        for (int y = 0; y < invTier; y++) {
-            container.addWidget(new TankWidget(
-                    tank.getStorages()[index++], 4 + invTier * 18, 4 + y * 18, true, true)
-                    .setBackground(GuiTextures.FLUID_SLOT));
+        SlotGroup slotGroup = new SlotGroup("inventory", inventory.getSlots());
+
+        int size = tank.getTanks();
+        String[] matrix = new String[size];
+        for (int i = 0; i < size; i++) {
+            String row = "I".repeat(size) + "F";
+            matrix[i] = row;
         }
 
-        container.setBackground(GuiTextures.BACKGROUND_INVERSE);
-        group.addWidget(container);
-        return group;
+        SlotGroupWidget slotWidget = SlotGroupWidget.builder()
+                .matrix(matrix)
+                .key('I', i -> new ItemSlot()
+                        .slot(new ModularSlot(inventory, i)
+                                .slotGroup(slotGroup)))
+                .key('F', i -> new FluidSlot()
+                        .syncHandler("fluids", i))
+                .build();
+
+        mainWidget.child(slotWidget.center().margin(0, 10));
     }
 }
diff --git a/src/main/java/com/gregtechceu/gtceu/common/machine/storage/CrateMachine.java b/src/main/java/com/gregtechceu/gtceu/common/machine/storage/CrateMachine.java
index fdbe1f565bd..cbef1b6e39d 100644
--- a/src/main/java/com/gregtechceu/gtceu/common/machine/storage/CrateMachine.java
+++ b/src/main/java/com/gregtechceu/gtceu/common/machine/storage/CrateMachine.java
@@ -3,11 +3,9 @@
 import com.gregtechceu.gtceu.api.blockentity.BlockEntityCreationInfo;
 import com.gregtechceu.gtceu.api.capability.recipe.IO;
 import com.gregtechceu.gtceu.api.data.chemical.material.Material;
-import com.gregtechceu.gtceu.api.gui.GuiTextures;
-import com.gregtechceu.gtceu.api.gui.UITemplate;
-import com.gregtechceu.gtceu.api.gui.widget.SlotWidget;
 import com.gregtechceu.gtceu.api.machine.MetaMachine;
 import com.gregtechceu.gtceu.api.machine.feature.*;
+import com.gregtechceu.gtceu.api.machine.mui.MachineUIPanelBuilder;
 import com.gregtechceu.gtceu.api.machine.property.GTMachineModelProperties;
 import com.gregtechceu.gtceu.api.machine.trait.NotifiableItemStackHandler;
 import com.gregtechceu.gtceu.api.sync_system.annotations.RerenderOnChanged;
@@ -16,27 +14,29 @@
 import com.gregtechceu.gtceu.common.data.GTItems;
 import com.gregtechceu.gtceu.utils.ExtendedUseOnContext;
 
-import com.lowdragmc.lowdraglib.gui.modular.ModularUI;
-import com.lowdragmc.lowdraglib.gui.widget.LabelWidget;
-
-import net.minecraft.MethodsReturnNonnullByDefault;
 import net.minecraft.nbt.CompoundTag;
 import net.minecraft.world.InteractionResult;
-import net.minecraft.world.entity.player.Player;
 
+import brachy.modularui.api.drawable.IKey;
+import brachy.modularui.factory.PosGuiData;
+import brachy.modularui.screen.UISettings;
+import brachy.modularui.value.sync.PanelSyncManager;
+import brachy.modularui.value.sync.SyncHandlers;
+import brachy.modularui.widget.ParentWidget;
+import brachy.modularui.widgets.layout.Flow;
+import brachy.modularui.widgets.slot.ItemSlot;
 import lombok.Getter;
 
-import javax.annotation.ParametersAreNonnullByDefault;
-
-@ParametersAreNonnullByDefault
-@MethodsReturnNonnullByDefault
-public class CrateMachine extends MetaMachine implements IUIMachine, IDropSaveMachine {
+public class CrateMachine extends MetaMachine implements IMuiMachine,
+                          IDropSaveMachine {
 
     @Getter
     private final Material material;
     @Getter
     private final int inventorySize;
     @Getter
+    private final int rowLength;
+    @Getter
     @RerenderOnChanged
     @SaveField
     @SyncToClient
@@ -45,36 +45,44 @@ public class CrateMachine extends MetaMachine implements IUIMachine, IDropSaveMa
     @SaveField
     public final NotifiableItemStackHandler inventory;
 
-    public CrateMachine(BlockEntityCreationInfo info, Material material, int inventorySize) {
+    public CrateMachine(BlockEntityCreationInfo info, Material material, int inventorySize, int rowLength) {
         super(info);
         this.material = material;
         this.inventorySize = inventorySize;
+        this.rowLength = rowLength;
         this.inventory = attachTrait(new NotifiableItemStackHandler(inventorySize, IO.BOTH));
     }
 
     @Override
-    public ModularUI createUI(Player entityPlayer) {
-        int xOffset = inventorySize >= 90 ? 162 : 0;
-        int yOverflow = xOffset > 0 ? 18 : 9;
-        int yOffset = inventorySize > 3 * yOverflow ?
-                (inventorySize - 3 * yOverflow - (inventorySize - 3 * yOverflow) % yOverflow) / yOverflow * 18 : 0;
-        var modularUI = new ModularUI(176 + xOffset, 166 + yOffset, this, entityPlayer)
-                .background(GuiTextures.BACKGROUND)
-                .widget(new LabelWidget(5, 5, getBlockState().getBlock().getDescriptionId()))
-                .widget(UITemplate.bindPlayerInventory(entityPlayer.getInventory(), GuiTextures.SLOT, 7 + xOffset / 2,
-                        82 + yOffset, true));
-        int x = 0;
-        int y = 0;
-        for (int slot = 0; slot < inventorySize; slot++) {
-            modularUI.widget(new SlotWidget(inventory, slot, x * 18 + 7, y * 18 + 17)
-                    .setBackgroundTexture(GuiTextures.SLOT));
-            x++;
-            if (x == yOverflow) {
-                x = 0;
-                y++;
+    public MachineUIPanelBuilder getPanelBuilder(PosGuiData data, PanelSyncManager syncManager, UISettings settings) {
+        return MachineUIPanelBuilder.defaultPanelBuilder(this).addTitleBar(false);
+    }
+
+    @Override
+    public void buildMainUI(ParentWidget<?> mainWidget, PosGuiData guiData, PanelSyncManager syncManager,
+                            UISettings settings) {
+        syncManager.registerSlotGroup("item_inv", inventorySize);
+
+        int rows = inventorySize / rowLength;
+        ParentWidget<?> slots = new ParentWidget<>();
+        slots.coverChildren();
+        for (int i = 0; i < rows; i++) {
+            for (int j = 0; j < this.rowLength; j++) {
+                int index = i * rowLength + j;
+                slots.child(new ItemSlot()
+                        .slot(SyncHandlers.itemSlot(inventory, index).slotGroup("item_inv"))
+                        .left(18 * j)
+                        .top(18 * i));
             }
         }
-        return modularUI;
+
+        var col = Flow.col()
+                .margin(5, 5, 0, 5)
+                .coverChildren();
+        col.child(
+                IKey.lang(getBlockState().getBlock().getName()).asWidget().leftRel(0).margin(0, 0, 3, 3))
+                .child(slots.height(rows * 18));
+        mainWidget.child(col);
     }
 
     @Override
diff --git a/src/main/java/com/gregtechceu/gtceu/common/machine/storage/CreativeChestMachine.java b/src/main/java/com/gregtechceu/gtceu/common/machine/storage/CreativeChestMachine.java
index 5c80cfe9db5..73c3a46bff5 100644
--- a/src/main/java/com/gregtechceu/gtceu/common/machine/storage/CreativeChestMachine.java
+++ b/src/main/java/com/gregtechceu/gtceu/common/machine/storage/CreativeChestMachine.java
@@ -2,22 +2,31 @@
 
 import com.gregtechceu.gtceu.api.GTValues;
 import com.gregtechceu.gtceu.api.blockentity.BlockEntityCreationInfo;
-import com.gregtechceu.gtceu.api.gui.GuiTextures;
-import com.gregtechceu.gtceu.api.gui.widget.PhantomSlotWidget;
+import com.gregtechceu.gtceu.api.machine.mui.MachineUIPanel;
+import com.gregtechceu.gtceu.api.machine.mui.MachineUIPanelBuilder;
 import com.gregtechceu.gtceu.api.sync_system.annotations.SaveField;
+import com.gregtechceu.gtceu.common.mui.GTMuiWidgets;
 import com.gregtechceu.gtceu.utils.ExtendedUseOnContext;
 import com.gregtechceu.gtceu.utils.GTUtil;
 
-import com.lowdragmc.lowdraglib.gui.texture.GuiTextureGroup;
-import com.lowdragmc.lowdraglib.gui.texture.ResourceBorderTexture;
-import com.lowdragmc.lowdraglib.gui.texture.TextTexture;
-import com.lowdragmc.lowdraglib.gui.widget.*;
-
 import net.minecraft.nbt.CompoundTag;
 import net.minecraft.world.InteractionResult;
 import net.minecraft.world.item.ItemStack;
 import net.minecraftforge.items.ItemHandlerHelper;
 
+import brachy.modularui.api.drawable.IKey;
+import brachy.modularui.drawable.Rectangle;
+import brachy.modularui.factory.PosGuiData;
+import brachy.modularui.screen.UISettings;
+import brachy.modularui.utils.Alignment;
+import brachy.modularui.value.sync.IntSyncValue;
+import brachy.modularui.value.sync.PanelSyncManager;
+import brachy.modularui.value.sync.PhantomItemSlotSyncHandler;
+import brachy.modularui.widget.ParentWidget;
+import brachy.modularui.widgets.layout.Flow;
+import brachy.modularui.widgets.slot.ModularSlot;
+import brachy.modularui.widgets.slot.PhantomItemSlot;
+import brachy.modularui.widgets.textfield.TextFieldWidget;
 import lombok.Getter;
 
 public class CreativeChestMachine extends QuantumChestMachine {
@@ -47,16 +56,14 @@ private InteractionResult updateStored(ItemStack item) {
         return InteractionResult.SUCCESS;
     }
 
-    private void setTicksPerCycle(String value) {
-        if (value.isEmpty()) return;
-        ticksPerCycle = Integer.parseInt(value);
+    private void setTicksPerCycle(int value) {
+        ticksPerCycle = value;
         autoOutput.setTicksPerCycle(ticksPerCycle);
         onItemChanged();
     }
 
-    private void setItemsPerCycle(String value) {
-        if (value.isEmpty()) return;
-        itemsPerCycle = Integer.parseInt(value);
+    private void setItemsPerCycle(int value) {
+        itemsPerCycle = value;
         onItemChanged();
     }
 
@@ -95,32 +102,59 @@ public InteractionResult onUseWithItem(ExtendedUseOnContext context) {
     }
 
     @Override
-    public Widget createUIWidget() {
-        var group = new WidgetGroup(0, 0, 176, 131);
-        group.addWidget(new PhantomSlotWidget(cache, 0, 36, 6)
-                .setClearSlotOnRightClick(true)
-                .setMaxStackSize(1)
-                .setBackgroundTexture(GuiTextures.SLOT));
-        group.addWidget(new LabelWidget(7, 9, "gtceu.creative.chest.item"));
-        group.addWidget(new ImageWidget(7, 48, 154, 14, GuiTextures.DISPLAY));
-        group.addWidget(new TextFieldWidget(9, 50, 152, 10, () -> String.valueOf(itemsPerCycle), this::setItemsPerCycle)
-                .setMaxStringLength(11)
-                .setNumbersOnly(1, Integer.MAX_VALUE));
-        group.addWidget(new LabelWidget(7, 28, "gtceu.creative.chest.ipc"));
-        group.addWidget(new ImageWidget(7, 85, 154, 14, GuiTextures.DISPLAY));
-        group.addWidget(new TextFieldWidget(9, 87, 152, 10, () -> String.valueOf(ticksPerCycle), this::setTicksPerCycle)
-                .setMaxStringLength(11)
-                .setNumbersOnly(1, Integer.MAX_VALUE));
-        group.addWidget(new LabelWidget(7, 65, "gtceu.creative.chest.tpc"));
-        group.addWidget(new SwitchWidget(7, 101, 162, 20, (clickData, value) -> setWorkingEnabled(value))
-                .setTexture(
-                        new GuiTextureGroup(ResourceBorderTexture.BUTTON_COMMON,
-                                new TextTexture("gtceu.creative.activity.off")),
-                        new GuiTextureGroup(ResourceBorderTexture.BUTTON_COMMON,
-                                new TextTexture("gtceu.creative.activity.on")))
-                .setPressed(isWorkingEnabled()));
-
-        return group;
+    public MachineUIPanelBuilder getPanelBuilder(PosGuiData data, PanelSyncManager syncManager, UISettings settings) {
+        return MachineUIPanelBuilder.defaultPanelBuilder(this).addDefaultConfigurators(false)
+                .addTraitConfigurators(false).rightConfigurators(f -> f.child(GTMuiWidgets.createPowerButton(this)));
+    }
+
+    @Override
+    public void buildMainUI(ParentWidget<?> mainWidget, PosGuiData guiData, PanelSyncManager syncManager,
+                            UISettings settings) {
+        PhantomItemSlotSyncHandler storedSlot = new PhantomItemSlotSyncHandler(new ModularSlot(cache, 0).filter(
+                stack -> stored.isEmpty() || ItemStack.isSameItemSameTags(stack, stored)));
+
+        syncManager.syncValue("stored", storedSlot);
+
+        IntSyncValue itemsPerCycle = new IntSyncValue(this::getItemsPerCycle, this::setItemsPerCycle);
+        syncManager.syncValue("itemsPerCycle", itemsPerCycle);
+        IntSyncValue ticksPerCycle = new IntSyncValue(this::getTicksPerCycle, this::setTicksPerCycle);
+        syncManager.syncValue("ticksPerCycle", ticksPerCycle);
+
+        mainWidget
+                .child(Flow.col()
+                        .size(MachineUIPanel.DEFAULT_CONTENT_WIDTH, 86)
+                        .name("main")
+                        .padding(7)
+                        .mainAxisAlignment(Alignment.MainAxis.START)
+                        .child(Flow.row().coverChildrenHeight()
+                                .child(IKey.lang("gtceu.creative.chest.item").asWidget()
+                                        .marginRight(4)
+                                        .verticalCenter())
+                                .child(new PhantomItemSlot().syncHandler("stored")))
+                        .child(new Rectangle().color(0xFF555555).asWidget()
+                                .height(1).widthRel(0.95f).marginBottom(4).marginTop(4))
+                        .child(Flow.row()
+                                .height(18)
+                                .child(IKey.lang("gtceu.creative.chest.ipc").asWidget()
+                                        .marginRight(4)
+                                        .width(80)
+                                        .verticalCenter())
+                                .child(new TextFieldWidget()
+                                        .setTextAlignment(Alignment.CENTER)
+                                        .setNumbers(1, Integer.MAX_VALUE)
+                                        .value(itemsPerCycle)))
+                        .child(new Rectangle().color(0xFF555555).asWidget()
+                                .height(1).widthRel(0.95f).marginBottom(4).marginTop(4))
+                        .child(Flow.row()
+                                .height(18)
+                                .child(IKey.lang("gtceu.creative.chest.tpc").asWidget()
+                                        .marginRight(4)
+                                        .width(80)
+                                        .verticalCenter())
+                                .child(new TextFieldWidget()
+                                        .setTextAlignment(Alignment.CENTER)
+                                        .setNumbers(1, Integer.MAX_VALUE)
+                                        .value(ticksPerCycle))));
     }
 
     private class InfiniteCache extends ItemCache {
diff --git a/src/main/java/com/gregtechceu/gtceu/common/machine/storage/CreativeComputationProviderMachine.java b/src/main/java/com/gregtechceu/gtceu/common/machine/storage/CreativeComputationProviderMachine.java
index a036dbc4db6..fb007f5d3d1 100644
--- a/src/main/java/com/gregtechceu/gtceu/common/machine/storage/CreativeComputationProviderMachine.java
+++ b/src/main/java/com/gregtechceu/gtceu/common/machine/storage/CreativeComputationProviderMachine.java
@@ -1,26 +1,27 @@
 package com.gregtechceu.gtceu.common.machine.storage;
 
 import com.gregtechceu.gtceu.api.blockentity.BlockEntityCreationInfo;
+import com.gregtechceu.gtceu.api.capability.IControllable;
 import com.gregtechceu.gtceu.api.capability.IOpticalComputationProvider;
-import com.gregtechceu.gtceu.api.gui.GuiTextures;
 import com.gregtechceu.gtceu.api.machine.MetaMachine;
 import com.gregtechceu.gtceu.api.machine.TickableSubscription;
-import com.gregtechceu.gtceu.api.machine.feature.IUIMachine;
+import com.gregtechceu.gtceu.api.machine.feature.IMuiMachine;
+import com.gregtechceu.gtceu.api.machine.mui.MachineUIPanelBuilder;
 import com.gregtechceu.gtceu.api.sync_system.annotations.SaveField;
 
-import com.lowdragmc.lowdraglib.gui.modular.ModularUI;
-import com.lowdragmc.lowdraglib.gui.texture.GuiTextureGroup;
-import com.lowdragmc.lowdraglib.gui.texture.ResourceBorderTexture;
-import com.lowdragmc.lowdraglib.gui.texture.TextTexture;
-import com.lowdragmc.lowdraglib.gui.widget.LabelWidget;
-import com.lowdragmc.lowdraglib.gui.widget.SwitchWidget;
-import com.lowdragmc.lowdraglib.gui.widget.TextFieldWidget;
-
 import net.minecraft.MethodsReturnNonnullByDefault;
-import net.minecraft.world.entity.player.Player;
 
+import brachy.modularui.api.drawable.IKey;
+import brachy.modularui.drawable.Rectangle;
+import brachy.modularui.factory.PosGuiData;
+import brachy.modularui.screen.UISettings;
+import brachy.modularui.value.sync.IntSyncValue;
+import brachy.modularui.value.sync.PanelSyncManager;
+import brachy.modularui.widget.ParentWidget;
+import brachy.modularui.widgets.TextWidget;
+import brachy.modularui.widgets.layout.Flow;
+import brachy.modularui.widgets.textfield.TextFieldWidget;
 import lombok.Getter;
-import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 
 import java.util.Collection;
@@ -30,7 +31,7 @@
 @ParametersAreNonnullByDefault
 @MethodsReturnNonnullByDefault
 public class CreativeComputationProviderMachine extends MetaMachine
-                                                implements IUIMachine, IOpticalComputationProvider {
+                                                implements IMuiMachine, IOpticalComputationProvider, IControllable {
 
     @SaveField
     private int maxCWUt;
@@ -38,7 +39,7 @@ public class CreativeComputationProviderMachine extends MetaMachine
     private int requestedCWUPerSec;
     @SaveField
     @Getter
-    private boolean active;
+    private boolean workingEnabled;
     @Nullable
     private TickableSubscription computationSubs;
 
@@ -53,7 +54,7 @@ public void onLoad() {
     }
 
     protected void updateComputationSubscription() {
-        if (active) {
+        if (workingEnabled) {
             this.computationSubs = subscribeServerTick(this::updateComputationTick);
         } else if (computationSubs != null) {
             computationSubs.unsubscribe();
@@ -72,9 +73,9 @@ protected void updateComputationTick() {
 
     @Override
     public int requestCWUt(
-                           int cwut, boolean simulate, @NotNull Collection<IOpticalComputationProvider> seen) {
+                           int cwut, boolean simulate, Collection<IOpticalComputationProvider> seen) {
         seen.add(this);
-        int requestedCWUt = active ? Math.min(cwut, maxCWUt) : 0;
+        int requestedCWUt = workingEnabled ? Math.min(cwut, maxCWUt) : 0;
         if (!simulate) {
             this.requestedCWUPerSec += requestedCWUt;
         }
@@ -82,36 +83,49 @@ public int requestCWUt(
     }
 
     @Override
-    public int getMaxCWUt(@NotNull Collection<IOpticalComputationProvider> seen) {
+    public int getMaxCWUt(Collection<IOpticalComputationProvider> seen) {
         seen.add(this);
-        return active ? maxCWUt : 0;
+        return workingEnabled ? maxCWUt : 0;
     }
 
     @Override
-    public boolean canBridge(@NotNull Collection<IOpticalComputationProvider> seen) {
+    public boolean canBridge(Collection<IOpticalComputationProvider> seen) {
         seen.add(this);
         return true;
     }
 
-    public void setActive(boolean active) {
-        this.active = active;
+    public void setWorkingEnabled(boolean workingEnabled) {
+        this.workingEnabled = workingEnabled;
         updateComputationSubscription();
     }
 
     @Override
-    public ModularUI createUI(Player entityPlayer) {
-        return new ModularUI(140, 95, this, entityPlayer)
-                .background(GuiTextures.BACKGROUND)
-                .widget(new LabelWidget(7, 7, "CWUt"))
-                .widget(new TextFieldWidget(9, 20, 122, 16, () -> String.valueOf(maxCWUt),
-                        value -> maxCWUt = Integer.parseInt(value)).setNumbersOnly(0, Integer.MAX_VALUE))
-                .widget(new LabelWidget(7, 42, "gtceu.creative.computation.average"))
-                .widget(new LabelWidget(7, 54, () -> String.valueOf(lastRequestedCWUt)))
-                .widget(new SwitchWidget(9, 66, 122, 20, (clickData, value) -> setActive(value))
-                        .setSupplier(this::isActive)
-                        .setTexture(new GuiTextureGroup(ResourceBorderTexture.BUTTON_COMMON,
-                                new TextTexture("gtceu.creative.activity.off")),
-                                new GuiTextureGroup(ResourceBorderTexture.BUTTON_COMMON,
-                                        new TextTexture("gtceu.creative.activity.on"))));
+    public MachineUIPanelBuilder getPanelBuilder(PosGuiData data, PanelSyncManager syncManager, UISettings settings) {
+        return MachineUIPanelBuilder.defaultPanelBuilder(this).attachInventory(false);
+    }
+
+    @Override
+    public void buildMainUI(ParentWidget<?> mainWidget, PosGuiData guiData, PanelSyncManager syncManager,
+                            UISettings settings) {
+        mainWidget
+                .child(Flow.column()
+                        .padding(10)
+                        .childPadding(5)
+                        .child(Flow.row()
+                                .leftRel(0)
+                                .childPadding(5)
+                                .coverChildren()
+                                .child(new TextWidget<>(IKey.lang("gtceu.creative.computation.max_usage")))
+                                .child(new TextFieldWidget()
+                                        .setNumbers(0, Integer.MAX_VALUE)
+                                        .value(new IntSyncValue(() -> maxCWUt, (v) -> maxCWUt = v))))
+                        .child(new Rectangle().color(0xFF555555).asWidget()
+                                .height(1).widthRel(0.95f).marginBottom(4).marginTop(4))
+                        .child(Flow.row()
+                                .leftRel(0)
+                                .childPadding(5)
+                                .coverChildren()
+                                .child(new TextWidget<>(IKey.lang("gtceu.creative.computation.average",
+                                        () -> new Object[] { lastRequestedCWUt })))));
     }
 }
diff --git a/src/main/java/com/gregtechceu/gtceu/common/machine/storage/CreativeEnergyContainerMachine.java b/src/main/java/com/gregtechceu/gtceu/common/machine/storage/CreativeEnergyContainerMachine.java
index 0d01cb995ed..7da0cd9a184 100644
--- a/src/main/java/com/gregtechceu/gtceu/common/machine/storage/CreativeEnergyContainerMachine.java
+++ b/src/main/java/com/gregtechceu/gtceu/common/machine/storage/CreativeEnergyContainerMachine.java
@@ -3,35 +3,53 @@
 import com.gregtechceu.gtceu.api.GTValues;
 import com.gregtechceu.gtceu.api.blockentity.BlockEntityCreationInfo;
 import com.gregtechceu.gtceu.api.capability.GTCapabilityHelper;
+import com.gregtechceu.gtceu.api.capability.IControllable;
 import com.gregtechceu.gtceu.api.capability.IEnergyContainer;
 import com.gregtechceu.gtceu.api.capability.ILaserContainer;
-import com.gregtechceu.gtceu.api.gui.GuiTextures;
 import com.gregtechceu.gtceu.api.machine.TieredMachine;
-import com.gregtechceu.gtceu.api.machine.feature.IUIMachine;
+import com.gregtechceu.gtceu.api.machine.feature.IMuiMachine;
+import com.gregtechceu.gtceu.api.machine.mui.MachineUIPanel;
+import com.gregtechceu.gtceu.api.machine.mui.MachineUIPanelBuilder;
 import com.gregtechceu.gtceu.api.sync_system.annotations.SaveField;
 import com.gregtechceu.gtceu.utils.GTUtil;
 
-import com.lowdragmc.lowdraglib.gui.editor.ColorPattern;
-import com.lowdragmc.lowdraglib.gui.modular.ModularUI;
-import com.lowdragmc.lowdraglib.gui.texture.GuiTextureGroup;
-import com.lowdragmc.lowdraglib.gui.texture.ResourceBorderTexture;
-import com.lowdragmc.lowdraglib.gui.texture.TextTexture;
-import com.lowdragmc.lowdraglib.gui.widget.*;
-
 import net.minecraft.MethodsReturnNonnullByDefault;
 import net.minecraft.core.Direction;
-import net.minecraft.world.entity.player.Player;
+import net.minecraft.network.chat.Component;
 import net.minecraft.world.level.Level;
 
-import org.apache.commons.lang3.ArrayUtils;
-
-import java.util.Arrays;
+import brachy.modularui.api.IPanelHandler;
+import brachy.modularui.api.drawable.IDrawable;
+import brachy.modularui.api.drawable.IKey;
+import brachy.modularui.drawable.DynamicDrawable;
+import brachy.modularui.drawable.GuiTextures;
+import brachy.modularui.drawable.Rectangle;
+import brachy.modularui.factory.PosGuiData;
+import brachy.modularui.screen.ModularPanel;
+import brachy.modularui.screen.RichTooltip;
+import brachy.modularui.screen.UISettings;
+import brachy.modularui.utils.Alignment;
+import brachy.modularui.utils.MouseData;
+import brachy.modularui.value.sync.BooleanSyncValue;
+import brachy.modularui.value.sync.IntSyncValue;
+import brachy.modularui.value.sync.LongSyncValue;
+import brachy.modularui.value.sync.PanelSyncManager;
+import brachy.modularui.widget.ParentWidget;
+import brachy.modularui.widgets.ButtonWidget;
+import brachy.modularui.widgets.Dialog;
+import brachy.modularui.widgets.ListWidget;
+import brachy.modularui.widgets.ToggleButton;
+import brachy.modularui.widgets.layout.Flow;
+import brachy.modularui.widgets.textfield.TextFieldWidget;
+import lombok.Getter;
+import lombok.Setter;
 
 import javax.annotation.ParametersAreNonnullByDefault;
 
 @ParametersAreNonnullByDefault
 @MethodsReturnNonnullByDefault
-public class CreativeEnergyContainerMachine extends TieredMachine implements ILaserContainer, IUIMachine {
+public class CreativeEnergyContainerMachine extends TieredMachine
+                                            implements ILaserContainer, IMuiMachine, IControllable {
 
     @SaveField
     private long voltage = 0;
@@ -40,7 +58,9 @@ public class CreativeEnergyContainerMachine extends TieredMachine implements ILa
     @SaveField
     private int setTier = 0;
     @SaveField
-    private boolean active = false;
+    @Getter
+    @Setter
+    private boolean workingEnabled = false;
     @SaveField
     private boolean source = true;
     @SaveField
@@ -79,7 +99,7 @@ protected void updateEnergyTick() {
             }
         }
         ampsReceived = 0;
-        if (!active || !source || voltage <= 0 || amps <= 0) return;
+        if (!workingEnabled || !source || voltage <= 0 || amps <= 0) return;
         int ampsUsed = 0;
         for (var facing : GTUtil.DIRECTIONS) {
             var opposite = facing.getOpposite();
@@ -102,7 +122,7 @@ protected void updateEnergyTick() {
 
     @Override
     public long acceptEnergyFromNetwork(Direction side, long voltage, long amperage) {
-        if (source || !active || ampsReceived >= amps) {
+        if (source || !workingEnabled || ampsReceived >= amps) {
             return 0;
         }
         if (voltage > this.voltage) {
@@ -132,7 +152,7 @@ public boolean outputsEnergy(Direction side) {
 
     @Override
     public long changeEnergy(long differenceAmount) {
-        if (source || !active) {
+        if (source || !workingEnabled) {
             return 0;
         }
         energyIOPerSec += differenceAmount;
@@ -180,62 +200,171 @@ public void setIOSpeed(long energyIOPerSec) {
     //////////////////////////////////////
 
     @Override
-    public ModularUI createUI(Player entityPlayer) {
-        return new ModularUI(176, 166, this, entityPlayer)
-                .background(GuiTextures.BACKGROUND)
-                .widget(new LabelWidget(7, 32, "gtceu.creative.energy.voltage"))
-                .widget(new TextFieldWidget(9, 47, 152, 16, () -> String.valueOf(voltage),
-                        value -> {
-                            voltage = Long.parseLong(value);
-                            setTier = GTUtil.getTierByVoltage(voltage);
-                        }).setNumbersOnly(0L, Long.MAX_VALUE))
-                .widget(new LabelWidget(7, 74, "gtceu.creative.energy.amperage"))
-                .widget(new ButtonWidget(7, 87, 20, 20,
-                        new GuiTextureGroup(ResourceBorderTexture.BUTTON_COMMON, new TextTexture("-")),
-                        cd -> amps = --amps == -1 ? 0 : amps))
-                .widget(new TextFieldWidget(31, 89, 114, 16, () -> String.valueOf(amps),
-                        value -> amps = Integer.parseInt(value)).setNumbersOnly(0, Integer.MAX_VALUE))
-                .widget(new ButtonWidget(149, 87, 20, 20,
-                        new GuiTextureGroup(ResourceBorderTexture.BUTTON_COMMON, new TextTexture("+")),
-                        cd -> {
-                            if (amps < Integer.MAX_VALUE) {
-                                amps++;
+    public MachineUIPanelBuilder getPanelBuilder(PosGuiData data, PanelSyncManager syncManager, UISettings settings) {
+        return MachineUIPanelBuilder.defaultPanelBuilder(this).attachInventory(false);
+    }
+
+    @Override
+    public void buildMainUI(ParentWidget<?> mainWidget, PosGuiData guiData, PanelSyncManager syncManager,
+                            UISettings settings) {
+        // syncing
+        LongSyncValue voltage = new LongSyncValue(() -> this.voltage, (v) -> this.voltage = v);
+        IntSyncValue amps = new IntSyncValue(() -> this.amps, (a) -> this.amps = Math.max(a, 1));
+        IntSyncValue tier = new IntSyncValue(() -> this.tier, (t) -> this.setTier = t);
+        BooleanSyncValue sourceSync = new BooleanSyncValue(() -> this.source, (b) -> this.source = b);
+        syncManager.syncValue("tier", tier);
+
+        IPanelHandler panelSyncHandler = syncManager.syncedPanel("voltage popup", false,
+                (manager, handler) -> createAmpSelector(voltage, tier));
+
+        mainWidget
+                .child(Flow.col()
+                        .size(MachineUIPanel.DEFAULT_CONTENT_WIDTH, 101)
+                        .name("main")
+                        .padding(7)
+                        .mainAxisAlignment(Alignment.MainAxis.START)
+                        .child(createVoltageRow(panelSyncHandler, voltage))
+                        .child(createAmpRow(amps))
+                        .child(new Rectangle().color(0xFF555555).asWidget()
+                                .height(1).widthRel(0.95f).marginBottom(4).marginTop(4))
+                        .child(createSourceSelector(sourceSync)));
+    }
+
+    private Flow createVoltageRow(IPanelHandler panel, LongSyncValue voltage) {
+        return Flow.row()
+                .height(18)
+                .marginBottom(4)
+                .child(IKey.str("Voltage").asWidget()
+                        .marginRight(4)
+                        .width(50)
+                        .verticalCenter())
+                .child(new TextFieldWidget()
+                        .setTextAlignment(Alignment.CENTER)
+                        .setNumbersLong(() -> 1, () -> Long.MAX_VALUE)
+                        .value(voltage))
+                .child(new ButtonWidget<>()
+                        .height(18)
+                        .width(40)
+                        .overlay(IKey.dynamic(
+                                () -> Component.literal(GTValues.VNF[GTUtil.getTierByVoltage(voltage.getLongValue())]))
+                                .shadow(true))
+
+                        // .width(32)
+                        .marginLeft(4)
+                        .tooltip(new RichTooltip().add("Click to Change Tier"))
+                        .onMousePressed((a, b, c) -> {
+                            if (panel.isPanelOpen()) {
+                                panel.closePanel();
+                            } else {
+                                panel.openPanel();
                             }
+                            return true;
+                        })
+
+                );
+    }
+
+    static Flow createAmpRow(IntSyncValue amps) {
+        return Flow.row()
+                .coverChildrenHeight()
+                .child(IKey.lang("gtceu.creative.energy.amperage").asWidget()
+                        .marginRight(4)
+                        .verticalCenter().width(50))
+                .child(
+                        new TextFieldWidget()
+                                .setTextAlignment(Alignment.CENTER)
+                                .setNumbers(1, Integer.MAX_VALUE)
+                                .value(amps)
+                                .setDefaultNumber(1))
+                .child(new ButtonWidget<>()
+                        .overlay(new DynamicDrawable(() -> {
+                            MouseData mouseData = MouseData.create(-1);
+                            if (mouseData.shift()) {
+                                return IKey.str("1/2x");
+                            } else if (mouseData.ctrl()) {
+                                return IKey.str("4x");
+                            } else {
+                                return IKey.str("2x");
+                            }
+
                         }))
-                .widget(new LabelWidget(7, 110,
-                        () -> "Average Energy I/O per tick: " + this.lastAverageEnergyIOPerTick))
-                .widget(new SwitchWidget(7, 139, 77, 20, (clickData, value) -> active = value)
-                        .setTexture(
-                                new GuiTextureGroup(ResourceBorderTexture.BUTTON_COMMON,
-                                        new TextTexture("gtceu.creative.activity.off")),
-                                new GuiTextureGroup(ResourceBorderTexture.BUTTON_COMMON,
-                                        new TextTexture("gtceu.creative.activity.on")))
-                        .setPressed(active))
-                .widget(new SwitchWidget(85, 139, 77, 20, (clickData, value) -> {
-                    source = value;
-                    if (source) {
-                        voltage = 0;
-                        amps = 0;
-                        setTier = 0;
-                    } else {
-                        voltage = GTValues.V[14];
-                        amps = Integer.MAX_VALUE;
-                        setTier = 14;
-                    }
-                }).setTexture(
-                        new GuiTextureGroup(ResourceBorderTexture.BUTTON_COMMON,
-                                new TextTexture("gtceu.creative.energy.sink")),
-                        new GuiTextureGroup(ResourceBorderTexture.BUTTON_COMMON,
-                                new TextTexture("gtceu.creative.energy.source")))
-                        .setPressed(source))
-                .widget(new SelectorWidget(7, 7, 50, 20, Arrays.stream(GTValues.VNF).toList(), -1)
-                        .setOnChanged(tier -> {
-                            setTier = ArrayUtils.indexOf(GTValues.VNF, tier);
-                            voltage = GTValues.VEX[setTier];
+                        .width(40)
+                        .height(18)
+                        .tooltip(new RichTooltip().addLine("Click to Double Amperage")
+                                .addLine("Shift to half current Amperage"))
+                        .onMousePressed((a, b, c) -> {
+                            MouseData mouseData = MouseData.create(c);
+                            if (mouseData.shift()) {
+                                amps.setValue(amps.getValue() / 2);
+                            } else if (mouseData.ctrl()) {
+                                amps.setValue(amps.getValue() * 4);
+                            } else {
+                                amps.setValue(amps.getValue() * 2);
+                            }
+                            return true;
                         })
-                        .setSupplier(() -> GTValues.VNF[setTier])
-                        .setButtonBackground(ResourceBorderTexture.BUTTON_COMMON)
-                        .setBackground(ColorPattern.BLACK.rectTexture())
-                        .setValue(GTValues.VNF[setTier]));
+                        .marginLeft(4));
+    }
+
+    private Flow createSourceSelector(BooleanSyncValue sourceSync) {
+        return Flow.column()
+                .coverChildrenHeight()
+                .child(Flow.row()
+                        .coverChildrenHeight()
+                        .name("button")
+                        .childPadding(2)
+                        .child(new ToggleButton()
+                                .overlay(new DynamicDrawable(() -> {
+                                    if (sourceSync.getValue()) {
+                                        return GuiTextures.CHECK_BOX.getSubArea(0, .5f, 1, 1f);
+                                    }
+                                    return IDrawable.EMPTY;
+                                }))
+                                .value(sourceSync))
+                        .child(IKey.lang("gtceu.creative.energy.source").asWidget())
+                        .paddingBottom(2))
+                .child(Flow.row()
+                        .coverChildrenHeight()
+                        .name("button")
+                        .coverChildrenHeight()
+                        .childPadding(2)
+                        .child(new ToggleButton()
+                                .overlay(new DynamicDrawable(() -> {
+                                    if (!sourceSync.getValue()) {
+                                        return GuiTextures.CHECK_BOX.getSubArea(0, .5f, 1, 1f);
+                                    }
+                                    return IDrawable.EMPTY;
+                                }))
+                                .value(new BooleanSyncValue(() -> !source, bool -> source = !bool)))
+                        .child(IKey.lang("gtceu.creative.energy.sink").asWidget()));
+    }
+
+    private ModularPanel<?> createAmpSelector(LongSyncValue voltage, IntSyncValue tier) {
+        return new Dialog<>("amp_selector")
+                .disablePanelsBelow(false)
+                .draggable(true)
+                .closeOnOutOfBoundsClick(true)
+                .width(72)
+                .height(104)
+                .child(Flow.column()
+                        .child(IKey.lang("gtceu.top.cable_voltage").asWidget().top(4).left(3))
+                        .child(new Rectangle().color(0xFF555555).asWidget()
+                                .height(1).widthRel(0.80f).horizontalCenter().top(19))
+                        .child(new ListWidget<>()
+                                .widthRel(1.0f)
+                                .height(120)
+                                .maxSize(80)
+                                .crossAxisAlignment(Alignment.CrossAxis.CENTER)
+                                .children(GTValues.TIER_COUNT, v -> new ButtonWidget<>()
+                                        .width(36)
+                                        .overlay(IKey.lang(Component.literal(GTValues.VNF[v])))
+                                        .onMousePressed((x, y, b) -> {
+                                            voltage.setValue(GTValues.V[v]);
+                                            tier.setValue(v);
+                                            return true;
+                                        }))
+                                .top(20))
+                        .child(new Rectangle().color(0xFF555555).asWidget()
+                                .height(1).widthRel(0.80f).horizontalCenter().top(99)));
     }
 }
diff --git a/src/main/java/com/gregtechceu/gtceu/common/machine/storage/CreativeTankMachine.java b/src/main/java/com/gregtechceu/gtceu/common/machine/storage/CreativeTankMachine.java
index 59edfa7ab41..f5002fd56ea 100644
--- a/src/main/java/com/gregtechceu/gtceu/common/machine/storage/CreativeTankMachine.java
+++ b/src/main/java/com/gregtechceu/gtceu/common/machine/storage/CreativeTankMachine.java
@@ -2,17 +2,14 @@
 
 import com.gregtechceu.gtceu.api.GTValues;
 import com.gregtechceu.gtceu.api.blockentity.BlockEntityCreationInfo;
-import com.gregtechceu.gtceu.api.gui.GuiTextures;
-import com.gregtechceu.gtceu.api.gui.widget.PhantomFluidWidget;
+import com.gregtechceu.gtceu.api.machine.mui.MachineUIPanel;
+import com.gregtechceu.gtceu.api.machine.mui.MachineUIPanelBuilder;
 import com.gregtechceu.gtceu.api.sync_system.annotations.SaveField;
 import com.gregtechceu.gtceu.api.transfer.fluid.CustomFluidTank;
+import com.gregtechceu.gtceu.common.mui.GTGuiTextures;
+import com.gregtechceu.gtceu.common.mui.GTMuiWidgets;
 import com.gregtechceu.gtceu.utils.ExtendedUseOnContext;
 
-import com.lowdragmc.lowdraglib.gui.texture.GuiTextureGroup;
-import com.lowdragmc.lowdraglib.gui.texture.ResourceBorderTexture;
-import com.lowdragmc.lowdraglib.gui.texture.TextTexture;
-import com.lowdragmc.lowdraglib.gui.widget.*;
-
 import net.minecraft.nbt.CompoundTag;
 import net.minecraft.world.InteractionResult;
 import net.minecraft.world.item.ItemStack;
@@ -20,6 +17,18 @@
 import net.minecraftforge.fluids.FluidUtil;
 import net.minecraftforge.items.ItemHandlerHelper;
 
+import brachy.modularui.api.drawable.IKey;
+import brachy.modularui.drawable.Rectangle;
+import brachy.modularui.factory.PosGuiData;
+import brachy.modularui.screen.UISettings;
+import brachy.modularui.utils.Alignment;
+import brachy.modularui.value.sync.FluidSlotSyncHandler;
+import brachy.modularui.value.sync.IntSyncValue;
+import brachy.modularui.value.sync.PanelSyncManager;
+import brachy.modularui.widget.ParentWidget;
+import brachy.modularui.widgets.layout.Flow;
+import brachy.modularui.widgets.slot.FluidSlot;
+import brachy.modularui.widgets.textfield.TextFieldWidget;
 import lombok.Getter;
 
 public class CreativeTankMachine extends QuantumTankMachine {
@@ -56,15 +65,14 @@ private InteractionResult updateStored(FluidStack fluid) {
         return InteractionResult.SUCCESS;
     }
 
-    private void setTicksPerCycle(String value) {
-        if (value.isEmpty()) return;
-        ticksPerCycle = Integer.parseInt(value);
+    private void setTicksPerCycle(int value) {
+        ticksPerCycle = value;
+        autoOutput.setTicksPerCycle(value);
         onFluidChanged();
     }
 
-    private void setmBPerCycle(String value) {
-        if (value.isEmpty()) return;
-        mBPerCycle = Integer.parseInt(value);
+    private void setmBPerCycle(int value) {
+        mBPerCycle = value;
         onFluidChanged();
     }
 
@@ -127,31 +135,59 @@ public InteractionResult onUse(ExtendedUseOnContext context) {
     }
 
     @Override
-    public WidgetGroup createUIWidget() {
-        var group = new WidgetGroup(0, 0, 176, 131);
-        group.addWidget(new PhantomFluidWidget(cache, 0, 36, 6, 18, 18, this::getStored, this::updateStored)
-                .setShowAmount(false)
-                .setBackground(GuiTextures.FLUID_SLOT));
-        group.addWidget(new LabelWidget(7, 9, "gtceu.creative.tank.fluid"));
-        group.addWidget(new ImageWidget(7, 45, 154, 14, GuiTextures.DISPLAY));
-        group.addWidget(new TextFieldWidget(9, 47, 152, 10, () -> String.valueOf(mBPerCycle), this::setmBPerCycle)
-                .setMaxStringLength(11)
-                .setNumbersOnly(1, Integer.MAX_VALUE));
-        group.addWidget(new LabelWidget(7, 28, "gtceu.creative.tank.mbpc"));
-        group.addWidget(new ImageWidget(7, 82, 154, 14, GuiTextures.DISPLAY));
-        group.addWidget(new TextFieldWidget(9, 84, 152, 10, () -> String.valueOf(ticksPerCycle), this::setTicksPerCycle)
-                .setMaxStringLength(11)
-                .setNumbersOnly(1, Integer.MAX_VALUE));
-        group.addWidget(new LabelWidget(7, 65, "gtceu.creative.tank.tpc"));
-        group.addWidget(new SwitchWidget(7, 101, 162, 20, (clickData, value) -> setWorkingEnabled(value))
-                .setTexture(
-                        new GuiTextureGroup(ResourceBorderTexture.BUTTON_COMMON,
-                                new TextTexture("gtceu.creative.activity.off")),
-                        new GuiTextureGroup(ResourceBorderTexture.BUTTON_COMMON,
-                                new TextTexture("gtceu.creative.activity.on")))
-                .setPressed(isWorkingEnabled()));
-
-        return group;
+    public MachineUIPanelBuilder getPanelBuilder(PosGuiData data, PanelSyncManager syncManager, UISettings settings) {
+        return MachineUIPanelBuilder.defaultPanelBuilder(this).addDefaultConfigurators(false)
+                .addTraitConfigurators(false).rightConfigurators(f -> f.child(GTMuiWidgets.createPowerButton(this)));
+    }
+
+    // TODO
+    @Override
+    public void buildMainUI(ParentWidget<?> mainWidget, PosGuiData guiData, PanelSyncManager syncManager,
+                            UISettings settings) {
+        syncManager.syncValue("fluid",
+                new FluidSlotSyncHandler(new FluidCacheTankWrapper(cache)).controlsAmount(false).phantom(true));
+
+        IntSyncValue mbPerCycle = new IntSyncValue(this::getMBPerCycle, this::setmBPerCycle);
+        syncManager.syncValue("mbPerCycle", mbPerCycle);
+        IntSyncValue ticksPerCycle = new IntSyncValue(this::getTicksPerCycle, this::setTicksPerCycle);
+        syncManager.syncValue("ticksPerCycle", ticksPerCycle);
+
+        mainWidget
+                .child(Flow.col()
+                        .size(MachineUIPanel.DEFAULT_CONTENT_WIDTH, 86)
+                        .name("main")
+                        .padding(7)
+                        .mainAxisAlignment(Alignment.MainAxis.START)
+                        .child(Flow.row().coverChildrenHeight()
+                                .child(IKey.lang("gtceu.creative.tank.fluid").asWidget()
+                                        .marginRight(4)
+                                        .verticalCenter())
+                                .child(new FluidSlot().syncHandler("locked_fluid_slot", 0)
+                                        .background(GTGuiTextures.FLUID_SLOT)))
+                        .child(new Rectangle().color(0xFF555555).asWidget()
+                                .height(1).widthRel(0.95f).marginBottom(4).marginTop(4))
+                        .child(Flow.row()
+                                .height(18)
+                                .child(IKey.lang("gtceu.creative.tank.mbpc").asWidget()
+                                        .marginRight(4)
+                                        .width(80)
+                                        .verticalCenter())
+                                .child(new TextFieldWidget()
+                                        .setTextAlignment(Alignment.CENTER)
+                                        .setNumbers(1, Integer.MAX_VALUE)
+                                        .value(mbPerCycle)))
+                        .child(new Rectangle().color(0xFF555555).asWidget()
+                                .height(1).widthRel(0.95f).marginBottom(4).marginTop(4))
+                        .child(Flow.row()
+                                .height(18)
+                                .child(IKey.lang("gtceu.creative.tank.tpc").asWidget()
+                                        .marginRight(4)
+                                        .width(80)
+                                        .verticalCenter())
+                                .child(new TextFieldWidget()
+                                        .setTextAlignment(Alignment.CENTER)
+                                        .setNumbers(1, Integer.MAX_VALUE)
+                                        .value(ticksPerCycle))));
     }
 
     private class InfiniteCache extends FluidCache {
diff --git a/src/main/java/com/gregtechceu/gtceu/common/machine/storage/QuantumChestMachine.java b/src/main/java/com/gregtechceu/gtceu/common/machine/storage/QuantumChestMachine.java
index 4b2093c9793..9e30398d8a6 100644
--- a/src/main/java/com/gregtechceu/gtceu/common/machine/storage/QuantumChestMachine.java
+++ b/src/main/java/com/gregtechceu/gtceu/common/machine/storage/QuantumChestMachine.java
@@ -3,14 +3,10 @@
 import com.gregtechceu.gtceu.api.blockentity.BlockEntityCreationInfo;
 import com.gregtechceu.gtceu.api.capability.IControllable;
 import com.gregtechceu.gtceu.api.capability.recipe.IO;
-import com.gregtechceu.gtceu.api.gui.GuiTextures;
-import com.gregtechceu.gtceu.api.gui.widget.PhantomSlotWidget;
-import com.gregtechceu.gtceu.api.gui.widget.SlotWidget;
-import com.gregtechceu.gtceu.api.gui.widget.ToggleButtonWidget;
 import com.gregtechceu.gtceu.api.item.tool.GTToolType;
 import com.gregtechceu.gtceu.api.machine.TieredMachine;
 import com.gregtechceu.gtceu.api.machine.feature.IDropSaveMachine;
-import com.gregtechceu.gtceu.api.machine.feature.IFancyUIMachine;
+import com.gregtechceu.gtceu.api.machine.feature.IMuiMachine;
 import com.gregtechceu.gtceu.api.machine.trait.MachineTrait;
 import com.gregtechceu.gtceu.api.machine.trait.MachineTraitType;
 import com.gregtechceu.gtceu.api.sync_system.annotations.SaveField;
@@ -18,17 +14,14 @@
 import com.gregtechceu.gtceu.api.transfer.fluid.IFluidHandlerModifiable;
 import com.gregtechceu.gtceu.api.transfer.item.CustomItemStackHandler;
 import com.gregtechceu.gtceu.common.machine.trait.AutoOutputTrait;
+import com.gregtechceu.gtceu.common.mui.GTGuiTextures;
+import com.gregtechceu.gtceu.common.mui.GTMuiWidgets;
 import com.gregtechceu.gtceu.utils.*;
 
-import com.lowdragmc.lowdraglib.gui.editor.Icons;
-import com.lowdragmc.lowdraglib.gui.texture.GuiTextureGroup;
-import com.lowdragmc.lowdraglib.gui.texture.ResourceBorderTexture;
-import com.lowdragmc.lowdraglib.gui.texture.ResourceTexture;
-import com.lowdragmc.lowdraglib.gui.widget.*;
-
 import net.minecraft.core.BlockPos;
 import net.minecraft.core.Direction;
 import net.minecraft.nbt.CompoundTag;
+import net.minecraft.network.chat.Component;
 import net.minecraft.world.InteractionHand;
 import net.minecraft.world.InteractionResult;
 import net.minecraft.world.entity.player.Player;
@@ -39,8 +32,21 @@
 import net.minecraftforge.items.IItemHandlerModifiable;
 import net.minecraftforge.items.ItemHandlerHelper;
 
+import brachy.modularui.api.drawable.IKey;
+import brachy.modularui.api.widget.IWidget;
+import brachy.modularui.drawable.UITexture;
+import brachy.modularui.factory.PosGuiData;
+import brachy.modularui.screen.UISettings;
+import brachy.modularui.value.sync.*;
+import brachy.modularui.widget.ParentWidget;
+import brachy.modularui.widgets.layout.Flow;
+import brachy.modularui.widgets.slot.ItemSlot;
+import brachy.modularui.widgets.slot.ModularSlot;
+import brachy.modularui.widgets.slot.PhantomItemSlot;
+import brachy.modularui.widgets.slot.SlotGroup;
 import it.unimi.dsi.fastutil.objects.Object2LongOpenHashMap;
 import lombok.Getter;
+import lombok.Setter;
 import org.jetbrains.annotations.Nullable;
 
 import java.util.Set;
@@ -48,7 +54,7 @@
 import java.util.function.Predicate;
 
 public class QuantumChestMachine extends TieredMachine implements IControllable,
-                                 IDropSaveMachine, IFancyUIMachine {
+                                 IDropSaveMachine, IMuiMachine {
 
     /**
      * Sourced from FunctionalStorage's
@@ -59,6 +65,8 @@ public class QuantumChestMachine extends TieredMachine implements IControllable,
     public static final Object2LongOpenHashMap<UUID> INTERACTION_LOGGER = new Object2LongOpenHashMap<>();
 
     @SaveField
+    @Getter
+    @Setter
     private boolean isVoiding;
 
     private final long maxAmount;
@@ -237,72 +245,68 @@ public ItemStack getLockedItem() {
     // *********** GUI ***********//
     //////////////////////////////////////
 
-    public Widget createUIWidget() {
-        var group = new WidgetGroup(0, 0, 109, 63);
-        var importItems = createImportItems();
-        group.addWidget(new ImageWidget(4, 4, 81, 55, GuiTextures.DISPLAY))
-                .addWidget(new LabelWidget(8, 8, "gtceu.machine.quantum_chest.items_stored"))
-                .addWidget(new LabelWidget(8, 18, () -> FormattingUtil.formatNumbers(storedAmount))
-                        .setTextColor(-1)
-                        .setDropShadow(true))
-                .addWidget(new SlotWidget(importItems, 0, 87, 5, false, true)
-                        .setBackgroundTexture(new GuiTextureGroup(GuiTextures.SLOT, GuiTextures.IN_SLOT_OVERLAY)))
-                .addWidget(new SlotWidget(cache, 0, 87, 23, false, false)
-                        .setItemHook(s -> s.copyWithCount((int) Math.min(storedAmount, s.getMaxStackSize())))
-                        .setBackgroundTexture(GuiTextures.SLOT))
-                .addWidget(new ButtonWidget(87, 42, 18, 18,
-                        new GuiTextureGroup(ResourceBorderTexture.BUTTON_COMMON, Icons.DOWN.scale(0.7f)), cd -> {
-                            if (!cd.isRemote) {
-                                if (!stored.isEmpty()) {
-                                    var extracted = cache.extractItem(0,
-                                            (int) Math.min(storedAmount, stored.getMaxStackSize()), false);
-                                    if (!group.getGui().entityPlayer.addItem(extracted)) {
-                                        Block.popResource(group.getGui().entityPlayer.level(),
-                                                group.getGui().entityPlayer.getOnPos(), extracted);
-                                    }
-                                }
-                            }
-                        }))
-                .addWidget(new PhantomSlotWidget(lockedItem, 0, 58, 41,
-                        stack -> stored.isEmpty() || GTUtil.isSameItemSameTags(stack, stored))
-                        .setMaxStackSize(1))
-                .addWidget(new ToggleButtonWidget(4, 41, 18, 18,
-                        GuiTextures.BUTTON_ITEM_OUTPUT, this.autoOutput::isAutoOutputItems,
-                        this.autoOutput::setAllowAutoOutputItems)
-                        .setShouldUseBaseBackground()
-                        .setTooltipText("gtceu.gui.item_auto_output.tooltip"))
-                .addWidget(new ToggleButtonWidget(22, 41, 18, 18,
-                        GuiTextures.BUTTON_LOCK, this::isLocked, this::setLocked)
-                        .setShouldUseBaseBackground()
-                        .setTooltipText("gtceu.gui.item_lock.tooltip"))
-                .addWidget(new ToggleButtonWidget(40, 41, 18, 18,
-                        GuiTextures.BUTTON_VOID, () -> isVoiding, (b) -> isVoiding = b)
-                        .setShouldUseBaseBackground()
-                        .setTooltipText("gtceu.gui.item_voiding_partial.tooltip"));
-        group.setBackground(GuiTextures.BACKGROUND_INVERSE);
-        return group;
+    @Override
+    public void buildMainUI(ParentWidget<?> mainWidget, PosGuiData guiData, PanelSyncManager syncManager,
+                            UISettings settings) {
+        LongSyncValue itemSyncer = new LongSyncValue(this::getStoredAmount, (ignored) -> {});
+        syncManager.syncValue("item_amount", itemSyncer);
+        // SlotGroup group = new SlotGroup("item_inv", 1, 0, true);
+
+        mainWidget
+                .child(new ParentWidget<>()
+                        .background(GTGuiTextures.DISPLAY)
+                        .size(90, 63)
+                        .center()
+                        .child(IKey.lang("gtceu.machine.quantum_chest.items_stored").asWidget()
+                                .color(0xffffff)
+                                .margin(8, 0, 8, 0))
+                        .child(IKey.dynamic(
+                                () -> Component.literal(
+                                        FormattingUtil.formatNumbers(itemSyncer.getLongValue())))
+                                .asWidget()
+                                .color(0xffffff)
+                                .margin(8, 0, 18, 0))
+                        .child(Flow.row()
+                                .margin(4, 0, 41, 0)
+                                .coverChildren()
+                                .child(GTMuiWidgets.createAutoOutputItemButton(autoOutput))
+                                .child(GTMuiWidgets.createToggleButton(this::isLocked, this::setLocked,
+                                        GTGuiTextures.BUTTON_LOCK, "gtceu.gui.item_lock.tooltip"))
+                                .child(GTMuiWidgets.createToggleButton(this::isVoiding, this::setVoiding,
+                                        GTGuiTextures.BUTTON_VOID, "gtceu.gui.item_voiding_partial.tooltip")))
+                        .child(Flow.column()
+                                .margin(68, 0, 15, 0)
+                                .coverChildren()
+                                .child(createItemSlot(syncManager))
+                                .child(createPhantomLockeditemSlot(syncManager)))
+
+                );
     }
 
-    private CustomItemStackHandler createImportItems() {
-        var importItems = new CustomItemStackHandler();
-        importItems.setFilter(cache::canInsert);
-        importItems.setOnContentsChanged(() -> {
-            var item = importItems.getStackInSlot(0).copy();
-            if (!item.isEmpty()) {
-                importItems.setStackInSlot(0, ItemStack.EMPTY);
-                importItems.onContentsChanged(0);
-                cache.insertItem(0, item.copy(), false);
-            }
-        });
-        return importItems;
+    private IWidget createItemSlot(PanelSyncManager syncManager) {
+        ItemSlotSyncHandler slot = new ItemSlotSyncHandler(new ModularSlot(cache, 0)
+                .ignoreMaxStackSize(true)
+                .slotGroup(new SlotGroup("stored", 1, true)));
+        syncManager.syncValue("stored", 1, slot);
+
+        return new ItemSlot().syncHandler("stored", 1);
+    }
+
+    private IWidget createPhantomLockeditemSlot(PanelSyncManager syncManager) {
+        lockedItem.setOnContentsChanged(() -> lockedItem.getStackInSlot(0).setCount(1));
+        PhantomItemSlotSyncHandler lockSlot = new PhantomItemSlotSyncHandler(new ModularSlot(lockedItem, 0).filter(
+                stack -> stored.isEmpty() || ItemStack.isSameItemSameTags(stack, stored)));
+
+        syncManager.syncValue("lock", lockSlot);
+        return new PhantomItemSlot().syncHandler("lock");
     }
 
     //////////////////////////////////////
     // ******* Rendering ********//
     //////////////////////////////////////
     @Override
-    public @Nullable ResourceTexture sideTips(Player player, BlockPos pos, BlockState state, Set<GTToolType> toolTypes,
-                                              Direction side) {
+    public @Nullable UITexture sideTips(Player player, BlockPos pos, BlockState state, Set<GTToolType> toolTypes,
+                                        Direction side) {
         if (toolTypes.contains(GTToolType.SOFT_MALLET)) {
             if (side == getFrontFacing()) return null;
         }
diff --git a/src/main/java/com/gregtechceu/gtceu/common/machine/storage/QuantumTankMachine.java b/src/main/java/com/gregtechceu/gtceu/common/machine/storage/QuantumTankMachine.java
index 7ab09a37106..92820e6eb70 100644
--- a/src/main/java/com/gregtechceu/gtceu/common/machine/storage/QuantumTankMachine.java
+++ b/src/main/java/com/gregtechceu/gtceu/common/machine/storage/QuantumTankMachine.java
@@ -3,13 +3,9 @@
 import com.gregtechceu.gtceu.api.blockentity.BlockEntityCreationInfo;
 import com.gregtechceu.gtceu.api.capability.IControllable;
 import com.gregtechceu.gtceu.api.capability.recipe.IO;
-import com.gregtechceu.gtceu.api.gui.GuiTextures;
-import com.gregtechceu.gtceu.api.gui.widget.PhantomFluidWidget;
-import com.gregtechceu.gtceu.api.gui.widget.TankWidget;
-import com.gregtechceu.gtceu.api.gui.widget.ToggleButtonWidget;
 import com.gregtechceu.gtceu.api.machine.*;
 import com.gregtechceu.gtceu.api.machine.feature.IDropSaveMachine;
-import com.gregtechceu.gtceu.api.machine.feature.IFancyUIMachine;
+import com.gregtechceu.gtceu.api.machine.feature.IMuiMachine;
 import com.gregtechceu.gtceu.api.machine.trait.MachineTrait;
 import com.gregtechceu.gtceu.api.machine.trait.MachineTraitType;
 import com.gregtechceu.gtceu.api.sync_system.annotations.SaveField;
@@ -17,38 +13,50 @@
 import com.gregtechceu.gtceu.api.transfer.fluid.CustomFluidTank;
 import com.gregtechceu.gtceu.api.transfer.fluid.IFluidHandlerModifiable;
 import com.gregtechceu.gtceu.common.machine.trait.AutoOutputTrait;
+import com.gregtechceu.gtceu.common.mui.GTGuiTextures;
+import com.gregtechceu.gtceu.common.mui.GTMuiWidgets;
 import com.gregtechceu.gtceu.utils.ExtendedUseOnContext;
 import com.gregtechceu.gtceu.utils.FormattingUtil;
 import com.gregtechceu.gtceu.utils.GTMath;
 import com.gregtechceu.gtceu.utils.GTTransferUtils;
 
-import com.lowdragmc.lowdraglib.gui.editor.ColorPattern;
-import com.lowdragmc.lowdraglib.gui.widget.ImageWidget;
-import com.lowdragmc.lowdraglib.gui.widget.LabelWidget;
-import com.lowdragmc.lowdraglib.gui.widget.Widget;
-import com.lowdragmc.lowdraglib.gui.widget.WidgetGroup;
-
 import net.minecraft.core.Direction;
 import net.minecraft.nbt.CompoundTag;
+import net.minecraft.network.chat.Component;
 import net.minecraft.world.InteractionResult;
 import net.minecraftforge.fluids.FluidStack;
 import net.minecraftforge.fluids.FluidUtil;
+import net.minecraftforge.fluids.IFluidTank;
 import net.minecraftforge.fluids.capability.IFluidHandler;
 import net.minecraftforge.items.IItemHandlerModifiable;
 
+import brachy.modularui.api.drawable.IKey;
+import brachy.modularui.api.widget.IWidget;
+import brachy.modularui.factory.PosGuiData;
+import brachy.modularui.screen.UISettings;
+import brachy.modularui.value.sync.FluidSlotSyncHandler;
+import brachy.modularui.value.sync.LongSyncValue;
+import brachy.modularui.value.sync.PanelSyncManager;
+import brachy.modularui.value.sync.SyncHandlers;
+import brachy.modularui.widget.ParentWidget;
+import brachy.modularui.widgets.layout.Flow;
+import brachy.modularui.widgets.slot.FluidSlot;
 import it.unimi.dsi.fastutil.objects.Object2LongArrayMap;
 import it.unimi.dsi.fastutil.objects.Object2LongMap;
 import lombok.Getter;
+import lombok.Setter;
 import org.jetbrains.annotations.Nullable;
 
 import java.util.function.Predicate;
 
 public class QuantumTankMachine extends TieredMachine implements IControllable,
-                                IDropSaveMachine, IFancyUIMachine {
+                                IDropSaveMachine, IMuiMachine {
 
     public static Object2LongMap<MachineDefinition> TANK_CAPACITY = new Object2LongArrayMap<>();
 
     @SaveField
+    @Getter
+    @Setter
     private boolean isVoiding;
 
     @Getter
@@ -193,35 +201,52 @@ public void loadFromItem(CompoundTag tag) {
     //////////////////////////////////////
     // *********** GUI ***********//
     //////////////////////////////////////
-    public Widget createUIWidget() {
-        var group = new WidgetGroup(0, 0, 90, 63);
-        group.addWidget(new ImageWidget(4, 4, 82, 55, GuiTextures.DISPLAY))
-                .addWidget(new LabelWidget(8, 8, "gtceu.gui.fluid_amount"))
-                .addWidget(new LabelWidget(8, 18, () -> FormattingUtil.formatBuckets(storedAmount))
-                        .setTextColor(-1)
-                        .setDropShadow(false))
-                .addWidget(new TankWidget(cache, 0, 68, 23, true, true)
-                        .setShowAmount(false)
-                        .setBackground(GuiTextures.FLUID_SLOT))
-                .addWidget(new PhantomFluidWidget(lockedFluid, 0, 68, 41, 18, 18,
-                        this::getLockedFluid, this::setLocked)
-                        .setShowAmount(false)
-                        .setBackground(ColorPattern.T_GRAY.rectTexture()))
-                .addWidget(new ToggleButtonWidget(4, 41, 18, 18,
-                        GuiTextures.BUTTON_FLUID_OUTPUT, this.autoOutput::isAutoOutputFluids,
-                        this.autoOutput::setAllowAutoOutputFluids)
-                        .setShouldUseBaseBackground()
-                        .setTooltipText("gtceu.gui.fluid_auto_output.tooltip"))
-                .addWidget(new ToggleButtonWidget(22, 41, 18, 18,
-                        GuiTextures.BUTTON_LOCK, this::isLocked, this::setLocked)
-                        .setShouldUseBaseBackground()
-                        .setTooltipText("gtceu.gui.fluid_lock.tooltip"))
-                .addWidget(new ToggleButtonWidget(40, 41, 18, 18,
-                        GuiTextures.BUTTON_VOID, () -> isVoiding, (b) -> isVoiding = b)
-                        .setShouldUseBaseBackground()
-                        .setTooltipText("gtceu.gui.fluid_voiding_partial.tooltip"));
-        group.setBackground(GuiTextures.BACKGROUND_INVERSE);
-        return group;
+    // TODO: Needs AOI widget
+    @Override
+    public void buildMainUI(ParentWidget<?> mainWidget, PosGuiData guiData, PanelSyncManager syncManager,
+                            UISettings settings) {
+        LongSyncValue bucketSyncer = new LongSyncValue(this::getStoredAmount, (ignored) -> {});
+        syncManager.syncValue("bucket_amount", bucketSyncer);
+
+        mainWidget
+                .child(new ParentWidget<>()
+                        .background(GTGuiTextures.DISPLAY)
+                        .size(90, 63)
+                        .center()
+                        .child(IKey.lang("gtceu.gui.fluid_amount").asWidget()
+                                .color(0xffffff)
+                                .margin(8, 0, 8, 0))
+                        .child(IKey.dynamic(
+                                () -> Component.literal(
+                                        FormattingUtil.formatBuckets(bucketSyncer.getLongValue())))
+                                .asWidget()
+                                .color(0xffffff)
+                                .margin(8, 0, 18, 0))
+                        .child(Flow.row()
+                                .margin(4, 0, 41, 0)
+                                .coverChildren()
+                                .child(GTMuiWidgets.createAutoOutputFluidButton(autoOutput))
+                                .child(GTMuiWidgets.createToggleButton(this::isLocked, this::setLocked,
+                                        GTGuiTextures.BUTTON_LOCK, "gtceu.gui.fluid_lock.tooltip"))
+                                .child(GTMuiWidgets.createToggleButton(this::isVoiding, this::setVoiding,
+                                        GTGuiTextures.BUTTON_VOID, "gtceu.gui.fluid_voiding_partial.tooltip")))
+                        .child(Flow.column()
+                                .margin(68, 0, 23, 0)
+                                .coverChildren()
+                                .child(createFluidSlot(syncManager))
+                                .child(createPhantomLockedFluidSlot(syncManager))));
+    }
+
+    private IWidget createFluidSlot(PanelSyncManager syncManager) {
+        syncManager.syncValue("fluid_slot",
+                SyncHandlers.fluidSlot(new FluidCacheTankWrapper(cache)).controlsAmount(false));
+        return new FluidSlot().syncHandler("fluid_slot", 0).background(GTGuiTextures.FLUID_SLOT);
+    }
+
+    private IWidget createPhantomLockedFluidSlot(PanelSyncManager syncManager) {
+        syncManager.syncValue("locked_fluid_slot",
+                new FluidSlotSyncHandler(lockedFluid).controlsAmount(false).phantom(true));
+        return new FluidSlot().syncHandler("locked_fluid_slot", 0).background(GTGuiTextures.FLUID_SLOT);
     }
 
     protected class FluidCache extends MachineTrait implements IFluidHandler {
@@ -304,4 +329,48 @@ public void exportToNearby(Direction... facings) {
             }
         }
     }
+
+    protected class FluidCacheTankWrapper implements IFluidTank {
+
+        private final FluidCache cache;
+
+        public FluidCacheTankWrapper(FluidCache cache) {
+            this.cache = cache;
+        }
+
+        @Override
+        public FluidStack getFluid() {
+            return cache.getFluidInTank(0);
+        }
+
+        @Override
+        public int getFluidAmount() {
+            return cache.getFluidInTank(0).getAmount();
+        }
+
+        @Override
+        public int getCapacity() {
+            return cache.getTankCapacity(0);
+        }
+
+        @Override
+        public boolean isFluidValid(FluidStack fluidStack) {
+            return cache.isFluidValid(0, fluidStack);
+        }
+
+        @Override
+        public int fill(FluidStack fluidStack, IFluidHandler.FluidAction fluidAction) {
+            return cache.fill(fluidStack, fluidAction);
+        }
+
+        @Override
+        public FluidStack drain(int i, IFluidHandler.FluidAction fluidAction) {
+            return cache.drain(i, fluidAction);
+        }
+
+        @Override
+        public FluidStack drain(FluidStack fluidStack, IFluidHandler.FluidAction fluidAction) {
+            return cache.drain(fluidStack, fluidAction);
+        }
+    }
 }
diff --git a/src/main/java/com/gregtechceu/gtceu/common/machine/trait/AutoOutputTrait.java b/src/main/java/com/gregtechceu/gtceu/common/machine/trait/AutoOutputTrait.java
index 693d0539ea5..12670ed989f 100644
--- a/src/main/java/com/gregtechceu/gtceu/common/machine/trait/AutoOutputTrait.java
+++ b/src/main/java/com/gregtechceu/gtceu/common/machine/trait/AutoOutputTrait.java
@@ -1,10 +1,10 @@
 package com.gregtechceu.gtceu.common.machine.trait;
 
 import com.gregtechceu.gtceu.api.capability.recipe.IO;
-import com.gregtechceu.gtceu.api.gui.GuiTextures;
 import com.gregtechceu.gtceu.api.item.tool.GTToolType;
 import com.gregtechceu.gtceu.api.machine.TickableSubscription;
 import com.gregtechceu.gtceu.api.machine.trait.*;
+import com.gregtechceu.gtceu.api.machine.trait.feature.IAttachConfiguratorsTrait;
 import com.gregtechceu.gtceu.api.machine.trait.feature.IFrontFacingTrait;
 import com.gregtechceu.gtceu.api.machine.trait.feature.IInteractionTrait;
 import com.gregtechceu.gtceu.api.machine.trait.feature.IRenderingTrait;
@@ -12,12 +12,12 @@
 import com.gregtechceu.gtceu.api.sync_system.annotations.SaveField;
 import com.gregtechceu.gtceu.api.sync_system.annotations.SyncToClient;
 import com.gregtechceu.gtceu.common.item.tool.behavior.ToolModeSwitchBehavior;
+import com.gregtechceu.gtceu.common.mui.GTGuiTextures;
+import com.gregtechceu.gtceu.common.mui.GTMuiWidgets;
 import com.gregtechceu.gtceu.utils.ExtendedUseOnContext;
 import com.gregtechceu.gtceu.utils.GTTransferUtils;
 import com.gregtechceu.gtceu.utils.ISubscription;
 
-import com.lowdragmc.lowdraglib.gui.texture.ResourceTexture;
-
 import net.minecraft.core.BlockPos;
 import net.minecraft.core.Direction;
 import net.minecraft.network.chat.Component;
@@ -31,6 +31,10 @@
 import net.minecraftforge.fluids.capability.IFluidHandler;
 import net.minecraftforge.items.IItemHandler;
 
+import brachy.modularui.drawable.UITexture;
+import brachy.modularui.screen.ModularPanel;
+import brachy.modularui.value.sync.PanelSyncManager;
+import brachy.modularui.widgets.layout.Flow;
 import com.mojang.datafixers.util.Pair;
 import lombok.Getter;
 import lombok.Setter;
@@ -44,7 +48,8 @@
 
 import static com.gregtechceu.gtceu.api.item.tool.ToolHelper.getBehaviorsTag;
 
-public class AutoOutputTrait extends MachineTrait implements IRenderingTrait, IInteractionTrait, IFrontFacingTrait {
+public class AutoOutputTrait extends MachineTrait implements IRenderingTrait, IInteractionTrait, IFrontFacingTrait,
+                             IAttachConfiguratorsTrait {
 
     public static final MachineTraitType<AutoOutputTrait> TYPE = new MachineTraitType<>(AutoOutputTrait.class);
 
@@ -301,8 +306,16 @@ public boolean shouldRenderGridOverlay(Player player, BlockPos pos, BlockState s
     }
 
     @Override
-    public @Nullable ResourceTexture getGridOverlayIcon(Player player, BlockPos pos, BlockState state,
-                                                        Set<GTToolType> toolTypes, Direction side) {
+    public void attachRightConfigurators(Flow flow, ModularPanel<?> panel, PanelSyncManager syncManager) {
+        flow.childIf(supportsAutoOutputItems(), () -> GTMuiWidgets.createAutoOutputItemButton(this))
+                .childIf(supportsAutoOutputFluids(), () -> GTMuiWidgets.createAutoOutputFluidButton(this))
+                .childIf(supportsAutoOutputItems(), () -> GTMuiWidgets.createInputFromOutputItem(this))
+                .childIf(supportsAutoOutputFluids(), () -> GTMuiWidgets.createInputFromOutputFluid(this));
+    }
+
+    @Override
+    public @Nullable UITexture getGridOverlayIcon(Player player, BlockPos pos, BlockState state,
+                                                  Set<GTToolType> toolTypes, Direction side) {
         if (toolTypes.contains(GTToolType.WRENCH)) {
             if (!player.isShiftKeyDown()) {
                 if (!getMachine().hasFrontFacing() || side != getMachine().getFrontFacing()) {
@@ -311,14 +324,14 @@ public boolean shouldRenderGridOverlay(Player player, BlockPos pos, BlockState s
                     var canSwitchFluidOutputToSide = supportsAutoOutputFluids() &&
                             fluidOutputDirectionValidator.test(side) && side != getFluidOutputDirection();
                     if (canSwitchItemOutputToSide || canSwitchFluidOutputToSide)
-                        return GuiTextures.TOOL_IO_FACING_ROTATION;
+                        return GTGuiTextures.TOOL_IO_FACING_ROTATION;
                 }
             }
         }
         if (toolTypes.contains(GTToolType.SCREWDRIVER)) {
             if (side == getItemOutputDirection() || side == getFluidOutputDirection()) {
-                if (player.isShiftKeyDown()) return GuiTextures.TOOL_ALLOW_INPUT;
-                return GuiTextures.TOOL_AUTO_OUTPUT;
+                if (player.isShiftKeyDown()) return GTGuiTextures.TOOL_ALLOW_INPUT;
+                return GTGuiTextures.TOOL_AUTO_OUTPUT;
             }
         }
         return null;
diff --git a/src/main/java/com/gregtechceu/gtceu/common/machine/trait/miner/MinerLogic.java b/src/main/java/com/gregtechceu/gtceu/common/machine/trait/miner/MinerLogic.java
index b1af429b9ef..50c03ed6a50 100644
--- a/src/main/java/com/gregtechceu/gtceu/common/machine/trait/miner/MinerLogic.java
+++ b/src/main/java/com/gregtechceu/gtceu/common/machine/trait/miner/MinerLogic.java
@@ -12,6 +12,7 @@
 import com.gregtechceu.gtceu.api.recipe.GTRecipe;
 import com.gregtechceu.gtceu.api.recipe.RecipeHelper;
 import com.gregtechceu.gtceu.api.sync_system.annotations.SaveField;
+import com.gregtechceu.gtceu.api.sync_system.annotations.SyncToClient;
 import com.gregtechceu.gtceu.api.transfer.item.NotifiableAccountedInvWrapper;
 import com.gregtechceu.gtceu.common.data.GTBlocks;
 import com.gregtechceu.gtceu.common.data.GTMaterialItems;
@@ -64,12 +65,15 @@ public class MinerLogic extends RecipeLogic implements IRecipeCapabilityHolder {
     private int blocksToMineOriginalCount = 0;
     @Getter
     @SaveField
+    @SyncToClient
     protected int x = Integer.MAX_VALUE;
     @Getter
     @SaveField
+    @SyncToClient
     protected int y = Integer.MAX_VALUE;
     @Getter
     @SaveField
+    @SyncToClient
     protected int z = Integer.MAX_VALUE;
     @Getter
     @SaveField
@@ -85,12 +89,15 @@ public class MinerLogic extends RecipeLogic implements IRecipeCapabilityHolder {
     protected int pipeY = Integer.MAX_VALUE;
     @Getter
     @SaveField
+    @SyncToClient
     protected int mineX = Integer.MAX_VALUE;
     @Getter
     @SaveField
+    @SyncToClient
     protected int mineZ = Integer.MAX_VALUE;
     @Getter
     @SaveField
+    @SyncToClient
     protected int mineY = Integer.MAX_VALUE;
     @Getter
     private int minBuildHeight = Integer.MAX_VALUE;
@@ -105,8 +112,10 @@ public class MinerLogic extends RecipeLogic implements IRecipeCapabilityHolder {
     private int currentRadius;
     @Getter
     @SaveField
+    @SyncToClient
     private boolean isDone;
     @Getter
+    @SyncToClient
     private boolean isInventoryFull;
     @Getter
     private final Map<IO, List<RecipeHandlerList>> capabilitiesProxy;
@@ -276,6 +285,9 @@ public void serverTick() {
                 x = mineX;
                 y = mineY;
                 z = mineZ;
+                syncDataHolder.markClientSyncFieldDirty("x");
+                syncDataHolder.markClientSyncFieldDirty("y");
+                syncDataHolder.markClientSyncFieldDirty("z");
 
                 // attempt to get more blocks to mine, if there are none, the miner is done mining
                 blocksToMine.addAll(getBlocksToMine());
@@ -439,6 +451,9 @@ private void mineAndInsertItems(NonNullList<ItemStack> blockDrops, ServerLevel w
             mineX = pos.getX();
             mineZ = pos.getZ();
             mineY = pos.getY();
+            syncDataHolder.markClientSyncFieldDirty("mineX");
+            syncDataHolder.markClientSyncFieldDirty("mineY");
+            syncDataHolder.markClientSyncFieldDirty("mineZ");
             blocksToMine.removeFirst();
             onMineOperation();
 
@@ -459,11 +474,15 @@ private void mineAndInsertItems(NonNullList<ItemStack> blockDrops, ServerLevel w
     public void initPos(BlockPos pos, int currentRadius) {
         x = pos.getX() - currentRadius;
         z = pos.getZ() - currentRadius;
+        syncDataHolder.markClientSyncFieldDirty("x");
+        syncDataHolder.markClientSyncFieldDirty("z");
+
         if (dir == Direction.UP) {
             y = pos.getY() + 1;
         } else {
             y = pos.getY() - 1;
         }
+        syncDataHolder.markClientSyncFieldDirty("y");
         startX = pos.getX() - currentRadius;
         startZ = pos.getZ() - currentRadius;
         startY = pos.getY();
@@ -474,12 +493,14 @@ public void initPos(BlockPos pos, int currentRadius) {
         }
         mineX = pos.getX() - currentRadius;
         mineZ = pos.getZ() - currentRadius;
+        syncDataHolder.markClientSyncFieldDirty("mineX");
+        syncDataHolder.markClientSyncFieldDirty("mineZ");
         if (dir == Direction.UP) {
             mineY = pos.getY() + 1;
         } else {
             mineY = pos.getY() - 1;
         }
-
+        syncDataHolder.markClientSyncFieldDirty("mineY");
         removePipes();
     }
 
@@ -566,6 +587,9 @@ private LinkedList<BlockPos> getBlocksToMine() {
                         --y;
                     }
                 }
+                syncDataHolder.markClientSyncFieldDirty("x");
+                syncDataHolder.markClientSyncFieldDirty("y");
+                syncDataHolder.markClientSyncFieldDirty("z");
             } else
                 return blocks;
 
diff --git a/src/main/java/com/gregtechceu/gtceu/common/module/AdvancedJetpackModule.java b/src/main/java/com/gregtechceu/gtceu/common/module/AdvancedJetpackModule.java
new file mode 100644
index 00000000000..caae3de1880
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/common/module/AdvancedJetpackModule.java
@@ -0,0 +1,53 @@
+package com.gregtechceu.gtceu.common.module;
+
+import com.gregtechceu.gtceu.api.GTValues;
+import com.gregtechceu.gtceu.api.item.armor.IArmorLogic;
+import com.gregtechceu.gtceu.api.item.module.AppliedItemModule;
+import com.gregtechceu.gtceu.api.item.module.ArmorLogicItemModule;
+import com.gregtechceu.gtceu.api.item.module.ITieredItemModule;
+import com.gregtechceu.gtceu.common.item.armor.AdvancedJetpack;
+import com.gregtechceu.gtceu.config.ConfigHolder;
+
+import net.minecraft.network.chat.Component;
+import net.minecraft.resources.ResourceLocation;
+import net.minecraft.world.item.TooltipFlag;
+import net.minecraft.world.level.Level;
+
+import org.jetbrains.annotations.Nullable;
+
+import java.util.List;
+
+public class AdvancedJetpackModule extends ArmorLogicItemModule implements ITieredItemModule {
+
+    private static final AdvancedJetpack JETPACK = new AdvancedJetpack(
+            256,
+            6_400_000L * (long) Math.max(1, Math.pow(4, ConfigHolder.INSTANCE.tools.voltageTierAdvImpeller - 4)),
+            ConfigHolder.INSTANCE.tools.voltageTierAdvImpeller);
+
+    public AdvancedJetpackModule(ResourceLocation id) {
+        super(id);
+    }
+
+    @Override
+    public Component getInfo() {
+        return Component.translatable("gtceu.module.advanced_jetpack");
+    }
+
+    @Override
+    protected @Nullable IArmorLogic getArmorLogic(AppliedItemModule module) {
+        return JETPACK;
+    }
+
+    @Override
+    public int getTier() {
+        return GTValues.EV;
+    }
+
+    @Override
+    public void appendHoverText(Level level, TooltipFlag isAdvanced, List<Component> tooltips,
+                                AppliedItemModule module) {
+        super.appendHoverText(level, isAdvanced, tooltips, module);
+        tooltips.add(
+                Component.translatable("metaarmor.tooltip.modifier.jetpack", module.getModuleItem().getHoverName()));
+    }
+}
diff --git a/src/main/java/com/gregtechceu/gtceu/common/module/AirSupplierModule.java b/src/main/java/com/gregtechceu/gtceu/common/module/AirSupplierModule.java
new file mode 100644
index 00000000000..8d6ec7f94d5
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/common/module/AirSupplierModule.java
@@ -0,0 +1,43 @@
+package com.gregtechceu.gtceu.common.module;
+
+import com.gregtechceu.gtceu.api.capability.GTCapabilityHelper;
+import com.gregtechceu.gtceu.api.capability.IElectricItem;
+import com.gregtechceu.gtceu.api.item.module.AppliedItemModule;
+import com.gregtechceu.gtceu.api.item.module.ItemModule;
+import com.gregtechceu.gtceu.common.item.armor.AdvancedQuarkTechSuite;
+
+import net.minecraft.network.chat.Component;
+import net.minecraft.resources.ResourceLocation;
+import net.minecraft.world.entity.LivingEntity;
+import net.minecraft.world.entity.player.Player;
+import net.minecraft.world.item.TooltipFlag;
+import net.minecraft.world.level.Level;
+
+import java.util.List;
+
+public class AirSupplierModule extends ItemModule {
+
+    public AirSupplierModule(ResourceLocation id) {
+        super(id);
+    }
+
+    @Override
+    public Component getInfo() {
+        return Component.translatable("metaarmor.tooltip.breath");
+    }
+
+    @Override
+    public void onArmorTick(LivingEntity entity, AppliedItemModule module) {
+        super.onArmorTick(entity, module);
+        IElectricItem electricItem = GTCapabilityHelper.getElectricItem(module.getAppliedTo());
+        if (electricItem == null) return;
+        AdvancedQuarkTechSuite.supplyAir(electricItem, (Player) entity, 128);
+    }
+
+    @Override
+    public void appendHoverText(Level level, TooltipFlag isAdvanced, List<Component> tooltips,
+                                AppliedItemModule module) {
+        super.appendHoverText(level, isAdvanced, tooltips, module);
+        tooltips.add(Component.translatable("metaarmor.tooltip.breath"));
+    }
+}
diff --git a/src/main/java/com/gregtechceu/gtceu/common/module/AttackDamageItemModule.java b/src/main/java/com/gregtechceu/gtceu/common/module/AttackDamageItemModule.java
new file mode 100644
index 00000000000..2d25d5c79a2
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/common/module/AttackDamageItemModule.java
@@ -0,0 +1,50 @@
+package com.gregtechceu.gtceu.common.module;
+
+import com.gregtechceu.gtceu.api.GTValues;
+import com.gregtechceu.gtceu.api.item.module.AppliedItemModule;
+import com.gregtechceu.gtceu.api.item.module.TieredAttributeItemModule;
+
+import net.minecraft.network.chat.Component;
+import net.minecraft.resources.ResourceLocation;
+import net.minecraft.world.entity.ai.attributes.Attribute;
+import net.minecraft.world.entity.ai.attributes.AttributeModifier;
+import net.minecraft.world.entity.ai.attributes.Attributes;
+import net.minecraft.world.item.TooltipFlag;
+import net.minecraft.world.level.Level;
+
+import java.util.List;
+import java.util.UUID;
+
+public class AttackDamageItemModule extends TieredAttributeItemModule {
+
+    private static final UUID MUL_DAMAGE_UUID = UUID.fromString("a5bd81ea-b3af-4cca-8866-f3e62f5f68f1");
+
+    public AttackDamageItemModule(ResourceLocation id, int tier) {
+        super(id, tier);
+    }
+
+    @Override
+    public Component getInfo() {
+        return Component.translatable("gtceu.module.attack_damage", getTier() * 100 / 16d);
+    }
+
+    @Override
+    public Attribute getAttribute(AppliedItemModule module) {
+        return Attributes.ATTACK_DAMAGE;
+    }
+
+    @Override
+    public AttributeModifier getAttributeModifier(AppliedItemModule module) {
+        double mul = 1 + getTier() / 16d;
+        return new AttributeModifier(MUL_DAMAGE_UUID, "Attack Damage Modifier", mul,
+                AttributeModifier.Operation.MULTIPLY_TOTAL);
+    }
+
+    @Override
+    public void appendHoverText(Level level, TooltipFlag isAdvanced, List<Component> tooltips,
+                                AppliedItemModule module) {
+        super.appendHoverText(level, isAdvanced, tooltips, module);
+        tooltips.add(Component.translatable("metaarmor.tooltip.modifier.attack_damage",
+                GTValues.VNF[getTier()]));
+    }
+}
diff --git a/src/main/java/com/gregtechceu/gtceu/common/module/AttackSpeedItemModule.java b/src/main/java/com/gregtechceu/gtceu/common/module/AttackSpeedItemModule.java
new file mode 100644
index 00000000000..dbbee8e1a36
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/common/module/AttackSpeedItemModule.java
@@ -0,0 +1,50 @@
+package com.gregtechceu.gtceu.common.module;
+
+import com.gregtechceu.gtceu.api.GTValues;
+import com.gregtechceu.gtceu.api.item.module.AppliedItemModule;
+import com.gregtechceu.gtceu.api.item.module.TieredAttributeItemModule;
+
+import net.minecraft.network.chat.Component;
+import net.minecraft.resources.ResourceLocation;
+import net.minecraft.world.entity.ai.attributes.Attribute;
+import net.minecraft.world.entity.ai.attributes.AttributeModifier;
+import net.minecraft.world.entity.ai.attributes.Attributes;
+import net.minecraft.world.item.TooltipFlag;
+import net.minecraft.world.level.Level;
+
+import java.util.List;
+import java.util.UUID;
+
+public class AttackSpeedItemModule extends TieredAttributeItemModule {
+
+    private static final UUID MUL_ATTACK_SPEED_UUID = UUID.fromString("b5bd81ea-b3af-4cca-8866-f3e62f5f68f1");
+
+    public AttackSpeedItemModule(ResourceLocation id, int tier) {
+        super(id, tier);
+    }
+
+    @Override
+    public Component getInfo() {
+        return Component.translatable("gtceu.module.attack_speed", getTier() * 100 / 16d);
+    }
+
+    @Override
+    public Attribute getAttribute(AppliedItemModule module) {
+        return Attributes.ATTACK_SPEED;
+    }
+
+    @Override
+    public AttributeModifier getAttributeModifier(AppliedItemModule module) {
+        double mul = 1 + getTier() / 16d;
+        return new AttributeModifier(MUL_ATTACK_SPEED_UUID, "Attack Speed Modifier", mul,
+                AttributeModifier.Operation.MULTIPLY_TOTAL);
+    }
+
+    @Override
+    public void appendHoverText(Level level, TooltipFlag isAdvanced, List<Component> tooltips,
+                                AppliedItemModule module) {
+        super.appendHoverText(level, isAdvanced, tooltips, module);
+        tooltips.add(Component.translatable("metaarmor.tooltip.modifier.attack_speed",
+                GTValues.VNF[getTier()]));
+    }
+}
diff --git a/src/main/java/com/gregtechceu/gtceu/common/module/AutoChargeItemModule.java b/src/main/java/com/gregtechceu/gtceu/common/module/AutoChargeItemModule.java
new file mode 100644
index 00000000000..92b9641030c
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/common/module/AutoChargeItemModule.java
@@ -0,0 +1,103 @@
+package com.gregtechceu.gtceu.common.module;
+
+import com.gregtechceu.gtceu.api.GTValues;
+import com.gregtechceu.gtceu.api.capability.GTCapabilityHelper;
+import com.gregtechceu.gtceu.api.capability.IElectricItem;
+import com.gregtechceu.gtceu.api.item.module.AppliedItemModule;
+import com.gregtechceu.gtceu.api.item.module.IModularItem;
+import com.gregtechceu.gtceu.api.item.module.ItemModule;
+import com.gregtechceu.gtceu.api.item.module.TieredItemModule;
+import com.gregtechceu.gtceu.api.machine.MetaMachine;
+import com.gregtechceu.gtceu.common.data.GTItemModules;
+import com.gregtechceu.gtceu.common.machine.electric.ChargerMachine;
+import com.gregtechceu.gtceu.common.machine.multiblock.electric.PowerSubstationMachine;
+
+import net.minecraft.core.BlockPos;
+import net.minecraft.core.registries.Registries;
+import net.minecraft.nbt.CompoundTag;
+import net.minecraft.network.chat.Component;
+import net.minecraft.resources.ResourceKey;
+import net.minecraft.resources.ResourceLocation;
+import net.minecraft.server.MinecraftServer;
+import net.minecraft.world.entity.player.Player;
+import net.minecraft.world.item.TooltipFlag;
+import net.minecraft.world.level.Level;
+
+import java.util.List;
+
+public class AutoChargeItemModule extends TieredItemModule {
+
+    public AutoChargeItemModule(ResourceLocation id, int tier) {
+        super(id, tier);
+    }
+
+    @Override
+    public Component getInfo() {
+        if (getTier() < GTValues.IV)
+            return Component.translatable("gtceu.module.wireless_charging", getRange(), GTValues.VNF[getTier()]);
+        else return Component.translatable("gtceu.module.wireless_charging.interdimensional", getRange(),
+                GTValues.VNF[getTier()], GTValues.VNF[GTValues.IV]);
+    }
+
+    @Override
+    public void onInventoryTick(Player player, AppliedItemModule module) {
+        super.onInventoryTick(player, module);
+        long energy = getEnergyToTransfer(player, module);
+        MetaMachine machine = getLinkedMachine(player.getServer(), module);
+        IElectricItem electricItem = GTCapabilityHelper.getElectricItem(module.getAppliedTo());
+        if (electricItem == null) return;
+        if (energy > 0) {
+            if (machine instanceof PowerSubstationMachine substation) {
+                electricItem.charge(substation.getEnergyBank().drain(energy), electricItem.getTier(), false, false);
+            } else if (machine instanceof ChargerMachine charger) {
+                charger.getLinkedItems().add(module.getAppliedTo());
+            }
+        }
+    }
+
+    private long getEnergyToTransfer(Player player, AppliedItemModule module) {
+        IElectricItem electricItem = GTCapabilityHelper.getElectricItem(module.getAppliedTo());
+        if (electricItem == null) return 0;
+        long energy = Math.min(electricItem.getMaxCharge() - electricItem.getCharge(), electricItem.getTransferLimit());
+        if (energy <= 0) return 0;
+        MetaMachine machine = getLinkedMachine(player.getServer(), module);
+        if (machine == null) return 0;
+        int interdimensionalTier = -1;
+        ItemModule[] damageBlock = GTItemModules.DAMAGE_BLOCK;
+        for (int i = 0; i < damageBlock.length; i++) {
+            ItemModule shieldModule = damageBlock[i];
+            IModularItem modularItem = GTCapabilityHelper.getModularItem(module.getAppliedTo());
+            if (modularItem != null && modularItem.getModule(shieldModule) != null)
+                interdimensionalTier = i + 1;
+        }
+        interdimensionalTier = Math.min(interdimensionalTier, getTier());
+        if (machine.getLevel() != player.level() && interdimensionalTier < GTValues.IV) return 0;
+        if (interdimensionalTier < GTValues.IV && machine.getBlockPos().distSqr(player.blockPosition()) > getRange())
+            return 0;
+        return Math.min(energy, GTValues.V[machine.getLevel() == player.level() ? getTier() : interdimensionalTier]);
+    }
+
+    private MetaMachine getLinkedMachine(MinecraftServer server, AppliedItemModule module) {
+        if (!module.getModuleItem().getOrCreateTag().contains("LinkedCharger")) return null;
+        CompoundTag tag = module.getModuleItem().getOrCreateTagElement("LinkedCharger");
+        int x = tag.getInt("x");
+        int y = tag.getInt("y");
+        int z = tag.getInt("z");
+        if (server == null) return null;
+        Level level = server
+                .getLevel(ResourceKey.create(Registries.DIMENSION, new ResourceLocation(tag.getString("dim"))));
+        if (level == null) return null;
+        return MetaMachine.getMachine(level, new BlockPos(x, y, z));
+    }
+
+    private double getRange() {
+        return (8 << getTier());
+    }
+
+    @Override
+    public void appendHoverText(Level level, TooltipFlag isAdvanced, List<Component> tooltips,
+                                AppliedItemModule module) {
+        super.appendHoverText(level, isAdvanced, tooltips, module);
+        tooltips.add(Component.translatable("metaarmor.tooltip.modifier.wireless_charging", GTValues.VNF[getTier()]));
+    }
+}
diff --git a/src/main/java/com/gregtechceu/gtceu/common/module/AutoEatModule.java b/src/main/java/com/gregtechceu/gtceu/common/module/AutoEatModule.java
new file mode 100644
index 00000000000..22c5b809be7
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/common/module/AutoEatModule.java
@@ -0,0 +1,43 @@
+package com.gregtechceu.gtceu.common.module;
+
+import com.gregtechceu.gtceu.api.capability.GTCapabilityHelper;
+import com.gregtechceu.gtceu.api.capability.IElectricItem;
+import com.gregtechceu.gtceu.api.item.module.AppliedItemModule;
+import com.gregtechceu.gtceu.api.item.module.ItemModule;
+import com.gregtechceu.gtceu.common.item.armor.AdvancedQuarkTechSuite;
+
+import net.minecraft.network.chat.Component;
+import net.minecraft.resources.ResourceLocation;
+import net.minecraft.world.entity.LivingEntity;
+import net.minecraft.world.entity.player.Player;
+import net.minecraft.world.item.TooltipFlag;
+import net.minecraft.world.level.Level;
+
+import java.util.List;
+
+public class AutoEatModule extends ItemModule {
+
+    public AutoEatModule(ResourceLocation id) {
+        super(id);
+    }
+
+    @Override
+    public Component getInfo() {
+        return Component.translatable("metaarmor.tooltip.autoeat");
+    }
+
+    @Override
+    public void onArmorTick(LivingEntity entity, AppliedItemModule module) {
+        super.onArmorTick(entity, module);
+        IElectricItem electricItem = GTCapabilityHelper.getElectricItem(module.getAppliedTo());
+        if (electricItem == null) return;
+        AdvancedQuarkTechSuite.supplyFood(electricItem, (Player) entity, 512);
+    }
+
+    @Override
+    public void appendHoverText(Level level, TooltipFlag isAdvanced, List<Component> tooltips,
+                                AppliedItemModule module) {
+        super.appendHoverText(level, isAdvanced, tooltips, module);
+        tooltips.add(Component.translatable("metaarmor.tooltip.autoeat"));
+    }
+}
diff --git a/src/main/java/com/gregtechceu/gtceu/common/module/BatteryItemModule.java b/src/main/java/com/gregtechceu/gtceu/common/module/BatteryItemModule.java
new file mode 100644
index 00000000000..1a7a7c9ff39
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/common/module/BatteryItemModule.java
@@ -0,0 +1,151 @@
+package com.gregtechceu.gtceu.common.module;
+
+import com.gregtechceu.gtceu.api.GTValues;
+import com.gregtechceu.gtceu.api.capability.GTCapability;
+import com.gregtechceu.gtceu.api.capability.GTCapabilityHelper;
+import com.gregtechceu.gtceu.api.capability.IElectricItem;
+import com.gregtechceu.gtceu.api.item.module.AppliedItemModule;
+import com.gregtechceu.gtceu.api.item.module.ICapabilityModule;
+import com.gregtechceu.gtceu.api.item.module.IHUDProviderItemModule;
+import com.gregtechceu.gtceu.api.item.module.ItemModule;
+import com.gregtechceu.gtceu.utils.GTStringUtils;
+
+import net.minecraft.client.Minecraft;
+import net.minecraft.client.gui.GuiGraphics;
+import net.minecraft.network.chat.Component;
+import net.minecraft.resources.ResourceLocation;
+import net.minecraft.world.InteractionHand;
+import net.minecraft.world.InteractionResultHolder;
+import net.minecraft.world.entity.EquipmentSlot;
+import net.minecraft.world.entity.LivingEntity;
+import net.minecraft.world.entity.player.Player;
+import net.minecraft.world.item.ItemStack;
+import net.minecraft.world.item.TooltipFlag;
+import net.minecraft.world.level.Level;
+import net.minecraftforge.common.capabilities.Capability;
+import net.minecraftforge.common.util.LazyOptional;
+
+import brachy.modularui.api.drawable.IKey;
+import brachy.modularui.value.sync.PanelSyncManager;
+import org.jetbrains.annotations.NotNull;
+
+import java.util.List;
+
+public class BatteryItemModule extends ItemModule implements ICapabilityModule, IHUDProviderItemModule {
+
+    private static final double PERCENTAGE = 80.0d;
+
+    public BatteryItemModule(ResourceLocation id) {
+        super(id);
+    }
+
+    @Override
+    public Component getDisplayName(AppliedItemModule module) {
+        IElectricItem electricItem = GTCapabilityHelper.getElectricItem(module.getModuleItem());
+        if (electricItem != null)
+            return Component.translatable("metaarmor.tooltip.modifier.battery", GTValues.VNF[electricItem.getTier()]);
+        else return super.getDisplayName(module);
+    }
+
+    @Override
+    public Component getInfo() {
+        return Component.translatable("gtceu.module.battery");
+    }
+
+    @Override
+    public void onInventoryTick(Player player, AppliedItemModule module) {
+        super.onInventoryTick(player, module);
+        if (module.getAppliedTo() == null || module.getModuleItem() == null) return;
+        IElectricItem item = GTCapabilityHelper.getElectricItem(module.getAppliedTo());
+        IElectricItem battery = GTCapabilityHelper.getElectricItem(module.getModuleItem());
+        if (item == null || battery == null || item == battery) return;
+        if (item.getCharge() > item.getMaxCharge() * PERCENTAGE / 100) {
+            long amount = (long) (item.getCharge() - item.getMaxCharge() * PERCENTAGE / 100);
+            item.charge(battery.discharge(amount, battery.getTier(), true, false, false), item.getTier(), true, false);
+        } else if (item.getCharge() < item.getMaxCharge() * PERCENTAGE / 100) {
+            long amount = (long) (item.getMaxCharge() * PERCENTAGE / 100 - item.getCharge());
+            battery.charge(item.discharge(amount, item.getTier(), true, false, false), battery.getTier(), true, false);
+        }
+        // the battery's inventoryTick method does not use inventorySlot or isCurrentItem
+        module.getModuleItem().inventoryTick(player.level(), player, 0, false);
+    }
+
+    @Override
+    public void appendHoverText(Level level, TooltipFlag isAdvanced, List<Component> tooltips,
+                                AppliedItemModule module) {
+        super.appendHoverText(level, isAdvanced, tooltips, module);
+        tooltips.add(
+                Component.translatable("metaarmor.tooltip.modifier.battery", module.getModuleItem().getHoverName()));
+        if (module.getModuleItem() != null) {
+            module.getModuleItem().getItem().appendHoverText(module.getModuleItem(), level, tooltips, isAdvanced);
+        }
+    }
+
+    @Override
+    public @NotNull <T> LazyOptional<T> getCapability(AppliedItemModule module, @NotNull Capability<T> cap) {
+        if (cap == GTCapability.CAPABILITY_ELECTRIC_ITEM && module.getModuleItem() != null) {
+            return module.getModuleItem().getCapability(cap);
+        } else return LazyOptional.empty();
+    }
+
+    @Override
+    public void drawHUD(AppliedItemModule module, GuiGraphics graphics) {
+        IElectricItem electricItem = GTCapabilityHelper.getElectricItem(module.getModuleItem());
+        if (electricItem == null) return;
+        EquipmentSlot slot = LivingEntity.getEquipmentSlotForItem(module.getAppliedTo());
+        Component displayName = module.getModuleItem().getHoverName();
+        int x = 10, y;
+        switch (slot) {
+            case HEAD -> {
+                y = 20;
+                graphics.drawString(
+                        Minecraft.getInstance().font,
+                        Component.translatable("metaarmor.tooltip.modifier.battery.hud.helmet", displayName),
+                        x, y, 0xFFFFFF);
+            }
+            case CHEST -> {
+                y = 40;
+                graphics.drawString(
+                        Minecraft.getInstance().font,
+                        Component.translatable("metaarmor.tooltip.modifier.battery.hud.chestplate", displayName),
+                        x, y, 0xFFFFFF);
+            }
+            case LEGS -> {
+                y = 60;
+                graphics.drawString(
+                        Minecraft.getInstance().font,
+                        Component.translatable("metaarmor.tooltip.modifier.battery.hud.leggings", displayName),
+                        x, y, 0xFFFFFF);
+            }
+            case FEET -> {
+                y = 80;
+                graphics.drawString(
+                        Minecraft.getInstance().font,
+                        Component.translatable("metaarmor.tooltip.modifier.battery.hud.boots", displayName),
+                        x, y, 0xFFFFFF);
+            }
+            default -> y = 100;
+        }
+        graphics.drawString(
+                Minecraft.getInstance().font,
+                Component.translatable("metaarmor.tooltip.modifier.battery.hud.info", electricItem.getCharge(),
+                        electricItem.getMaxCharge()),
+                x, y + 10, 0xFFFFFF);
+    }
+
+    @Override
+    public InteractionResultHolder<ItemStack> use(AppliedItemModule module, Level level, Player player,
+                                                  InteractionHand hand) {
+        return module.getModuleItem().use(level, player, hand);
+    }
+
+    @Override
+    public Settings getSettings(AppliedItemModule module, PanelSyncManager psm, int id) {
+        IElectricItem electricItem = GTCapabilityHelper.getElectricItem(module.getModuleItem());
+        if (electricItem == null) return super.getSettings(module, psm, id);
+        return super.getSettings(module, psm, id)
+                .progress(IKey.lang("gtceu.module.gui.charge"),
+                        () -> (double) electricItem.getCharge() / electricItem.getMaxCharge(),
+                        x -> GTStringUtils.formatInt((long) (x * electricItem.getMaxCharge())) + " EU");
+    }
+}
diff --git a/src/main/java/com/gregtechceu/gtceu/common/module/BlockReachItemModule.java b/src/main/java/com/gregtechceu/gtceu/common/module/BlockReachItemModule.java
new file mode 100644
index 00000000000..e1220de59df
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/common/module/BlockReachItemModule.java
@@ -0,0 +1,50 @@
+package com.gregtechceu.gtceu.common.module;
+
+import com.gregtechceu.gtceu.api.GTValues;
+import com.gregtechceu.gtceu.api.item.module.AppliedItemModule;
+import com.gregtechceu.gtceu.api.item.module.TieredAttributeItemModule;
+
+import net.minecraft.network.chat.Component;
+import net.minecraft.resources.ResourceLocation;
+import net.minecraft.world.entity.ai.attributes.Attribute;
+import net.minecraft.world.entity.ai.attributes.AttributeModifier;
+import net.minecraft.world.item.TooltipFlag;
+import net.minecraft.world.level.Level;
+import net.minecraftforge.common.ForgeMod;
+
+import java.util.List;
+import java.util.UUID;
+
+public class BlockReachItemModule extends TieredAttributeItemModule {
+
+    private static final UUID ADD_BLOCK_REACH_UUID = UUID.fromString("c5bd81ea-b3af-4cca-8866-f3e62f5f68f1");
+
+    public BlockReachItemModule(ResourceLocation id, int tier) {
+        super(id, tier);
+    }
+
+    @Override
+    public Component getInfo() {
+        return Component.translatable("gtceu.module.block_reach", getTier() / 2d);
+    }
+
+    @Override
+    public Attribute getAttribute(AppliedItemModule module) {
+        return ForgeMod.BLOCK_REACH.get();
+    }
+
+    @Override
+    public AttributeModifier getAttributeModifier(AppliedItemModule module) {
+        double add = getTier() / 2d;
+        return new AttributeModifier(ADD_BLOCK_REACH_UUID, "Block Reach Modifier", add,
+                AttributeModifier.Operation.ADDITION);
+    }
+
+    @Override
+    public void appendHoverText(Level level, TooltipFlag isAdvanced, List<Component> tooltips,
+                                AppliedItemModule module) {
+        super.appendHoverText(level, isAdvanced, tooltips, module);
+        tooltips.add(Component.translatable("metaarmor.tooltip.modifier.block_reach",
+                GTValues.VNF[getTier()]));
+    }
+}
diff --git a/src/main/java/com/gregtechceu/gtceu/common/module/CreativeFlightModule.java b/src/main/java/com/gregtechceu/gtceu/common/module/CreativeFlightModule.java
new file mode 100644
index 00000000000..73e0aec7f48
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/common/module/CreativeFlightModule.java
@@ -0,0 +1,80 @@
+package com.gregtechceu.gtceu.common.module;
+
+import com.gregtechceu.gtceu.api.GTValues;
+import com.gregtechceu.gtceu.api.capability.GTCapabilityHelper;
+import com.gregtechceu.gtceu.api.capability.IElectricItem;
+import com.gregtechceu.gtceu.api.item.module.AppliedItemModule;
+import com.gregtechceu.gtceu.api.item.module.ITieredItemModule;
+import com.gregtechceu.gtceu.api.item.module.ItemModule;
+
+import net.minecraft.ChatFormatting;
+import net.minecraft.network.chat.Component;
+import net.minecraft.resources.ResourceLocation;
+import net.minecraft.world.entity.LivingEntity;
+import net.minecraft.world.entity.player.Player;
+import net.minecraft.world.item.TooltipFlag;
+import net.minecraft.world.level.Level;
+
+import java.util.List;
+
+public class CreativeFlightModule extends ItemModule implements ITieredItemModule {
+
+    public CreativeFlightModule(ResourceLocation id) {
+        super(id);
+    }
+
+    @Override
+    public Component getInfo() {
+        return Component.translatable("gtceu.module.creative_flight", 2048);
+    }
+
+    private void setMayFly(LivingEntity entity, boolean mayFly) {
+        if (entity instanceof Player player) {
+            player.getAbilities().mayfly = mayFly;
+            if (!mayFly) player.getAbilities().flying = false;
+        }
+    }
+
+    private boolean isFlying(LivingEntity entity) {
+        if (entity instanceof Player player) {
+            return player.getAbilities().flying;
+        } else return false;
+    }
+
+    @Override
+    public void onEquip(LivingEntity entity, AppliedItemModule module) {
+        super.onEquip(entity, module);
+        setMayFly(entity, true);
+    }
+
+    @Override
+    public void onUnequip(LivingEntity entity, AppliedItemModule module) {
+        super.onUnequip(entity, module);
+        setMayFly(entity, false);
+    }
+
+    @Override
+    public void onArmorTick(LivingEntity entity, AppliedItemModule module) {
+        super.onArmorTick(entity, module);
+        IElectricItem electricItem = GTCapabilityHelper.getElectricItem(module.getAppliedTo());
+        if (electricItem == null || !isFlying(entity)) return;
+        if (!electricItem.canUse(2048)) setMayFly(entity, false);
+        else {
+            electricItem.discharge(2048, electricItem.getTier(), true, false, false);
+            setMayFly(entity, true);
+        }
+    }
+
+    @Override
+    public void appendHoverText(Level level, TooltipFlag isAdvanced, List<Component> tooltips,
+                                AppliedItemModule module) {
+        super.appendHoverText(level, isAdvanced, tooltips, module);
+        tooltips.add(Component.translatable("metaarmor.tooltip.modifier.creative_flight")
+                .withStyle(ChatFormatting.LIGHT_PURPLE));
+    }
+
+    @Override
+    public int getTier() {
+        return GTValues.IV;
+    }
+}
diff --git a/src/main/java/com/gregtechceu/gtceu/common/module/EnergyShieldItemModule.java b/src/main/java/com/gregtechceu/gtceu/common/module/EnergyShieldItemModule.java
new file mode 100644
index 00000000000..52a1c9febc4
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/common/module/EnergyShieldItemModule.java
@@ -0,0 +1,66 @@
+package com.gregtechceu.gtceu.common.module;
+
+import com.gregtechceu.gtceu.api.GTValues;
+import com.gregtechceu.gtceu.api.capability.GTCapabilityHelper;
+import com.gregtechceu.gtceu.api.capability.IElectricItem;
+import com.gregtechceu.gtceu.api.item.module.AppliedItemModule;
+import com.gregtechceu.gtceu.api.item.module.TieredItemModule;
+
+import net.minecraft.network.chat.Component;
+import net.minecraft.resources.ResourceLocation;
+import net.minecraft.tags.DamageTypeTags;
+import net.minecraft.world.damagesource.DamageSource;
+import net.minecraft.world.damagesource.DamageTypes;
+import net.minecraft.world.entity.LivingEntity;
+import net.minecraft.world.item.TooltipFlag;
+import net.minecraft.world.level.Level;
+
+import java.util.List;
+
+public class EnergyShieldItemModule extends TieredItemModule {
+
+    public EnergyShieldItemModule(ResourceLocation id, int tier) {
+        super(id, tier);
+    }
+
+    @Override
+    public Component getInfo() {
+        return Component.translatable("gtceu.module.damage_block", getEnergyPerHP());
+    }
+
+    private long getEnergyPerHP() {
+        float div = (getTier() - 1) / 4f + 1;
+        return (long) (8192 / div);
+    }
+
+    @Override
+    public float changeDamage(LivingEntity entity, AppliedItemModule module, float amount, DamageSource source) {
+        long energyPerHP = getEnergyPerHP();
+        double percentage = 25;
+        if (source.is(DamageTypeTags.BYPASSES_INVULNERABILITY) || source.is(DamageTypeTags.IS_FALL) ||
+                source.is(DamageTypeTags.IS_DROWNING) || source.is(DamageTypes.STARVE)) {
+            return amount;
+        }
+
+        int damageReduction = Integer.MAX_VALUE;
+        IElectricItem electricItem = GTCapabilityHelper.getElectricItem(module.getAppliedTo());
+        if (electricItem == null) {
+            return amount;
+        }
+        damageReduction = (int) Math.min(damageReduction,
+                percentage * electricItem.getCharge() / (energyPerHP * 100.0D));
+        damageReduction = Math.toIntExact(electricItem.discharge(
+                damageReduction * energyPerHP,
+                electricItem.getTier(),
+                true, false, false) / energyPerHP);
+        return Math.max(amount - damageReduction, 0);
+    }
+
+    @Override
+    public void appendHoverText(Level level, TooltipFlag isAdvanced, List<Component> tooltips,
+                                AppliedItemModule module) {
+        super.appendHoverText(level, isAdvanced, tooltips, module);
+        tooltips.add(Component.translatable("metaarmor.tooltip.modifier.damage_block",
+                GTValues.VNF[getTier()]));
+    }
+}
diff --git a/src/main/java/com/gregtechceu/gtceu/common/module/FluidStorageModule.java b/src/main/java/com/gregtechceu/gtceu/common/module/FluidStorageModule.java
new file mode 100644
index 00000000000..eb04136fd26
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/common/module/FluidStorageModule.java
@@ -0,0 +1,54 @@
+package com.gregtechceu.gtceu.common.module;
+
+import com.gregtechceu.gtceu.api.item.module.AppliedItemModule;
+import com.gregtechceu.gtceu.api.item.module.ICapabilityModule;
+import com.gregtechceu.gtceu.api.item.module.ItemModule;
+
+import net.minecraft.network.chat.Component;
+import net.minecraft.resources.ResourceLocation;
+import net.minecraft.world.item.TooltipFlag;
+import net.minecraft.world.level.Level;
+import net.minecraftforge.common.capabilities.Capability;
+import net.minecraftforge.common.capabilities.ForgeCapabilities;
+import net.minecraftforge.common.util.LazyOptional;
+import net.minecraftforge.fluids.FluidStack;
+import net.minecraftforge.fluids.capability.IFluidHandlerItem;
+
+import org.jetbrains.annotations.NotNull;
+
+import java.util.List;
+
+public class FluidStorageModule extends ItemModule implements ICapabilityModule {
+
+    public FluidStorageModule(ResourceLocation id) {
+        super(id);
+    }
+
+    @Override
+    public Component getInfo() {
+        return Component.translatable("gtceu.module.fluid_storage");
+    }
+
+    @Override
+    public @NotNull <T> LazyOptional<T> getCapability(AppliedItemModule module, @NotNull Capability<T> cap) {
+        if (cap == ForgeCapabilities.FLUID_HANDLER_ITEM)
+            return module.getModuleItem().getCapability(cap);
+        return LazyOptional.empty();
+    }
+
+    @Override
+    public void appendHoverText(Level level, TooltipFlag isAdvanced, List<Component> tooltips,
+                                AppliedItemModule module) {
+        super.appendHoverText(level, isAdvanced, tooltips, module);
+        tooltips.add(Component.translatable("metaarmor.tooltip.modifier.fluid_storage",
+                module.getModuleItem().getDisplayName()));
+        IFluidHandlerItem fluidHandler = getCapability(module, ForgeCapabilities.FLUID_HANDLER_ITEM).resolve()
+                .orElse(null);
+        if (fluidHandler != null) {
+            FluidStack fluid = fluidHandler.getFluidInTank(0);
+            int capacity = fluidHandler.getTankCapacity(0);
+            tooltips.add(Component.translatable("metaarmor.tooltip.modifier.fluid_storage.tooltip", fluid.getAmount(),
+                    capacity, fluid.getDisplayName()));
+        }
+    }
+}
diff --git a/src/main/java/com/gregtechceu/gtceu/common/module/JetpackModule.java b/src/main/java/com/gregtechceu/gtceu/common/module/JetpackModule.java
new file mode 100644
index 00000000000..04784f17d01
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/common/module/JetpackModule.java
@@ -0,0 +1,53 @@
+package com.gregtechceu.gtceu.common.module;
+
+import com.gregtechceu.gtceu.api.GTValues;
+import com.gregtechceu.gtceu.api.item.armor.IArmorLogic;
+import com.gregtechceu.gtceu.api.item.module.AppliedItemModule;
+import com.gregtechceu.gtceu.api.item.module.ArmorLogicItemModule;
+import com.gregtechceu.gtceu.api.item.module.ITieredItemModule;
+import com.gregtechceu.gtceu.common.item.armor.Jetpack;
+import com.gregtechceu.gtceu.config.ConfigHolder;
+
+import net.minecraft.network.chat.Component;
+import net.minecraft.resources.ResourceLocation;
+import net.minecraft.world.item.TooltipFlag;
+import net.minecraft.world.level.Level;
+
+import org.jetbrains.annotations.Nullable;
+
+import java.util.List;
+
+public class JetpackModule extends ArmorLogicItemModule implements ITieredItemModule {
+
+    private static final Jetpack JETPACK = new Jetpack(
+            15,
+            1_000_000L * (long) Math.max(1, Math.pow(4, ConfigHolder.INSTANCE.tools.voltageTierImpeller - 2)),
+            ConfigHolder.INSTANCE.tools.voltageTierImpeller);
+
+    public JetpackModule(ResourceLocation id) {
+        super(id);
+    }
+
+    @Override
+    public Component getInfo() {
+        return Component.translatable("gtceu.module.jetpack");
+    }
+
+    @Override
+    protected @Nullable IArmorLogic getArmorLogic(AppliedItemModule module) {
+        return JETPACK;
+    }
+
+    @Override
+    public int getTier() {
+        return GTValues.HV;
+    }
+
+    @Override
+    public void appendHoverText(Level level, TooltipFlag isAdvanced, List<Component> tooltips,
+                                AppliedItemModule module) {
+        super.appendHoverText(level, isAdvanced, tooltips, module);
+        tooltips.add(
+                Component.translatable("metaarmor.tooltip.modifier.jetpack", module.getModuleItem().getHoverName()));
+    }
+}
diff --git a/src/main/java/com/gregtechceu/gtceu/common/module/JumpBoostItemModule.java b/src/main/java/com/gregtechceu/gtceu/common/module/JumpBoostItemModule.java
new file mode 100644
index 00000000000..0c566f29c14
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/common/module/JumpBoostItemModule.java
@@ -0,0 +1,61 @@
+package com.gregtechceu.gtceu.common.module;
+
+import com.gregtechceu.gtceu.api.GTValues;
+import com.gregtechceu.gtceu.api.item.module.AppliedItemModule;
+import com.gregtechceu.gtceu.api.item.module.IJumpBoostItemModule;
+import com.gregtechceu.gtceu.api.item.module.TieredItemModule;
+
+import net.minecraft.network.chat.Component;
+import net.minecraft.resources.ResourceLocation;
+import net.minecraft.world.item.TooltipFlag;
+import net.minecraft.world.level.Level;
+
+import brachy.modularui.api.drawable.IKey;
+import brachy.modularui.value.sync.PanelSyncManager;
+
+import java.util.List;
+
+public class JumpBoostItemModule extends TieredItemModule implements IJumpBoostItemModule {
+
+    private static final String JUMP_BOOST_KEY = "jump_boost";
+
+    public JumpBoostItemModule(ResourceLocation id, int tier) {
+        super(id, tier);
+    }
+
+    @Override
+    public Component getInfo() {
+        return Component.translatable("gtceu.module.jump", getTier() / 4f);
+    }
+
+    @Override
+    public float getJumpBoost(AppliedItemModule module) {
+        if (module.getTag().contains(JUMP_BOOST_KEY))
+            return module.getTag().getFloat(JUMP_BOOST_KEY);
+        return getMaxJumpBoost();
+    }
+
+    @Override
+    public void appendHoverText(Level level, TooltipFlag isAdvanced, List<Component> tooltips,
+                                AppliedItemModule module) {
+        super.appendHoverText(level, isAdvanced, tooltips, module);
+        tooltips.add(Component.translatable("metaarmor.tooltip.modifier.jump", GTValues.VNF[getTier()]));
+    }
+
+    public float getMaxJumpBoost() {
+        return getTier() / 4f;
+    }
+
+    public void setJumpBoost(AppliedItemModule module, float jumpBoost) {
+        module.getTag().putFloat(JUMP_BOOST_KEY, jumpBoost);
+    }
+
+    @Override
+    public Settings getSettings(AppliedItemModule module, PanelSyncManager psm, int id) {
+        return super.getSettings(module, psm, id)
+                .num(IKey.lang("gtceu.module.gui.jump_boost"),
+                        () -> getJumpBoost(module),
+                        x -> setJumpBoost(module, (float) x),
+                        0, getMaxJumpBoost());
+    }
+}
diff --git a/src/main/java/com/gregtechceu/gtceu/common/module/LiquidFuelJetpackModule.java b/src/main/java/com/gregtechceu/gtceu/common/module/LiquidFuelJetpackModule.java
new file mode 100644
index 00000000000..61f354f20a9
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/common/module/LiquidFuelJetpackModule.java
@@ -0,0 +1,49 @@
+package com.gregtechceu.gtceu.common.module;
+
+import com.gregtechceu.gtceu.api.GTValues;
+import com.gregtechceu.gtceu.api.item.armor.IArmorLogic;
+import com.gregtechceu.gtceu.api.item.module.AppliedItemModule;
+import com.gregtechceu.gtceu.api.item.module.ArmorLogicItemModule;
+import com.gregtechceu.gtceu.api.item.module.ITieredItemModule;
+import com.gregtechceu.gtceu.common.item.armor.PowerlessJetpack;
+
+import net.minecraft.network.chat.Component;
+import net.minecraft.resources.ResourceLocation;
+import net.minecraft.world.item.TooltipFlag;
+import net.minecraft.world.level.Level;
+
+import org.jetbrains.annotations.Nullable;
+
+import java.util.List;
+
+public class LiquidFuelJetpackModule extends ArmorLogicItemModule implements ITieredItemModule {
+
+    private static final PowerlessJetpack JETPACK = new PowerlessJetpack();
+
+    public LiquidFuelJetpackModule(ResourceLocation id) {
+        super(id);
+    }
+
+    @Override
+    public Component getInfo() {
+        return Component.translatable("gtceu.module.liquid_fuel_jetpack");
+    }
+
+    @Override
+    protected @Nullable IArmorLogic getArmorLogic(AppliedItemModule module) {
+        return JETPACK;
+    }
+
+    @Override
+    public int getTier() {
+        return GTValues.LV;
+    }
+
+    @Override
+    public void appendHoverText(Level level, TooltipFlag isAdvanced, List<Component> tooltips,
+                                AppliedItemModule module) {
+        super.appendHoverText(level, isAdvanced, tooltips, module);
+        tooltips.add(
+                Component.translatable("metaarmor.tooltip.modifier.jetpack", module.getModuleItem().getHoverName()));
+    }
+}
diff --git a/src/main/java/com/gregtechceu/gtceu/common/module/MovementSpeedItemModule.java b/src/main/java/com/gregtechceu/gtceu/common/module/MovementSpeedItemModule.java
new file mode 100644
index 00000000000..33cc10534d8
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/common/module/MovementSpeedItemModule.java
@@ -0,0 +1,50 @@
+package com.gregtechceu.gtceu.common.module;
+
+import com.gregtechceu.gtceu.api.GTValues;
+import com.gregtechceu.gtceu.api.item.module.AppliedItemModule;
+import com.gregtechceu.gtceu.api.item.module.TieredAttributeItemModule;
+
+import net.minecraft.network.chat.Component;
+import net.minecraft.resources.ResourceLocation;
+import net.minecraft.world.entity.ai.attributes.Attribute;
+import net.minecraft.world.entity.ai.attributes.AttributeModifier;
+import net.minecraft.world.entity.ai.attributes.Attributes;
+import net.minecraft.world.item.TooltipFlag;
+import net.minecraft.world.level.Level;
+
+import java.util.List;
+import java.util.UUID;
+
+public class MovementSpeedItemModule extends TieredAttributeItemModule {
+
+    private static final UUID MUL_MOVEMENT_SPEED_UUID = UUID.fromString("d5bd81ea-b3af-4cca-8866-f3e62f5f68f1");
+
+    public MovementSpeedItemModule(ResourceLocation id, int tier) {
+        super(id, tier);
+    }
+
+    @Override
+    public Component getInfo() {
+        return Component.translatable("gtceu.module.movement_speed", getTier() * 100 / 8d);
+    }
+
+    @Override
+    public Attribute getAttribute(AppliedItemModule module) {
+        return Attributes.MOVEMENT_SPEED;
+    }
+
+    @Override
+    public AttributeModifier getAttributeModifier(AppliedItemModule module) {
+        double mul = 1 + getTier() / 8d;
+        return new AttributeModifier(MUL_MOVEMENT_SPEED_UUID, "Movement Speed Modifier", mul,
+                AttributeModifier.Operation.MULTIPLY_TOTAL);
+    }
+
+    @Override
+    public void appendHoverText(Level level, TooltipFlag isAdvanced, List<Component> tooltips,
+                                AppliedItemModule module) {
+        super.appendHoverText(level, isAdvanced, tooltips, module);
+        tooltips.add(Component.translatable("metaarmor.tooltip.modifier.movement_speed",
+                GTValues.VNF[getTier()]));
+    }
+}
diff --git a/src/main/java/com/gregtechceu/gtceu/common/module/NightVisionModule.java b/src/main/java/com/gregtechceu/gtceu/common/module/NightVisionModule.java
new file mode 100644
index 00000000000..98a1e187fc6
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/common/module/NightVisionModule.java
@@ -0,0 +1,85 @@
+package com.gregtechceu.gtceu.common.module;
+
+import com.gregtechceu.gtceu.api.capability.GTCapabilityHelper;
+import com.gregtechceu.gtceu.api.capability.IElectricItem;
+import com.gregtechceu.gtceu.api.item.armor.ArmorUtils;
+import com.gregtechceu.gtceu.api.item.module.AppliedItemModule;
+import com.gregtechceu.gtceu.api.item.module.ItemModule;
+import com.gregtechceu.gtceu.utils.input.KeyBind;
+
+import net.minecraft.nbt.CompoundTag;
+import net.minecraft.network.chat.Component;
+import net.minecraft.resources.ResourceLocation;
+import net.minecraft.world.effect.MobEffectInstance;
+import net.minecraft.world.effect.MobEffects;
+import net.minecraft.world.entity.LivingEntity;
+import net.minecraft.world.entity.player.Player;
+import net.minecraft.world.item.TooltipFlag;
+import net.minecraft.world.level.Level;
+
+import java.util.List;
+
+public class NightVisionModule extends ItemModule {
+
+    public NightVisionModule(ResourceLocation id) {
+        super(id);
+    }
+
+    @Override
+    public Component getInfo() {
+        return Component.translatable("gtceu.module.nightvision", 2);
+    }
+
+    @Override
+    public void appendHoverText(Level level, TooltipFlag isAdvanced, List<Component> tooltips,
+                                AppliedItemModule module) {
+        super.appendHoverText(level, isAdvanced, tooltips, module);
+        tooltips.add(Component.translatable("metaarmor.message.nightvision.enabled"));
+    }
+
+    @Override
+    public void onArmorTick(LivingEntity entity, AppliedItemModule module) {
+        super.onArmorTick(entity, module);
+        if (!(entity instanceof Player player)) return;
+        IElectricItem item = GTCapabilityHelper.getElectricItem(module.getAppliedTo());
+        if (item == null) {
+            return;
+        }
+        CompoundTag data = module.getTag();
+        byte toggleTimer = data.contains("toggleTimer") ? data.getByte("toggleTimer") : 0;
+        int nightVisionTimer = data.contains("nightVisionTimer") ? data.getInt("nightVisionTimer") :
+                ArmorUtils.NIGHTVISION_DURATION;
+        boolean nightVision = data.contains("nightVision") && data.getBoolean("nightVision");
+        if (toggleTimer == 0 && KeyBind.ARMOR_MODE_SWITCH.isKeyDown(player)) {
+            nightVision = !nightVision;
+            toggleTimer = 5;
+            if (item.getCharge() < ArmorUtils.MIN_NIGHTVISION_CHARGE) {
+                nightVision = false;
+                player.displayClientMessage(Component.translatable("metaarmor.nms.nightvision.error"), true);
+            } else {
+                player.displayClientMessage(Component
+                        .translatable("metaarmor.nms.nightvision." + (nightVision ? "enabled" : "disabled")), true);
+            }
+        }
+
+        if (nightVision) {
+            player.removeEffect(MobEffects.BLINDNESS);
+            if (nightVisionTimer <= ArmorUtils.NIGHT_VISION_RESET) {
+                nightVisionTimer = ArmorUtils.NIGHTVISION_DURATION;
+                player.addEffect(
+                        new MobEffectInstance(MobEffects.NIGHT_VISION, ArmorUtils.NIGHTVISION_DURATION, 0, true,
+                                false));
+                item.discharge(2, item.getTier(), true, false, false);
+            }
+        } else {
+            player.removeEffect(MobEffects.NIGHT_VISION);
+        }
+        data.putBoolean("nightVision", nightVision);
+
+        if (nightVisionTimer > 0) nightVisionTimer--;
+        if (toggleTimer > 0) toggleTimer--;
+
+        data.putInt("nightVisionTimer", nightVisionTimer);
+        data.putByte("toggleTimer", toggleTimer);
+    }
+}
diff --git a/src/main/java/com/gregtechceu/gtceu/common/module/PPEModule.java b/src/main/java/com/gregtechceu/gtceu/common/module/PPEModule.java
new file mode 100644
index 00000000000..5ae9f26d0b2
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/common/module/PPEModule.java
@@ -0,0 +1,43 @@
+package com.gregtechceu.gtceu.common.module;
+
+import com.gregtechceu.gtceu.api.item.module.AppliedItemModule;
+import com.gregtechceu.gtceu.api.item.module.ItemModule;
+
+import net.minecraft.network.chat.Component;
+import net.minecraft.resources.ResourceLocation;
+import net.minecraft.world.item.TooltipFlag;
+import net.minecraft.world.level.Level;
+import net.minecraftforge.common.Tags;
+
+import java.util.List;
+
+public class PPEModule extends ItemModule {
+
+    public PPEModule(ResourceLocation id) {
+        super(id);
+    }
+
+    @Override
+    public Component getInfo() {
+        return Component.translatable("gtceu.module.ppe");
+    }
+
+    @Override
+    public boolean isPPE(AppliedItemModule module) {
+        return true;
+    }
+
+    @Override
+    public void appendHoverText(Level level, TooltipFlag isAdvanced, List<Component> tooltips,
+                                AppliedItemModule module) {
+        super.appendHoverText(level, isAdvanced, tooltips, module);
+        if (module.getAppliedTo().is(Tags.Items.ARMORS_BOOTS))
+            tooltips.add(Component.translatable("item.gtceu.hazmat_boots"));
+        if (module.getAppliedTo().is(Tags.Items.ARMORS_LEGGINGS))
+            tooltips.add(Component.translatable("item.gtceu.hazmat_leggings"));
+        if (module.getAppliedTo().is(Tags.Items.ARMORS_CHESTPLATES))
+            tooltips.add(Component.translatable("item.gtceu.hazmat_chestpiece"));
+        if (module.getAppliedTo().is(Tags.Items.ARMORS_HELMETS))
+            tooltips.add(Component.translatable("item.gtceu.hazmat_headpiece"));
+    }
+}
diff --git a/src/main/java/com/gregtechceu/gtceu/common/module/SensorItemModule.java b/src/main/java/com/gregtechceu/gtceu/common/module/SensorItemModule.java
new file mode 100644
index 00000000000..0175b3e22c7
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/common/module/SensorItemModule.java
@@ -0,0 +1,31 @@
+package com.gregtechceu.gtceu.common.module;
+
+import com.gregtechceu.gtceu.api.GTValues;
+import com.gregtechceu.gtceu.api.item.module.AppliedItemModule;
+import com.gregtechceu.gtceu.api.item.module.TieredItemModule;
+
+import net.minecraft.network.chat.Component;
+import net.minecraft.resources.ResourceLocation;
+import net.minecraft.world.item.TooltipFlag;
+import net.minecraft.world.level.Level;
+
+import java.util.List;
+
+public class SensorItemModule extends TieredItemModule {
+
+    public SensorItemModule(ResourceLocation id, int tier) {
+        super(id, tier);
+    }
+
+    @Override
+    public Component getInfo() {
+        return Component.translatable("gtceu.module.sensor");
+    }
+
+    @Override
+    public void appendHoverText(Level level, TooltipFlag isAdvanced, List<Component> tooltips,
+                                AppliedItemModule module) {
+        super.appendHoverText(level, isAdvanced, tooltips, module);
+        tooltips.add(Component.translatable("metaarmor.tooltip.modifier.sensor", GTValues.VNF[getTier()]));
+    }
+}
diff --git a/src/main/java/com/gregtechceu/gtceu/common/module/SneakSpeedItemModule.java b/src/main/java/com/gregtechceu/gtceu/common/module/SneakSpeedItemModule.java
new file mode 100644
index 00000000000..f0a8b255db8
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/common/module/SneakSpeedItemModule.java
@@ -0,0 +1,70 @@
+package com.gregtechceu.gtceu.common.module;
+
+import com.gregtechceu.gtceu.api.GTValues;
+import com.gregtechceu.gtceu.api.item.module.AppliedItemModule;
+import com.gregtechceu.gtceu.api.item.module.TieredItemModule;
+import com.gregtechceu.gtceu.utils.input.SyncedKeyMappings;
+
+import net.minecraft.network.chat.Component;
+import net.minecraft.resources.ResourceLocation;
+import net.minecraft.world.entity.LivingEntity;
+import net.minecraft.world.entity.player.Player;
+import net.minecraft.world.item.TooltipFlag;
+import net.minecraft.world.level.Level;
+import net.minecraft.world.phys.Vec3;
+
+import java.util.List;
+
+public class SneakSpeedItemModule extends TieredItemModule {
+
+    public SneakSpeedItemModule(ResourceLocation id, int tier) {
+        super(id, tier);
+    }
+
+    @Override
+    public Component getInfo() {
+        return Component.translatable("gtceu.module.sneak_speed", getTier() * 100 / 8f);
+    }
+
+    @Override
+    public void onArmorTick(LivingEntity entity, AppliedItemModule module) {
+        super.onArmorTick(entity, module);
+        if (entity instanceof Player player) {
+            float mul = getTier() / 8f + 1;
+            boolean jumping = SyncedKeyMappings.VANILLA_JUMP.isKeyDown(player);
+            boolean sneaking = SyncedKeyMappings.VANILLA_SNEAK.isKeyDown(player);
+
+            if (player.onGround() && sneaking) {
+                float speed = 0.25F * mul;
+                if (player.isInWater()) {
+                    speed = 0.1F * mul;
+                    if (jumping) {
+                        player.push(0.0, 0.1, 0.0);
+                    }
+                }
+                player.moveRelative(speed, new Vec3(0, 0, 1));
+            }
+        }
+    }
+
+    @Override
+    public boolean useEnergyInInventory(LivingEntity entity, AppliedItemModule module) {
+        return false;
+    }
+
+    @Override
+    public long energyUsagePerTick(LivingEntity entity, AppliedItemModule module) {
+        if (entity instanceof Player player) {
+            return SyncedKeyMappings.VANILLA_FORWARD.isKeyDown(player) && player.isShiftKeyDown() ? 819 : 0;
+        }
+        return 0;
+    }
+
+    @Override
+    public void appendHoverText(Level level, TooltipFlag isAdvanced, List<Component> tooltips,
+                                AppliedItemModule module) {
+        super.appendHoverText(level, isAdvanced, tooltips, module);
+        tooltips.add(Component.translatable("metaarmor.tooltip.modifier.sneak_speed",
+                GTValues.VNF[getTier()]));
+    }
+}
diff --git a/src/main/java/com/gregtechceu/gtceu/common/module/SpeedItemModule.java b/src/main/java/com/gregtechceu/gtceu/common/module/SpeedItemModule.java
new file mode 100644
index 00000000000..3a5de7120a1
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/common/module/SpeedItemModule.java
@@ -0,0 +1,77 @@
+package com.gregtechceu.gtceu.common.module;
+
+import com.gregtechceu.gtceu.api.GTValues;
+import com.gregtechceu.gtceu.api.item.module.AppliedItemModule;
+import com.gregtechceu.gtceu.api.item.module.TieredItemModule;
+import com.gregtechceu.gtceu.utils.input.SyncedKeyMappings;
+
+import net.minecraft.network.chat.Component;
+import net.minecraft.resources.ResourceLocation;
+import net.minecraft.world.entity.LivingEntity;
+import net.minecraft.world.entity.player.Player;
+import net.minecraft.world.item.TooltipFlag;
+import net.minecraft.world.level.Level;
+import net.minecraft.world.phys.Vec3;
+
+import java.util.List;
+
+public class SpeedItemModule extends TieredItemModule {
+
+    private static final double SPEED_ACCEL = 0.085D;
+
+    public SpeedItemModule(ResourceLocation id, int tier) {
+        super(id, tier);
+    }
+
+    @Override
+    public Component getInfo() {
+        return Component.translatable("gtceu.module.speed", getTier() * 25);
+    }
+
+    @Override
+    public void onArmorTick(LivingEntity entity, AppliedItemModule modifier) {
+        super.onArmorTick(entity, modifier);
+        if (entity instanceof Player player) {
+            float mul = getTier() / 4f + 1;
+            boolean sprinting = SyncedKeyMappings.VANILLA_FORWARD.isKeyDown(player) && player.isSprinting();
+            boolean jumping = SyncedKeyMappings.VANILLA_JUMP.isKeyDown(player);
+            boolean sneaking = SyncedKeyMappings.VANILLA_SNEAK.isKeyDown(player);
+
+            if ((player.onGround() || player.isInWater()) && sprinting) {
+                float speed = 0.25F * mul;
+                if (player.isInWater()) {
+                    speed = 0.1F * mul;
+                    if (jumping) {
+                        player.push(0.0, 0.1, 0.0);
+                    }
+                }
+                player.moveRelative(speed, new Vec3(0, 0, 1));
+            } else if (player.isInWater() && (sneaking || jumping)) {
+                if (sneaking)
+                    player.push(0.0, -SPEED_ACCEL * mul, 0.0);
+                if (jumping)
+                    player.push(0.0, SPEED_ACCEL * mul, 0.0);
+            }
+        }
+    }
+
+    @Override
+    public void appendHoverText(Level level, TooltipFlag isAdvanced, List<Component> tooltips,
+                                AppliedItemModule module) {
+        super.appendHoverText(level, isAdvanced, tooltips, module);
+        tooltips.add(Component.translatable("metaarmor.tooltip.modifier.speed", GTValues.VNF[getTier()]));
+    }
+
+    @Override
+    public long energyUsagePerTick(LivingEntity entity, AppliedItemModule module) {
+        if (entity instanceof Player player) {
+            return SyncedKeyMappings.VANILLA_FORWARD.isKeyDown(player) && player.isSprinting() ? 819 : 0;
+        }
+        return 0;
+    }
+
+    @Override
+    public boolean useEnergyInInventory(LivingEntity entity, AppliedItemModule module) {
+        return false;
+    }
+}
diff --git a/src/main/java/com/gregtechceu/gtceu/common/module/StepHeightModule.java b/src/main/java/com/gregtechceu/gtceu/common/module/StepHeightModule.java
new file mode 100644
index 00000000000..497a8446098
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/common/module/StepHeightModule.java
@@ -0,0 +1,50 @@
+package com.gregtechceu.gtceu.common.module;
+
+import com.gregtechceu.gtceu.api.GTValues;
+import com.gregtechceu.gtceu.api.item.module.AppliedItemModule;
+import com.gregtechceu.gtceu.api.item.module.TieredAttributeItemModule;
+
+import net.minecraft.network.chat.Component;
+import net.minecraft.resources.ResourceLocation;
+import net.minecraft.world.entity.ai.attributes.Attribute;
+import net.minecraft.world.entity.ai.attributes.AttributeModifier;
+import net.minecraft.world.item.TooltipFlag;
+import net.minecraft.world.level.Level;
+import net.minecraftforge.common.ForgeMod;
+
+import java.util.List;
+import java.util.UUID;
+
+public class StepHeightModule extends TieredAttributeItemModule {
+
+    private static final UUID ADD_STEP_HEIGHT_UUID = UUID.fromString("f5bd81ea-b3af-4cca-8866-f3e62f5f68f1");
+
+    public StepHeightModule(ResourceLocation id, int tier) {
+        super(id, tier);
+    }
+
+    @Override
+    public Component getInfo() {
+        return Component.translatable("gtceu.module.step_height", getTier() / 8d);
+    }
+
+    @Override
+    public Attribute getAttribute(AppliedItemModule module) {
+        return ForgeMod.STEP_HEIGHT_ADDITION.get();
+    }
+
+    @Override
+    public AttributeModifier getAttributeModifier(AppliedItemModule module) {
+        double add = getTier() / 8d;
+        return new AttributeModifier(ADD_STEP_HEIGHT_UUID, "Step Height Modifier", add,
+                AttributeModifier.Operation.ADDITION);
+    }
+
+    @Override
+    public void appendHoverText(Level level, TooltipFlag isAdvanced, List<Component> tooltips,
+                                AppliedItemModule module) {
+        super.appendHoverText(level, isAdvanced, tooltips, module);
+        tooltips.add(Component.translatable("metaarmor.tooltip.modifier.step_height",
+                GTValues.VN[getTier()]));
+    }
+}
diff --git a/src/main/java/com/gregtechceu/gtceu/common/module/SwimSpeedModule.java b/src/main/java/com/gregtechceu/gtceu/common/module/SwimSpeedModule.java
new file mode 100644
index 00000000000..8e581ed6577
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/common/module/SwimSpeedModule.java
@@ -0,0 +1,50 @@
+package com.gregtechceu.gtceu.common.module;
+
+import com.gregtechceu.gtceu.api.GTValues;
+import com.gregtechceu.gtceu.api.item.module.AppliedItemModule;
+import com.gregtechceu.gtceu.api.item.module.TieredAttributeItemModule;
+
+import net.minecraft.network.chat.Component;
+import net.minecraft.resources.ResourceLocation;
+import net.minecraft.world.entity.ai.attributes.Attribute;
+import net.minecraft.world.entity.ai.attributes.AttributeModifier;
+import net.minecraft.world.item.TooltipFlag;
+import net.minecraft.world.level.Level;
+import net.minecraftforge.common.ForgeMod;
+
+import java.util.List;
+import java.util.UUID;
+
+public class SwimSpeedModule extends TieredAttributeItemModule {
+
+    private static final UUID MUL_SWIM_SPEED_UUID = UUID.fromString("e5bd81ea-b3af-4cca-8866-f3e62f5f68f1");
+
+    public SwimSpeedModule(ResourceLocation id, int tier) {
+        super(id, tier);
+    }
+
+    @Override
+    public Component getInfo() {
+        return Component.translatable("gtceu.module.swim_speed", getTier() * 100 / 8d);
+    }
+
+    @Override
+    public Attribute getAttribute(AppliedItemModule module) {
+        return ForgeMod.SWIM_SPEED.get();
+    }
+
+    @Override
+    public AttributeModifier getAttributeModifier(AppliedItemModule module) {
+        double mul = 1 + getTier() / 8d;
+        return new AttributeModifier(MUL_SWIM_SPEED_UUID, "Swim Speed Modifier", mul,
+                AttributeModifier.Operation.MULTIPLY_TOTAL);
+    }
+
+    @Override
+    public void appendHoverText(Level level, TooltipFlag isAdvanced, List<Component> tooltips,
+                                AppliedItemModule module) {
+        super.appendHoverText(level, isAdvanced, tooltips, module);
+        tooltips.add(Component.translatable("metaarmor.tooltip.modifier.swim_speed",
+                GTValues.VNF[getTier()]));
+    }
+}
diff --git a/src/main/java/com/gregtechceu/gtceu/common/mui/GTByteBufAdapters.java b/src/main/java/com/gregtechceu/gtceu/common/mui/GTByteBufAdapters.java
new file mode 100644
index 00000000000..f505a7f85f3
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/common/mui/GTByteBufAdapters.java
@@ -0,0 +1,77 @@
+package com.gregtechceu.gtceu.common.mui;
+
+import com.gregtechceu.gtceu.api.recipe.GTRecipe;
+import com.gregtechceu.gtceu.api.recipe.GTRecipeSerializer;
+import com.gregtechceu.gtceu.common.machine.multiblock.electric.monitor.MonitorGroup;
+
+import net.minecraft.network.FriendlyByteBuf;
+import net.minecraft.network.chat.Component;
+import net.minecraft.resources.ResourceLocation;
+
+import brachy.modularui.utils.EqualityTest;
+import brachy.modularui.utils.serialization.network.*;
+import com.mojang.serialization.Codec;
+import com.mojang.serialization.JsonOps;
+import org.jetbrains.annotations.Nullable;
+
+import java.util.Objects;
+
+public class GTByteBufAdapters {
+
+    // spotless:off
+    public static final IByteBufAdapter<MonitorGroup> MONITOR_GROUPS = makeAdapter(MonitorGroup.CODEC);
+    public static final IByteBufAdapter<Component> COMPONENT = ByteBufAdapters.makeAdapter(FriendlyByteBuf::readComponent, FriendlyByteBuf::writeComponent,
+            (a, b) -> Objects.equals(a.toString(), b.toString()));
+
+    // spotless:on
+
+    public static final IByteBufAdapter<GTRecipe> GTRECIPE = new IByteBufAdapter<>() {
+
+        @Override
+        public @Nullable GTRecipe deserialize(FriendlyByteBuf buffer) {
+            if (!buffer.readBoolean()) {
+                return null;
+            }
+            ResourceLocation id = buffer.readResourceLocation();
+            return GTRecipeSerializer.SERIALIZER.fromNetwork(id, buffer);
+        }
+
+        @Override
+        public void serialize(FriendlyByteBuf buffer, @Nullable GTRecipe u) {
+            if (u == null) {
+                buffer.writeBoolean(false);
+                return;
+            }
+            buffer.writeBoolean(true);
+            buffer.writeResourceLocation(u.getId());
+            GTRecipeSerializer.SERIALIZER.toNetwork(buffer, u);
+        }
+
+        @Override
+        public boolean areEqual(GTRecipe t1, GTRecipe t2) {
+            return EqualityTest.wrapNullSafe(GTRecipe::equals).areEqual(t1, t2);
+        }
+    };
+
+    public static <T> IByteBufAdapter<T> makeAdapter(Codec<T> codec) {
+        return new IByteBufAdapter<>() {
+
+            @Override
+            public T deserialize(FriendlyByteBuf buffer) {
+                return buffer.readJsonWithCodec(codec);
+            }
+
+            @Override
+            public void serialize(FriendlyByteBuf buffer, T u) {
+                buffer.writeJsonWithCodec(codec, u);
+            }
+
+            @Override
+            public boolean areEqual(T a, T b) {
+                String encoded1 = codec.encodeStart(JsonOps.INSTANCE, a).result().orElseThrow().toString();
+                String encoded2 = codec.encodeStart(JsonOps.INSTANCE, b).result().orElseThrow().toString();
+                return Objects.equals(encoded1, encoded2);
+            }
+        };
+    }
+}
diff --git a/src/main/java/com/gregtechceu/gtceu/common/mui/GTGuiTextures.java b/src/main/java/com/gregtechceu/gtceu/common/mui/GTGuiTextures.java
new file mode 100644
index 00000000000..e41ca5173b4
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/common/mui/GTGuiTextures.java
@@ -0,0 +1,755 @@
+package com.gregtechceu.gtceu.common.mui;
+
+import com.gregtechceu.gtceu.GTCEu;
+import com.gregtechceu.gtceu.api.GTValues;
+
+import net.minecraft.resources.ResourceLocation;
+
+import brachy.modularui.api.GuiAxis;
+import brachy.modularui.drawable.ColorType;
+import brachy.modularui.drawable.TabTexture;
+import brachy.modularui.drawable.UITexture;
+import org.jetbrains.annotations.NotNull;
+
+@SuppressWarnings("unused")
+public class GTGuiTextures {
+
+    /** Keys used for GT assets registered for use in Themes */
+    public static class IDs {
+
+        public static final String STANDARD_BACKGROUND = "gregtech_standard_bg";
+        public static final String STANDARD_BACKGROUND_INVERSE = "gregtech_standard_inverse_bg";
+        public static final String COVER_BACKGROUND = "gregtech_cover_bg";
+        public static final String BRONZE_BACKGROUND = "gregtech_bronze_bg";
+        public static final String STEEL_BACKGROUND = "gregtech_steel_bg";
+        public static final String PRIMITIVE_BACKGROUND = "gregtech_primitive_bg";
+        public static final String EQUIPMENT_FOUNDRY_BACKGROUND = "gregtech_equipment_foundry_bg";
+
+        public static final String STANDARD_SLOT = "gregtech_standard_slot";
+        public static final String BRONZE_SLOT = "gregtech_bronze_slot";
+        public static final String STEEL_SLOT = "gregtech_steel_slot";
+        public static final String PRIMITIVE_SLOT = "gregtech_primitive_slot";
+
+        public static final String STANDARD_FLUID_SLOT = "gregtech_standard_fluid_slot";
+
+        public static final String STANDARD_BUTTON = "gregtech_standard_button";
+    }
+
+    public static final ResourceLocation MONOCRAFT_FONT = GTCEu.id("monocraft");
+
+    // ICONS
+
+    /** @apiNote You may want {@link GTGuiTextures#getLogo} instead. */
+    public static final UITexture GREGTECH_LOGO = fullImage("textures/gui/icon/gregtech_logo.png");
+    /** @apiNote You may want {@link GTGuiTextures#getLogo} instead. */
+    public static final UITexture GREGTECH_LOGO_XMAS = fullImage("textures/gui/icon/gregtech_logo_xmas.png");
+    public static final UITexture GREGTECH_LOGO_DARK = fullImage("textures/gui/icon/gregtech_logo_dark.png");
+    // todo blinking GT logos
+
+    public static final UITexture INDICATOR_NO_ENERGY = fullImage("textures/gui/base/indicator_no_energy.png");
+    public static final UITexture INDICATOR_NO_STEAM_BRONZE = fullImage(
+            "textures/gui/base/indicator_no_steam_bronze.png");
+    public static final UITexture INDICATOR_NO_STEAM_STEEL = fullImage(
+            "textures/gui/base/indicator_no_steam_steel.png");
+    public static final UITexture TANK_ICON = fullImage("textures/gui/base/tank_icon.png");
+
+    // BACKGROUNDS
+    public static final UITexture BACKGROUND = UITexture.builder()
+            .location(GTCEu.MOD_ID, "textures/gui/base/background.png")
+            .imageSize(16, 16)
+            .adaptable(4)
+            .name(IDs.STANDARD_BACKGROUND)
+            .defaultColorType()
+            .build();
+
+    public static final UITexture BACKGROUND_POPUP = UITexture.builder()
+            .location(GTCEu.MOD_ID, "textures/gui/base/background_popup.png")
+            .imageSize(195, 136)
+            .adaptable(4)
+            .name(IDs.COVER_BACKGROUND)
+            .canApplyTheme()
+            .build();
+
+    public static final UITexture BACKGROUND_INVERSE = UITexture.builder()
+            .location(GTCEu.MOD_ID, "textures/gui/base/background_inverse.png")
+            .imageSize(16, 16)
+            .adaptable(3)
+            .name(IDs.STANDARD_BACKGROUND_INVERSE)
+            .canApplyTheme()
+            .build();
+
+    public static final UITexture BACKGROUND_BRONZE = UITexture.builder()
+            .location(GTCEu.MOD_ID, "textures/gui/base/background_bronze.png")
+            .imageSize(16, 16)
+            .adaptable(4)
+            .name(IDs.BRONZE_BACKGROUND)
+            .build();
+
+    public static final UITexture BACKGROUND_STEEL = UITexture.builder()
+            .location(GTCEu.MOD_ID, "textures/gui/base/background_steel.png")
+            .imageSize(16, 16)
+            .adaptable(4)
+            .name(IDs.STEEL_BACKGROUND)
+            .build();
+
+    public static final UITexture BACKGROUND_EQUIPMENT_FOUNDRY = UITexture.builder()
+            .location(GTCEu.MOD_ID, "textures/gui/widget/equipment_foundry_background.png")
+            .imageSize(168, 75)
+            .adaptable(4)
+            .name(IDs.EQUIPMENT_FOUNDRY_BACKGROUND)
+            .build();
+
+    public static final UITexture BLANK_TRANSPARENT = fullImage("textures/gui/base/blank_transparent.png");
+
+    // todo move to textures/gui/base
+    public static final UITexture BACKGROUND_PRIMITIVE = UITexture.builder()
+            .location(GTCEu.MOD_ID, "textures/gui/primitive/primitive_background.png")
+            .imageSize(176, 166)
+            .adaptable(3)
+            .name(IDs.PRIMITIVE_BACKGROUND)
+            .build();
+
+    // todo clipboard backgrounds, may deserve some redoing
+
+    // DISPLAYS
+    public static final UITexture DISPLAY = new UITexture.Builder()
+            .location(GTCEu.MOD_ID, "textures/gui/base/display.png")
+            .imageSize(182, 117)
+            .canApplyTheme()
+            .build();
+
+    public static final UITexture DISPLAY_BRONZE = new UITexture.Builder()
+            .location(GTCEu.MOD_ID, "textures/gui/base/display_bronze.png")
+            .imageSize(162, 121)
+            .build();
+
+    public static final UITexture DISPLAY_STEEL = new UITexture.Builder()
+            .location(GTCEu.MOD_ID, "textures/gui/base/display_steel.png")
+            .imageSize(162, 121)
+            .adaptable(1)
+            .build();
+
+    // todo primitive display?
+
+    // SLOTS
+    public static final UITexture SLOT = new UITexture.Builder()
+            .location(GTCEu.MOD_ID, "textures/gui/base/slot.png")
+            .imageSize(18, 18)
+            .adaptable(1)
+            .name(IDs.STANDARD_SLOT)
+            .canApplyTheme()
+            .build();
+
+    public static final UITexture SLOT_BRONZE = new UITexture.Builder()
+            .location(GTCEu.MOD_ID, "textures/gui/base/slot_bronze.png")
+            .imageSize(18, 18)
+            .adaptable(1)
+            .name(IDs.BRONZE_SLOT)
+            .build();
+
+    public static final UITexture SLOT_STEEL = new UITexture.Builder()
+            .location(GTCEu.MOD_ID, "textures/gui/base/slot_steel.png")
+            .imageSize(18, 18)
+            .adaptable(1)
+            .name(IDs.STEEL_SLOT)
+            .build();
+
+    // todo move to textures/gui/base
+    public static final UITexture SLOT_PRIMITIVE = new UITexture.Builder()
+            .location(GTCEu.MOD_ID, "textures/gui/primitive/primitive_slot.png")
+            .imageSize(18, 18)
+            .adaptable(1)
+            .name(IDs.PRIMITIVE_SLOT)
+            .build();
+
+    public static final UITexture FLUID_SLOT = new UITexture.Builder()
+            .location(GTCEu.MOD_ID, "textures/gui/base/fluid_slot.png")
+            .imageSize(18, 18)
+            .adaptable(1)
+            .name(IDs.STANDARD_FLUID_SLOT)
+            .canApplyTheme()
+            .build();
+
+    public static final UITexture[] BUTTON_POWER = slice("textures/gui/widget/button_power.png", 16, 32, 16, 16,
+            ColorType.DEFAULT);
+
+    public static final UITexture BUTTON_BLACKLIST = fullImage("textures/gui/widget/button_blacklist.png",
+            ColorType.DEFAULT);
+    public static final UITexture[] BUTTON_IGNORE_DAMAGE = slice("textures/gui/widget/button_filter_damage.png",
+            16, 32, 16, 16, ColorType.DEFAULT);
+    public static final UITexture BUTTON_IGNORE_NBT = fullImage("textures/gui/widget/button_filter_nbt.png",
+            ColorType.DEFAULT);
+
+    public static final UITexture[] BUTTON_CASE_SENSITIVE = slice(
+            "textures/gui/widget/ore_filter/button_case_sensitive.png",
+            16, 32, 16, 16, ColorType.DEFAULT);
+
+    public static final UITexture[] BUTTON_MATCH_ALL = slice("textures/gui/widget/ore_filter/button_match_all.png",
+            16, 32, 16, 16, ColorType.DEFAULT);
+    public static final UITexture BUTTON_LOCK = fullImage("textures/gui/widget/button_lock.png");
+
+    public static final UITexture OREDICT_ERROR = fullImage("textures/gui/widget/ore_filter/error.png");
+    public static final UITexture OREDICT_INFO = fullImage("textures/gui/widget/ore_filter/info.png");
+    public static final UITexture OREDICT_MATCH = fullImage("textures/gui/widget/ore_filter/match.png");
+    public static final UITexture OREDICT_NO_MATCH = fullImage("textures/gui/widget/ore_filter/no_match.png");
+    public static final UITexture OREDICT_SUCCESS = fullImage("textures/gui/widget/ore_filter/success.png");
+    public static final UITexture OREDICT_WAITING = fullImage("textures/gui/widget/ore_filter/waiting.png");
+    public static final UITexture OREDICT_WARN = fullImage("textures/gui/widget/ore_filter/warn.png");
+
+    public static final UITexture INFO = fullImage("textures/gui/widget/information.png");
+
+    public static final UITexture[] MANUAL_IO_OVERLAY_IN = { fullImage("textures/gui/icon/manual_io_mode/disabled.png"),
+            fullImage("textures/gui/icon/manual_io_mode/filtered.png"),
+            fullImage("textures/gui/icon/manual_io_mode/unfiltered.png") };
+    public static final UITexture[] MANUAL_IO_OVERLAY_OUT = slice("textures/gui/overlay/manual_io_overlay_out.png",
+            18, 18 * 3, 18, 18, ColorType.DEFAULT);
+    public static final UITexture[] CONVEYOR_MODE_OVERLAY = slice("textures/gui/overlay/conveyor_mode_overlay.png",
+            18, 18 * 2, 18, 18, ColorType.DEFAULT);
+
+    public static final UITexture[] TRANSFER_MODE_OVERLAY = slice("textures/gui/overlay/transfer_mode_overlay.png",
+            40, 40 * 3, 40, 40, ColorType.DEFAULT);
+
+    public static final UITexture[] BUTTON_DISTINCT = slice(
+            "textures/gui/widget/button_distinct_buses.png",
+            16, 32, 16, 16, ColorType.DEFAULT);
+
+    public static final UITexture[] FLUID_TRANSFER_MODE_OVERLAY = slice(
+            "textures/gui/overlay/fluid_transfer_mode_overlay.png",
+            18, 18 * 3, 18, 18, ColorType.DEFAULT);
+
+    public static final UITexture[] DISTRIBUTION_MODE_OVERLAY = slice(
+            "textures/gui/widget/button_distribution_mode.png",
+            16, 48, 16, 16, ColorType.DEFAULT);
+
+    public static final UITexture[] VOIDING_MODES = { fullImage("textures/gui/icon/voiding_mode/void_any.png"),
+            fullImage("textures/gui/icon/voiding_mode/void_overflow.png") };
+
+    public static final UITexture BUTTON_VOID = fullImage("textures/gui/widget/button_void.png");
+
+    public static final UITexture BUTTON_VOID_PARTIAL = fullImage("textures/gui/widget/button_void_partial.png");
+
+    public static final UITexture[] BUTTON_VOID_MULTIBLOCK = slice("textures/gui/widget/button_void_multiblock.png",
+            16, 48, 16, 16, ColorType.DEFAULT);
+
+    public static final UITexture[] FILTER_MODE_OVERLAY = slice(
+            "textures/gui/overlay/filter_mode_overlay.png",
+            16, 48, 16, 16, ColorType.DEFAULT);
+
+    public static final UITexture[] PRIVATE_MODE_BUTTON = slice(
+            "textures/gui/widget/button_public_private.png",
+            18, 36, 18, 18, ColorType.DEFAULT);
+
+    public static final UITexture MENU_OVERLAY = fullImage("textures/gui/overlay/menu_overlay.png");
+
+    public static final UITexture RECIPE_LOCK = fullImage("textures/gui/widget/lock.png");
+
+    // todo bronze/steel/primitive fluid slots?
+
+    // SLOT OVERLAYS
+    public static final UITexture ATOMIC_OVERLAY_1 = fullImage("textures/gui/overlay/atomic_overlay_1.png",
+            ColorType.DEFAULT);
+    public static final UITexture ATOMIC_OVERLAY_2 = fullImage("textures/gui/overlay/atomic_overlay_2.png",
+            ColorType.DEFAULT);
+    public static final UITexture ARROW_INPUT_OVERLAY = fullImage("textures/gui/overlay/arrow_input_overlay.png",
+            ColorType.DEFAULT);
+    public static final UITexture ARROW_OUTPUT_OVERLAY = fullImage("textures/gui/overlay/arrow_output_overlay.png",
+            ColorType.DEFAULT);
+    public static final UITexture BATTERY_OVERLAY = fullImage("textures/gui/overlay/battery_overlay.png",
+            ColorType.DEFAULT);
+    public static final UITexture BEAKER_OVERLAY_1 = fullImage("textures/gui/overlay/beaker_overlay_1.png",
+            ColorType.DEFAULT);
+    public static final UITexture BEAKER_OVERLAY_2 = fullImage("textures/gui/overlay/beaker_overlay_2.png",
+            ColorType.DEFAULT);
+    public static final UITexture BEAKER_OVERLAY_3 = fullImage("textures/gui/overlay/beaker_overlay_3.png",
+            ColorType.DEFAULT);
+    public static final UITexture BEAKER_OVERLAY_4 = fullImage("textures/gui/overlay/beaker_overlay_4.png",
+            ColorType.DEFAULT);
+    public static final UITexture BENDER_OVERLAY = fullImage("textures/gui/overlay/bender_overlay.png",
+            ColorType.DEFAULT);
+    public static final UITexture BOX_OVERLAY = fullImage("textures/gui/overlay/box_overlay.png", ColorType.DEFAULT);
+    public static final UITexture BOXED_OVERLAY = fullImage("textures/gui/overlay/boxed_overlay.png",
+            ColorType.DEFAULT);
+    public static final UITexture BREWER_OVERLAY = fullImage("textures/gui/overlay/brewer_overlay.png",
+            ColorType.DEFAULT);
+    public static final UITexture CANNER_OVERLAY = fullImage("textures/gui/overlay/canner_overlay.png",
+            ColorType.DEFAULT);
+    public static final UITexture CHARGER_OVERLAY = fullImage("textures/gui/overlay/charger_slot_overlay.png",
+            ColorType.DEFAULT);
+    public static final UITexture CANISTER_OVERLAY = fullImage("textures/gui/overlay/canister_overlay.png",
+            ColorType.DEFAULT);
+    public static final UITexture CANISTER_OVERLAY_BRONZE = fullImage(
+            "textures/gui/overlay/canister_overlay_bronze.png");
+    public static final UITexture CANISTER_OVERLAY_STEEL = fullImage("textures/gui/overlay/canister_overlay_steel.png");
+    public static final UITexture CENTRIFUGE_OVERLAY = fullImage("textures/gui/overlay/centrifuge_overlay.png",
+            ColorType.DEFAULT);
+    public static final UITexture CIRCUIT_OVERLAY = fullImage("textures/gui/overlay/circuit_overlay.png",
+            ColorType.DEFAULT);
+    public static final UITexture COAL_OVERLAY_BRONZE = fullImage("textures/gui/overlay/coal_overlay_bronze.png");
+    public static final UITexture COAL_OVERLAY_STEEL = fullImage("textures/gui/overlay/coal_overlay_steel.png");
+    public static final UITexture COMPRESSOR_OVERLAY = fullImage("textures/gui/overlay/compressor_overlay.png",
+            ColorType.DEFAULT);
+    public static final UITexture COMPRESSOR_OVERLAY_BRONZE = fullImage(
+            "textures/gui/overlay/compressor_overlay_bronze.png");
+    public static final UITexture COMPRESSOR_OVERLAY_STEEL = fullImage(
+            "textures/gui/overlay/compressor_overlay_steel.png");
+    public static final UITexture CRACKING_OVERLAY_1 = fullImage("textures/gui/overlay/cracking_overlay_1.png",
+            ColorType.DEFAULT);
+    public static final UITexture CRACKING_OVERLAY_2 = fullImage("textures/gui/overlay/cracking_overlay_2.png",
+            ColorType.DEFAULT);
+    public static final UITexture CRUSHED_ORE_OVERLAY = fullImage("textures/gui/overlay/crushed_ore_overlay.png",
+            ColorType.DEFAULT);
+    public static final UITexture CRUSHED_ORE_OVERLAY_BRONZE = fullImage(
+            "textures/gui/overlay/crushed_ore_overlay_bronze.png");
+    public static final UITexture CRUSHED_ORE_OVERLAY_STEEL = fullImage(
+            "textures/gui/overlay/crushed_ore_overlay_steel.png");
+    public static final UITexture CRYSTAL_OVERLAY = fullImage("textures/gui/overlay/crystal_overlay.png",
+            ColorType.DEFAULT);
+    public static final UITexture CUTTER_OVERLAY = fullImage("textures/gui/overlay/cutter_overlay.png",
+            ColorType.DEFAULT);
+    public static final UITexture DARK_CANISTER_OVERLAY = fullImage("textures/gui/overlay/dark_canister_overlay.png",
+            ColorType.DEFAULT);
+    public static final UITexture DUST_OVERLAY = fullImage("textures/gui/overlay/dust_overlay.png", ColorType.DEFAULT);
+    public static final UITexture DUST_OVERLAY_BRONZE = fullImage("textures/gui/overlay/dust_overlay_bronze.png");
+    public static final UITexture DUST_OVERLAY_STEEL = fullImage("textures/gui/overlay/dust_overlay_steel.png");
+    public static final UITexture PRIMITIVE_DUST_OVERLAY = fullImage(
+            "textures/gui/primitive/overlay_primitive_dust.png", ColorType.DEFAULT);
+    public static final UITexture EXTRACTOR_OVERLAY = fullImage("textures/gui/overlay/extractor_overlay.png",
+            ColorType.DEFAULT);
+    public static final UITexture EXTRACTOR_OVERLAY_BRONZE = fullImage(
+            "textures/gui/overlay/extractor_overlay_bronze.png");
+    public static final UITexture EXTRACTOR_OVERLAY_STEEL = fullImage(
+            "textures/gui/overlay/extractor_overlay_steel.png");
+    public static final UITexture FILTER_SLOT_OVERLAY = fullImage("textures/gui/overlay/filter_slot_overlay.png",
+            ColorType.DEFAULT);
+    public static final UITexture FILTER_SETTINGS_OVERLAY = fullImage(
+            "textures/gui/overlay/filter_settings_overlay.png",
+            ColorType.DEFAULT);
+    public static final UITexture FURNACE_OVERLAY_1 = fullImage("textures/gui/overlay/furnace_overlay_1.png",
+            ColorType.DEFAULT);
+    public static final UITexture FURNACE_OVERLAY_2 = fullImage("textures/gui/overlay/furnace_overlay_2.png",
+            ColorType.DEFAULT);
+    public static final UITexture FURNACE_OVERLAY_BRONZE = fullImage("textures/gui/overlay/furnace_overlay_bronze.png");
+    public static final UITexture FURNACE_OVERLAY_STEEL = fullImage("textures/gui/overlay/furnace_overlay_steel.png");
+    public static final UITexture PRIMITIVE_FURNACE_OVERLAY = fullImage(
+            "textures/gui/primitive/overlay_primitive_furnace.png",
+            ColorType.DEFAULT);
+    public static final UITexture PRIMITIVE_LARGE_FLUID_TANK = fullImage(
+            "textures/gui/primitive/primitive_large_fluid_tank.png",
+            ColorType.DEFAULT);
+    public static final UITexture PRIMITIVE_LARGE_FLUID_TANK_OVERLAY = fullImage(
+            "textures/gui/primitive/primitive_large_fluid_tank_overlay.png",
+            ColorType.DEFAULT);
+    public static final UITexture HAMMER_OVERLAY = fullImage("textures/gui/overlay/hammer_overlay.png",
+            ColorType.DEFAULT);
+    public static final UITexture HAMMER_OVERLAY_BRONZE = fullImage("textures/gui/overlay/hammer_overlay_bronze.png");
+    public static final UITexture HAMMER_OVERLAY_STEEL = fullImage("textures/gui/overlay/hammer_overlay_steel.png");
+    public static final UITexture HEATING_OVERLAY_1 = fullImage("textures/gui/overlay/heating_overlay_1.png",
+            ColorType.DEFAULT);
+    public static final UITexture HEATING_OVERLAY_2 = fullImage("textures/gui/overlay/heating_overlay_2.png",
+            ColorType.DEFAULT);
+    public static final UITexture IMPLOSION_OVERLAY_1 = fullImage("textures/gui/overlay/implosion_overlay_1.png",
+            ColorType.DEFAULT);
+    public static final UITexture IMPLOSION_OVERLAY_2 = fullImage("textures/gui/overlay/implosion_overlay_2.png",
+            ColorType.DEFAULT);
+    public static final UITexture IN_SLOT_OVERLAY = fullImage("textures/gui/overlay/in_slot_overlay.png",
+            ColorType.DEFAULT);
+    public static final UITexture IN_SLOT_OVERLAY_BRONZE = fullImage("textures/gui/overlay/in_slot_overlay_bronze.png");
+    public static final UITexture IN_SLOT_OVERLAY_STEEL = fullImage("textures/gui/overlay/in_slot_overlay_steel.png");
+    public static final UITexture INGOT_OVERLAY = fullImage("textures/gui/overlay/ingot_overlay.png",
+            ColorType.DEFAULT);
+    public static final UITexture PRIMITIVE_INGOT_OVERLAY = fullImage(
+            "textures/gui/primitive/overlay_primitive_ingot.png",
+            ColorType.DEFAULT);
+    public static final UITexture INT_CIRCUIT_OVERLAY = fullImage("textures/gui/overlay/int_circuit_overlay.png",
+            ColorType.DEFAULT);
+    public static final UITexture LENS_OVERLAY = fullImage("textures/gui/overlay/lens_overlay.png", ColorType.DEFAULT);
+    public static final UITexture LIGHTNING_OVERLAY_1 = fullImage("textures/gui/overlay/lightning_overlay_1.png",
+            ColorType.DEFAULT);
+    public static final UITexture LIGHTNING_OVERLAY_2 = fullImage("textures/gui/overlay/lightning_overlay_2.png",
+            ColorType.DEFAULT);
+    public static final UITexture MOLD_OVERLAY = fullImage("textures/gui/overlay/mold_overlay.png", ColorType.DEFAULT);
+    public static final UITexture MOLECULAR_OVERLAY_1 = fullImage("textures/gui/overlay/molecular_overlay_1.png",
+            ColorType.DEFAULT);
+    public static final UITexture MOLECULAR_OVERLAY_2 = fullImage("textures/gui/overlay/molecular_overlay_2.png",
+            ColorType.DEFAULT);
+    public static final UITexture MOLECULAR_OVERLAY_3 = fullImage("textures/gui/overlay/molecular_overlay_3.png",
+            ColorType.DEFAULT);
+    public static final UITexture MOLECULAR_OVERLAY_4 = fullImage("textures/gui/overlay/molecular_overlay_4.png",
+            ColorType.DEFAULT);
+    public static final UITexture OUT_SLOT_OVERLAY = fullImage("textures/gui/overlay/out_slot_overlay.png",
+            ColorType.DEFAULT);
+    public static final UITexture OUT_SLOT_OVERLAY_BRONZE = fullImage(
+            "textures/gui/overlay/out_slot_overlay_bronze.png");
+    public static final UITexture OUT_SLOT_OVERLAY_STEEL = fullImage("textures/gui/overlay/out_slot_overlay_steel.png");
+    public static final UITexture PAPER_OVERLAY = fullImage("textures/gui/overlay/paper_overlay.png",
+            ColorType.DEFAULT);
+    public static final UITexture PATTERN_OVERLAY = fullImage("textures/gui/widget/pattern_overlay.png",
+            ColorType.DEFAULT);
+    public static final UITexture PRINTED_PAPER_OVERLAY = fullImage("textures/gui/overlay/printed_paper_overlay.png",
+            ColorType.DEFAULT);
+    public static final UITexture PIPE_OVERLAY_2 = fullImage("textures/gui/overlay/pipe_overlay_2.png",
+            ColorType.DEFAULT);
+    public static final UITexture PIPE_OVERLAY_1 = fullImage("textures/gui/overlay/pipe_overlay_1.png",
+            ColorType.DEFAULT);
+    public static final UITexture PRESS_OVERLAY_1 = fullImage("textures/gui/overlay/press_overlay_1.png",
+            ColorType.DEFAULT);
+    public static final UITexture PRESS_OVERLAY_2 = fullImage("textures/gui/overlay/press_overlay_2.png",
+            ColorType.DEFAULT);
+    public static final UITexture PRESS_OVERLAY_3 = fullImage("textures/gui/overlay/press_overlay_3.png",
+            ColorType.DEFAULT);
+    public static final UITexture PRESS_OVERLAY_4 = fullImage("textures/gui/overlay/press_overlay_4.png",
+            ColorType.DEFAULT);
+    public static final UITexture REFUND_OVERLAY = fullImage("textures/gui/widget/refund_overlay.png",
+            ColorType.DEFAULT);
+    public static final UITexture SAWBLADE_OVERLAY = fullImage("textures/gui/overlay/sawblade_overlay.png",
+            ColorType.DEFAULT);
+    public static final UITexture SOLIDIFIER_OVERLAY = fullImage("textures/gui/overlay/solidifier_overlay.png",
+            ColorType.DEFAULT);
+    public static final UITexture STRING_SLOT_OVERLAY = fullImage("textures/gui/overlay/string_slot_overlay.png",
+            ColorType.DEFAULT);
+    public static final UITexture TOOL_SLOT_OVERLAY = fullImage("textures/gui/overlay/tool_slot_overlay.png",
+            ColorType.DEFAULT);
+    public static final UITexture TURBINE_OVERLAY = fullImage("textures/gui/overlay/turbine_overlay.png",
+            ColorType.DEFAULT);
+    public static final UITexture VIAL_OVERLAY_1 = fullImage("textures/gui/overlay/vial_overlay_1.png",
+            ColorType.DEFAULT);
+    public static final UITexture VIAL_OVERLAY_2 = fullImage("textures/gui/overlay/vial_overlay_2.png",
+            ColorType.DEFAULT);
+    public static final UITexture WIREMILL_OVERLAY = fullImage("textures/gui/overlay/wiremill_overlay.png",
+            ColorType.DEFAULT);
+    public static final UITexture POSITIVE_MATTER_OVERLAY = fullImage(
+            "textures/gui/overlay/positive_matter_overlay.png", ColorType.DEFAULT);
+    public static final UITexture NEUTRAL_MATTER_OVERLAY = fullImage("textures/gui/overlay/neutral_matter_overlay.png",
+            ColorType.DEFAULT);
+    public static final UITexture DATA_ORB_OVERLAY = fullImage("textures/gui/overlay/data_orb_overlay.png",
+            ColorType.DEFAULT);
+    public static final UITexture SCANNER_OVERLAY = fullImage("textures/gui/overlay/scanner_overlay.png",
+            ColorType.DEFAULT);
+    public static final UITexture DUCT_TAPE_OVERLAY = fullImage("textures/gui/overlay/duct_tape_overlay.png",
+            ColorType.DEFAULT);
+    public static final UITexture RESEARCH_STATION_OVERLAY = fullImage(
+            "textures/gui/overlay/research_station_overlay.png", ColorType.DEFAULT);
+    public static final UITexture OVERLAY_REDSTONE_ON = fullImage("textures/gui/overlay/redstone_on.png");
+    public static final UITexture OVERLAY_REDSTONE_OFF = fullImage("textures/gui/overlay/redstone_off.png");
+
+    // BUTTONS
+
+    public static final UITexture BUTTON = new UITexture.Builder()
+            .location(GTCEu.MOD_ID, "textures/gui/widget/button.png")
+            .imageSize(32, 32)
+            .adaptable(2)
+            .name(IDs.STANDARD_BUTTON)
+            .canApplyTheme()
+            .build();
+
+    // BUTTON OVERLAYS
+
+    public static final UITexture BUTTON_ITEM_OUTPUT = fullImage("textures/gui/widget/button_item_output_overlay.png");
+    public static final UITexture BUTTON_FLUID_OUTPUT = fullImage(
+            "textures/gui/widget/button_fluid_output_overlay.png");
+    public static final UITexture BUTTON_AUTO_COLLAPSE = fullImage(
+            "textures/gui/widget/button_auto_collapse_overlay.png");
+    public static final UITexture BUTTON_X = fullImage("textures/gui/widget/button_x_overlay.png", ColorType.DEFAULT);
+    public static final UITexture BUTTON_CLEAR_GRID = fullImage("textures/gui/widget/button_clear_grid.png", null);
+
+    public static final UITexture BUTTON_CROSS = fullImage("textures/gui/widget/button_clear_grid.png");
+    public static final UITexture BUTTON_DETECTOR_INVERT = fullImage(
+            "textures/gui/widget/button_detector_cover_inverted.png");
+    public static final UITexture BUTTON_REDSTONE_ON = fullImage("textures/gui/widget/button_redstone_on.png");
+    public static final UITexture BUTTON_REDSTONE_OFF = fullImage("textures/gui/widget/button_redstone_off.png");
+    public static final UITexture BUTTON_THROTTLE_PLUS = fullImage("textures/gui/widget/button_throttle_plus.png");
+    public static final UITexture BUTTON_THROTTLE_MINUS = fullImage("textures/gui/widget/button_throttle_minus.png");
+    public static final UITexture BUTTON_EU = fullImage("textures/gui/overlay/mode_eu.png");
+    public static final UITexture BUTTON_PERCENT = fullImage("textures/gui/overlay/mode_percent.png");
+    public static final UITexture BUTTON_MAINTENANCE = fullImage("textures/gui/widget/button_maintenance.png");
+
+    public static final UITexture BUTTON_AUTO_PULL = fullImage("textures/gui/widget/button_me_auto_pull.png");
+
+    // PROGRESS BARS
+    public static final UITexture PROGRESS_BAR_ARC_FURNACE = progressBar(
+            "textures/gui/progress_bar/progress_bar_arc_furnace.png", ColorType.DEFAULT);
+    public static final UITexture PRIMITIVE_BLAST_FURNACE_PROGRESS_BAR = progressBar(
+            "textures/gui/primitive/progress_bar_primitive_blast_furnace.png", ColorType.DEFAULT);
+    public static final UITexture PROGRESS_BAR_ARROW = progressBar("textures/gui/progress_bar/progress_bar_arrow.png",
+            ColorType.DEFAULT);
+    public static final UITexture PROGRESS_BAR_ARROW_BRONZE = progressBar(
+            "textures/gui/progress_bar/progress_bar_arrow_bronze.png");
+    public static final UITexture PROGRESS_BAR_ARROW_STEEL = progressBar(
+            "textures/gui/progress_bar/progress_bar_arrow_steel.png");
+    public static final UITexture PROGRESS_BAR_ARROW_MULTIPLE = progressBar(
+            "textures/gui/progress_bar/progress_bar_arrow_multiple.png", ColorType.DEFAULT);
+    public static final UITexture PROGRESS_BAR_ASSEMBLER = progressBar(
+            "textures/gui/progress_bar/progress_bar_assembler.png",
+            ColorType.DEFAULT);
+    public static final UITexture PROGRESS_BAR_BATH = progressBar("textures/gui/progress_bar/progress_bar_bath.png",
+            ColorType.DEFAULT);
+    public static final UITexture PROGRESS_BAR_BENDING = progressBar(
+            "textures/gui/progress_bar/progress_bar_bending.png", ColorType.DEFAULT);
+    public static final UITexture PROGRESS_BAR_CANNER = progressBar("textures/gui/progress_bar/progress_bar_canner.png",
+            ColorType.DEFAULT);
+    public static final UITexture PROGRESS_BAR_CIRCUIT = progressBar(
+            "textures/gui/progress_bar/progress_bar_circuit.png", ColorType.DEFAULT);
+    public static final UITexture PROGRESS_BAR_CIRCUIT_ASSEMBLER = progressBar(
+            "textures/gui/progress_bar/progress_bar_circuit_assembler.png", ColorType.DEFAULT);
+    public static final UITexture PROGRESS_BAR_COMPRESS = progressBar(
+            "textures/gui/progress_bar/progress_bar_compress.png", ColorType.DEFAULT);
+    public static final UITexture PROGRESS_BAR_COMPRESS_BRONZE = progressBar(
+            "textures/gui/progress_bar/progress_bar_compress_bronze.png");
+    public static final UITexture PROGRESS_BAR_COMPRESS_STEEL = progressBar(
+            "textures/gui/progress_bar/progress_bar_compress_steel.png");
+    public static final UITexture PROGRESS_BAR_CRACKING = progressBar(
+            "textures/gui/progress_bar/progress_bar_cracking.png", ColorType.DEFAULT);
+    public static final UITexture PROGRESS_BAR_CRACKING_INPUT = progressBar(
+            "textures/gui/progress_bar/progress_bar_cracking_2.png", 21, 38, ColorType.DEFAULT);
+    public static final UITexture PROGRESS_BAR_CRYSTALLIZATION = progressBar(
+            "textures/gui/progress_bar/progress_bar_crystallization.png", ColorType.DEFAULT);
+    public static final UITexture PROGRESS_BAR_EXTRACT = progressBar(
+            "textures/gui/progress_bar/progress_bar_extract.png", ColorType.DEFAULT);
+    public static final UITexture PROGRESS_BAR_EXTRACT_BRONZE = progressBar(
+            "textures/gui/progress_bar/progress_bar_extract_bronze.png");
+    public static final UITexture PROGRESS_BAR_EXTRACT_STEEL = progressBar(
+            "textures/gui/progress_bar/progress_bar_extract_steel.png");
+    public static final UITexture PROGRESS_BAR_EXTRUDER = progressBar(
+            "textures/gui/progress_bar/progress_bar_extruder.png", ColorType.DEFAULT);
+    public static final UITexture PROGRESS_BAR_FUSION = progressBar("textures/gui/progress_bar/progress_bar_fusion.png",
+            ColorType.DEFAULT);
+    public static final UITexture PROGRESS_BAR_GAS_COLLECTOR = progressBar(
+            "textures/gui/progress_bar/progress_bar_gas_collector.png", ColorType.DEFAULT);
+    public static final UITexture PROGRESS_BAR_HAMMER = progressBar("textures/gui/progress_bar/progress_bar_hammer.png",
+            ColorType.DEFAULT);
+    public static final UITexture PROGRESS_BAR_HAMMER_BRONZE = progressBar(
+            "textures/gui/progress_bar/progress_bar_hammer_bronze.png");
+    public static final UITexture PROGRESS_BAR_HAMMER_STEEL = progressBar(
+            "textures/gui/progress_bar/progress_bar_hammer_steel.png");
+    public static final UITexture PROGRESS_BAR_HAMMER_BASE = fullImage(
+            "textures/gui/progress_bar/progress_bar_hammer_base.png", ColorType.DEFAULT);
+    public static final UITexture PROGRESS_BAR_HAMMER_BASE_BRONZE = fullImage(
+            "textures/gui/progress_bar/progress_bar_hammer_base_bronze.png");
+    public static final UITexture PROGRESS_BAR_HAMMER_BASE_STEEL = fullImage(
+            "textures/gui/progress_bar/progress_bar_hammer_base_steel.png");
+    public static final UITexture PROGRESS_BAR_LATHE = progressBar("textures/gui/progress_bar/progress_bar_lathe.png",
+            ColorType.DEFAULT);
+    public static final UITexture PROGRESS_BAR_LATHE_BASE = fullImage(
+            "textures/gui/progress_bar/progress_bar_lathe_base.png", ColorType.DEFAULT);
+    public static final UITexture PROGRESS_BAR_MACERATE = progressBar(
+            "textures/gui/progress_bar/progress_bar_macerate.png", ColorType.DEFAULT);
+    public static final UITexture PROGRESS_BAR_MACERATE_BRONZE = progressBar(
+            "textures/gui/progress_bar/progress_bar_macerate_bronze.png");
+    public static final UITexture PROGRESS_BAR_MACERATE_STEEL = progressBar(
+            "textures/gui/progress_bar/progress_bar_macerate_steel.png");
+    public static final UITexture PROGRESS_BAR_MAGNET = progressBar("textures/gui/progress_bar/progress_bar_magnet.png",
+            ColorType.DEFAULT);
+    public static final UITexture PROGRESS_BAR_MASS_FAB = progressBar(
+            "textures/gui/progress_bar/progress_bar_mass_fab.png", ColorType.DEFAULT);
+    public static final UITexture PROGRESS_BAR_MIXER = progressBar("textures/gui/progress_bar/progress_bar_mixer.png",
+            ColorType.DEFAULT);
+    public static final UITexture PROGRESS_BAR_PACKER = progressBar("textures/gui/progress_bar/progress_bar_packer.png",
+            ColorType.DEFAULT);
+    public static final UITexture PROGRESS_BAR_RECYCLER = progressBar(
+            "textures/gui/progress_bar/progress_bar_recycler.png", ColorType.DEFAULT);
+    public static final UITexture PROGRESS_BAR_REPLICATOR = progressBar(
+            "textures/gui/progress_bar/progress_bar_replicator.png", ColorType.DEFAULT);
+    public static final UITexture PROGRESS_BAR_SIFT = progressBar("textures/gui/progress_bar/progress_bar_sift.png",
+            ColorType.DEFAULT);
+    public static final UITexture PROGRESS_BAR_SLICE = progressBar("textures/gui/progress_bar/progress_bar_slice.png",
+            ColorType.DEFAULT);
+    public static final UITexture PROGRESS_BAR_UNPACKER = progressBar(
+            "textures/gui/progress_bar/progress_bar_unpacker.png", ColorType.DEFAULT);
+    public static final UITexture PROGRESS_BAR_WIREMILL = progressBar(
+            "textures/gui/progress_bar/progress_bar_wiremill.png", ColorType.DEFAULT);
+
+    // more custom progress bars
+    // todo these boiler empty bars can probably be replaced by using a resized steam slot texture
+    public static final UITexture PROGRESS_BAR_BOILER_EMPTY_BRONZE = new UITexture.Builder()
+            .location(GTCEu.MOD_ID, "textures/gui/progress_bar/progress_bar_boiler_empty_bronze.png")
+            .imageSize(10, 54)
+            .adaptable(1)
+            .build();
+    public static final UITexture PROGRESS_BAR_BOILER_EMPTY_STEEL = new UITexture.Builder()
+            .location(GTCEu.MOD_ID, "textures/gui/progress_bar/progress_bar_boiler_empty_steel.png")
+            .imageSize(10, 54)
+            .adaptable(1)
+            .build();
+    public static final UITexture PROGRESS_BAR_BOILER_FUEL_BRONZE = progressBar(
+            "textures/gui/progress_bar/progress_bar_boiler_fuel_bronze.png", 18, 36);
+    public static final UITexture PROGRESS_BAR_BOILER_FUEL_STEEL = progressBar(
+            "textures/gui/progress_bar/progress_bar_boiler_fuel_steel.png", 18, 36);
+    public static final UITexture PROGRESS_BAR_BOILER_HEAT = progressBar(
+            "textures/gui/progress_bar/progress_bar_boiler_heat.png", ColorType.DEFAULT);
+    public static final UITexture PROGRESS_BAR_ASSEMBLY_LINE = progressBar(
+            "textures/gui/progress_bar/progress_bar_assembly_line.png", 54, 144, ColorType.DEFAULT);
+    public static final UITexture PROGRESS_BAR_ASSEMBLY_LINE_ARROW = progressBar(
+            "textures/gui/progress_bar/progress_bar_assembly_line_arrow.png", 10, 36, ColorType.DEFAULT);
+    public static final UITexture PROGRESS_BAR_COKE_OVEN = progressBar(
+            "textures/gui/progress_bar/progress_bar_coke_oven.png", 36, 36, ColorType.DEFAULT);
+    public static final UITexture PROGRESS_BAR_DISTILLATION_TOWER = progressBar(
+            "textures/gui/progress_bar/progress_bar_distillation_tower.png", 66, 116, ColorType.DEFAULT);
+    public static final UITexture PROGRESS_BAR_SOLAR_BRONZE = progressBar(
+            "textures/gui/progress_bar/progress_bar_solar_bronze.png", 10, 20);
+    public static final UITexture PROGRESS_BAR_SOLAR_STEEL = progressBar(
+            "textures/gui/progress_bar/progress_bar_solar_steel.png", 10, 20);
+    public static final UITexture PROGRESS_BAR_RESEARCH_STATION_1 = progressBar(
+            "textures/gui/progress_bar/progress_bar_research_station_1.png", 54, 10, ColorType.DEFAULT);
+    public static final UITexture PROGRESS_BAR_RESEARCH_STATION_2 = progressBar(
+            "textures/gui/progress_bar/progress_bar_research_station_2.png", 10, 36, ColorType.DEFAULT);
+    public static final UITexture PROGRESS_BAR_RESEARCH_STATION_BASE = fullImage(
+            "textures/gui/progress_bar/progress_bar_research_station_base.png", ColorType.DEFAULT);
+    public static final UITexture PROGRESS_BAR_FUSION_ENERGY = progressBar(
+            "textures/gui/progress_bar/progress_bar_fusion_energy.png", 94, 14);
+    public static final UITexture PROGRESS_BAR_FUSION_HEAT = progressBar(
+            "textures/gui/progress_bar/progress_bar_fusion_heat.png", 94, 14);
+    public static final UITexture PROGRESS_BAR_MULTI_ENERGY_YELLOW = progressBar(
+            "textures/gui/progress_bar/progress_bar_multi_energy_yellow.png", 190, 14);
+    public static final UITexture PROGRESS_BAR_HPCA_COMPUTATION = progressBar(
+            "textures/gui/progress_bar/progress_bar_hpca_computation.png", 94, 14);
+    public static final UITexture PROGRESS_BAR_LCE_FUEL = progressBar(
+            "textures/gui/progress_bar/progress_bar_lce_fuel.png", 62, 14);
+    public static final UITexture PROGRESS_BAR_LCE_LUBRICANT = progressBar(
+            "textures/gui/progress_bar/progress_bar_lce_lubricant.png", 62, 14);
+    public static final UITexture PROGRESS_BAR_LCE_OXYGEN = progressBar(
+            "textures/gui/progress_bar/progress_bar_lce_oxygen.png", 62, 14);
+    public static final UITexture PROGRESS_BAR_TURBINE_ROTOR_SPEED = progressBar(
+            "textures/gui/progress_bar/progress_bar_turbine_rotor_speed.png", 62, 14);
+    public static final UITexture PROGRESS_BAR_TURBINE_ROTOR_DURABILITY = progressBar(
+            "textures/gui/progress_bar/progress_bar_turbine_rotor_durability.png", 62, 14);
+    public static final UITexture PROGRESS_BAR_FLUID_RIG_DEPLETION = progressBar(
+            "textures/gui/progress_bar/progress_bar_fluid_rig_depletion.png", 190, 14);
+
+    public static final UITexture CYCLE_BUTTON = UITexture.builder()
+            .location(GTCEu.MOD_ID, "textures/gui/widget/button_distribution_mode.png")
+            .imageSize(20, 60)
+            .name("cycle")
+            .build();
+    // 16, 48, 16, 16, true);
+
+    public static final TabTexture TAB_TOP = TabTexture.of(
+            fullImage("textures/gui/tab/tabs_top.png", ColorType.DEFAULT), GuiAxis.Y,
+            false,
+            28, 32, 4);
+
+    public static final UITexture MONITOR = UITexture.fullImage(GTCEu.MOD_ID, "item/computer_monitor_cover");
+    public static final UITexture DATA_HATCH = UITexture.fullImage(GTCEu.MOD_ID, "textures/item/data_module.png")
+            .getSubArea(0, 0, 1, 1 / 13f);
+
+    public static final UITexture SEPERATOR_SIMPLE = UITexture.builder()
+            .location(GTCEu.MOD_ID, "textures/gui/icon/seperator/seperator_simple.png")
+            .imageSize(16, 5)
+            .adaptable(2)
+            .build();
+
+    // HPCA
+    public static final UITexture HPCA_COMPUTATION_COMPONENT = fullImage(
+            "textures/gui/widget/hpca/computation_component.png");
+    public static final UITexture HPCA_ADVANCED_COMPUTATION_COMPONENT = fullImage(
+            "textures/gui/widget/hpca/advanced_computation_component.png");
+    public static final UITexture HPCA_DAMAGED_COMPUTATION_COMPONENT = fullImage(
+            "textures/gui/widget/hpca/damaged_computation_component.png");
+    public static final UITexture HPCA_DAMAGED_ADVANCED_COMPUTATION_COMPONENT = fullImage(
+            "textures/gui/widget/hpca/damaged_advanced_computation_component.png");
+    public static final UITexture HPCA_ACTIVE_COOLER_COMPONENT = fullImage(
+            "textures/gui/widget/hpca/active_cooler_component.png");
+    public static final UITexture HPCA_HEAT_SINK_COMPONENT = fullImage(
+            "textures/gui/widget/hpca/heat_sink_component.png");
+    public static final UITexture HPCA_EMPTY_COMPONENT = fullImage("textures/gui/widget/hpca/empty.png");
+    public static final UITexture HPCA_BRIDGE_COMPONENT = fullImage("textures/gui/widget/hpca/bridge_component.png");
+    public static final UITexture HPCA_COMPONENT_OUTLINE = fullImage("textures/gui/widget/hpca/component_outline.png");
+
+    // MACHINE GRID OVERLAYS
+
+    public static final UITexture TOOL_FRONT_FACING_ROTATION = fullImage(
+            "textures/gui/overlay/tool_front_facing_rotation.png");
+    public static final UITexture TOOL_IO_FACING_ROTATION = fullImage(
+            "textures/gui/overlay/tool_io_facing_rotation.png");
+    public static final UITexture TOOL_PAUSE = fullImage("textures/gui/overlay/tool_pause.png");
+    public static final UITexture TOOL_START = fullImage("textures/gui/overlay/tool_start.png");
+    public static final UITexture TOOL_COVER_SETTINGS = fullImage(
+            "textures/gui/overlay/tool_cover_settings.png");
+    public static final UITexture TOOL_MUTE = fullImage("textures/gui/overlay/tool_mute.png");
+    public static final UITexture TOOL_SOUND = fullImage("textures/gui/overlay/tool_sound.png");
+    public static final UITexture TOOL_ALLOW_INPUT = fullImage(
+            "textures/gui/overlay/tool_allow_input.png");
+    public static final UITexture TOOL_ATTACH_COVER = fullImage(
+            "textures/gui/overlay/tool_attach_cover.png");
+    public static final UITexture TOOL_REMOVE_COVER = fullImage(
+            "textures/gui/overlay/tool_remove_cover.png");
+    public static final UITexture TOOL_PIPE_BLOCK = fullImage(
+            "textures/gui/overlay/tool_pipe_block.png");
+    public static final UITexture TOOL_PIPE_CONNECT = fullImage(
+            "textures/gui/overlay/tool_pipe_connect.png");
+    public static final UITexture TOOL_WIRE_BLOCK = fullImage(
+            "textures/gui/overlay/tool_wire_block.png");
+    public static final UITexture TOOL_WIRE_CONNECT = fullImage(
+            "textures/gui/overlay/tool_wire_connect.png");
+    public static final UITexture TOOL_AUTO_OUTPUT = fullImage(
+            "textures/gui/overlay/tool_auto_output.png");
+    public static final UITexture TOOL_DISABLE_AUTO_OUTPUT = fullImage(
+            "textures/gui/overlay/tool_disable_auto_output.png");
+    public static final UITexture TOOL_SWITCH_CONVERTER_NATIVE = fullImage(
+            "textures/gui/overlay/tool_wire_block.png");
+    public static final UITexture TOOL_SWITCH_CONVERTER_EU = fullImage(
+            "textures/gui/overlay/tool_wire_connect.png");
+
+    // MISC
+
+    public static void init() {/**/}
+
+    private static UITexture fullImage(String path) {
+        return fullImage(path, null);
+    }
+
+    private static UITexture fullImage(String path, ColorType colorType) {
+        return UITexture.fullImage(GTCEu.MOD_ID, path, colorType);
+    }
+
+    @SuppressWarnings("SameParameterValue")
+    private static UITexture[] slice(String path, int imageWidth, int imageHeight, int sliceWidth, int sliceHeight,
+                                     ColorType colorType) {
+        if (imageWidth % sliceWidth != 0 || imageHeight % sliceHeight != 0)
+            throw new IllegalArgumentException("Slice height and slice width must divide the image evenly!");
+
+        int countX = imageWidth / sliceWidth;
+        int countY = imageHeight / sliceHeight;
+        UITexture[] slices = new UITexture[countX * countY];
+
+        for (int indexX = 0; indexX < countX; indexX++) {
+            for (int indexY = 0; indexY < countY; indexY++) {
+                slices[(indexX * countX) + indexY] = UITexture.builder()
+                        .location(GTCEu.MOD_ID, path)
+                        .imageSize(imageWidth, imageHeight)
+                        .colorType(colorType)
+                        .subAreaXYWH(indexX * sliceWidth, indexY * sliceHeight, sliceWidth, sliceHeight)
+                        .build();
+            }
+        }
+        return slices;
+    }
+
+    private static UITexture progressBar(String path) {
+        return progressBar(path, null);
+    }
+
+    private static UITexture progressBar(String path, ColorType colorType) {
+        return progressBar(path, 20, 40, colorType);
+    }
+
+    private static UITexture progressBar(String path, int width, int height) {
+        return progressBar(path, width, height, null);
+    }
+
+    private static UITexture progressBar(String path, int width, int height, ColorType colorType) {
+        UITexture.Builder builder = new UITexture.Builder()
+                .location(GTCEu.MOD_ID, path)
+                .imageSize(width, height)
+                .colorType(colorType);
+        return builder.build();
+    }
+
+    // todo steam logos? multi indicator blinking logos?
+    public static @NotNull UITexture getLogo(GTGuiTheme theme) {
+        if (theme != null) {
+            UITexture logo = theme.getLogo();
+            if (logo != null) return logo;
+        }
+        return GTValues.XMAS.getAsBoolean() ? GREGTECH_LOGO_XMAS : GREGTECH_LOGO;
+    }
+}
diff --git a/src/main/java/com/gregtechceu/gtceu/common/mui/GTGuiTheme.java b/src/main/java/com/gregtechceu/gtceu/common/mui/GTGuiTheme.java
new file mode 100644
index 00000000000..eca3df7ee9b
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/common/mui/GTGuiTheme.java
@@ -0,0 +1,420 @@
+package com.gregtechceu.gtceu.common.mui;
+
+import com.gregtechceu.gtceu.api.cover.IMuiCover;
+import com.gregtechceu.gtceu.config.ConfigHolder;
+
+import net.minecraftforge.eventbus.api.SubscribeEvent;
+import net.minecraftforge.fml.common.Mod;
+
+import brachy.modularui.api.ITheme;
+import brachy.modularui.api.IThemeApi;
+import brachy.modularui.drawable.UITexture;
+import brachy.modularui.screen.RichTooltip;
+import brachy.modularui.theme.ReloadThemeEvent;
+import brachy.modularui.theme.WidgetTheme;
+import brachy.modularui.theme.WidgetThemeKey;
+import brachy.modularui.utils.Color;
+import brachy.modularui.utils.serialization.json.JsonBuilder;
+import org.jetbrains.annotations.Nullable;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.function.Consumer;
+import java.util.function.Supplier;
+
+@Mod.EventBusSubscriber
+public class GTGuiTheme {
+
+    private static final List<GTGuiTheme> THEMES = new ArrayList<>();
+
+    public static WidgetThemeKey<WidgetTheme> TEXT_TITLE = IThemeApi.get()
+            .widgetThemeKeyBuilder("textTitle", WidgetTheme.class)
+            .defaultTheme(new WidgetTheme(0, 0, null, Color.WHITE.main, 0x404040, false, 0))
+            .defaultHoverTheme(null)
+            .register();
+
+    public static final GTGuiTheme STANDARD = templateBuilder("gregtech_standard")
+            .panel(GTGuiTextures.IDs.STANDARD_BACKGROUND)
+            .itemSlot(GTGuiTextures.IDs.STANDARD_SLOT)
+            .fluidSlot(GTGuiTextures.IDs.STANDARD_FLUID_SLOT)
+            .color(ConfigHolder.INSTANCE.client.ui.getDefaultUIColor())
+            .button(GTGuiTextures.IDs.STANDARD_BUTTON)
+            .simpleToggleButton(GTGuiTextures.IDs.STANDARD_BUTTON,
+                    GTGuiTextures.IDs.STANDARD_SLOT,
+                    ConfigHolder.INSTANCE.client.ui.getDefaultUIColor())
+            .build();
+
+    public static final GTGuiTheme COVER = templateBuilder("gregtech_cover")
+            .panel(GTGuiTextures.IDs.COVER_BACKGROUND)
+            .itemSlot(GTGuiTextures.IDs.STANDARD_SLOT)
+            .fluidSlot(GTGuiTextures.IDs.STANDARD_FLUID_SLOT)
+            .color(ConfigHolder.INSTANCE.client.ui.getDefaultUIColor())
+            .textColor(IMuiCover.UI_TEXT_COLOR)
+            .build();
+
+    // TODO Multiblock theme for display texture, logo changes
+
+    public static final GTGuiTheme BRONZE = templateBuilder("gregtech_bronze")
+            .panel(GTGuiTextures.IDs.BRONZE_BACKGROUND)
+            .itemSlot(GTGuiTextures.IDs.BRONZE_SLOT)
+            .build();
+
+    public static final GTGuiTheme STEEL = templateBuilder("gregtech_steel")
+            .panel(GTGuiTextures.IDs.STEEL_BACKGROUND)
+            .itemSlot(GTGuiTextures.IDs.STEEL_SLOT)
+            .build();
+
+    public static final GTGuiTheme PRIMITIVE = templateBuilder("gregtech_primitive")
+            .panel(GTGuiTextures.IDs.PRIMITIVE_BACKGROUND)
+            .itemSlot(GTGuiTextures.IDs.PRIMITIVE_SLOT)
+            .fluidSlot(GTGuiTextures.IDs.PRIMITIVE_SLOT)
+            .build();
+
+    public static final GTGuiTheme EQUIPMENT_FOUNDRY = templateBuilder("equipment_foundry")
+            .panel(GTGuiTextures.IDs.EQUIPMENT_FOUNDRY_BACKGROUND)
+            .color(0xff69645f)
+            .build();
+
+    private final String themeId;
+
+    private final List<Consumer<JsonBuilder>> elementBuilder;
+    private final JsonBuilder jsonBuilder;
+
+    private Supplier<UITexture> logo;
+
+    private GTGuiTheme(String themeId) {
+        this.themeId = themeId;
+        this.jsonBuilder = new JsonBuilder();
+        this.elementBuilder = new ArrayList<>();
+        THEMES.add(this);
+    }
+
+    public String getId() {
+        return themeId;
+    }
+
+    public ITheme getMuiTheme() {
+        return IThemeApi.get().getTheme(themeId);
+    }
+
+    public @Nullable UITexture getLogo() {
+        if (logo == null) return null;
+        return logo.get();
+    }
+
+    private void register() {
+        buildJson();
+        IThemeApi.get().registerTheme(themeId, jsonBuilder);
+    }
+
+    private void buildJson() {
+        elementBuilder.forEach(c -> c.accept(jsonBuilder));
+    }
+
+    @SubscribeEvent
+    public static void onReloadThemes(ReloadThemeEvent.Pre event) {
+        THEMES.forEach(GTGuiTheme::register);
+    }
+
+    public static Builder templateBuilder(String themeId) {
+        Builder builder = new Builder(themeId);
+        builder.openCloseAnimation(0);
+        builder.tooltipPos(RichTooltip.Pos.NEXT_TO_MOUSE);
+        builder.smoothProgressBar(true);
+        return builder;
+    }
+
+    @SuppressWarnings("UnusedReturnValue")
+    public static class Builder {
+
+        private final GTGuiTheme theme;
+
+        public Builder(String themeId) {
+            theme = new GTGuiTheme(themeId);
+        }
+
+        /**
+         * Set a parent theme for this theme, which unset values will inherit from.
+         * If not set, it will use the default theme as the parent (VANILLA).
+         */
+        public Builder parent(String parentId) {
+            theme.elementBuilder.add(b -> b.add("parent", parentId));
+            return this;
+        }
+
+        /**
+         * Set a background fallback for when specific widgets do not set their own.
+         */
+        public Builder globalBackground(String backgroundId) {
+            theme.elementBuilder.add(b -> b.add("background", backgroundId));
+            return this;
+        }
+
+        /**
+         * Set a tooltip hover background fallback for when specific widgets do not set their own.
+         */
+        public Builder globalHoverBackground(String hoverBackgroundId) {
+            theme.elementBuilder.add(b -> b.add("hoverBackground", hoverBackgroundId));
+            return this;
+        }
+
+        /**
+         * Set the window open/close animation speed. Overrides global cfg.
+         *
+         * @param rate the rate in frames to play the open/close animation over, or 0 for no animation
+         */
+        public Builder openCloseAnimation(int rate) {
+            theme.elementBuilder.add(b -> b.add("openCloseAnimation", rate));
+            return this;
+        }
+
+        /**
+         * Set whether progress bars should animate smoothly. Overrides global cfg.
+         */
+        public Builder smoothProgressBar(boolean smoothBar) {
+            theme.elementBuilder.add(b -> b.add("smoothProgressBar", smoothBar));
+            return this;
+        }
+
+        /**
+         * Set the tooltip pos for this theme. Overrides global cfg.
+         */
+        public Builder tooltipPos(RichTooltip.Pos tooltipPos) {
+            theme.elementBuilder.add(b -> b.add("tooltipPos", tooltipPos.name()));
+            return this;
+        }
+
+        /**
+         * Set a global UI coloration for this theme.
+         */
+        public Builder color(int color) {
+            theme.elementBuilder.add(b -> b.add("color", color));
+            return this;
+        }
+
+        /**
+         * Set a global UI text coloration for this theme.
+         */
+        public Builder textColor(int textColor) {
+            theme.elementBuilder.add(b -> b.add("textColor", textColor));
+            return this;
+        }
+
+        /**
+         * Enable text shadow for the global UI text for this theme.
+         */
+        public Builder textShadow() {
+            theme.elementBuilder.add(b -> b.add("textShadow", true));
+            return this;
+        }
+
+        /**
+         * Set a custom panel (background texture) for UIs with this theme.
+         */
+        public Builder panel(String panelId) {
+            theme.elementBuilder.add(b -> b
+                    .add("panel", new JsonBuilder()
+                            .add("background", new JsonBuilder()
+                                    .add("type", "texture")
+                                    .add("id", panelId))));
+            return this;
+        }
+
+        /**
+         * Set a custom button texture for UIs with this theme.
+         */
+        public Builder button(String buttonId) {
+            return button(buttonId, buttonId, 0xFFFFFFFF, false);
+        }
+
+        /**
+         * Set a custom button texture for UIs with this theme.
+         *
+         * @param buttonId The ID of the button texture
+         * @param hoverId  The ID of the button texture while hovering over the button with your mouse
+         */
+        public Builder button(String buttonId, String hoverId) {
+            return button(buttonId, hoverId, 0xFFFFFFFF, false);
+        }
+
+        /**
+         * Set a custom button texture for UIs with this theme.
+         *
+         * @param buttonId   The ID of the button texture
+         * @param hoverId    The ID of the button texture while hovering over the button with your mouse
+         * @param textColor  The color of text overlaid on this button
+         * @param textShadow If text overlaid on this button should have a text shadow
+         */
+        public Builder button(String buttonId, String hoverId, int textColor, boolean textShadow) {
+            theme.elementBuilder.add(b -> b
+                    .add("button", new JsonBuilder()
+                            .add("background", new JsonBuilder()
+                                    .add("type", "texture")
+                                    .add("id", buttonId))
+                            .add("hoverBackground", new JsonBuilder()
+                                    .add("type", "texture")
+                                    .add("id", hoverId))
+                            .add("textColor", textColor)
+                            .add("textShadow", textShadow)));
+            return this;
+        }
+
+        /**
+         * Set a custom item slot texture for UIs with this theme.
+         */
+        public Builder itemSlot(String itemSlotId) {
+            return itemSlot(itemSlotId, 0x60FFFFFF);
+        }
+
+        /**
+         * Set a custom item slot texture for UIs with this theme.
+         *
+         * @param itemSlotId The ID of the item slot texture
+         * @param hoverColor The color of the tooltip hover box for this widget
+         */
+        public Builder itemSlot(String itemSlotId, int hoverColor) {
+            theme.elementBuilder.add(b -> b
+                    .add("itemSlot", new JsonBuilder()
+                            .add("background", new JsonBuilder()
+                                    .add("type", "texture")
+                                    .add("id", itemSlotId))
+                            .add("slotHoverColor", hoverColor)));
+            return this;
+        }
+
+        /**
+         * Set a custom fluid slot texture for UIs with this theme.
+         */
+        public Builder fluidSlot(String fluidSlotId) {
+            return fluidSlot(fluidSlotId, 0x60FFFFFF);
+        }
+
+        /**
+         * Set a custom fluid slot texture for UIs with this theme.
+         *
+         * @param fluidSlotId The ID of the fluid slot texture
+         * @param hoverColor  The color of the tooltip hover box for this widget
+         */
+        public Builder fluidSlot(String fluidSlotId, int hoverColor) {
+            theme.elementBuilder.add(b -> b
+                    .add("fluidSlot", new JsonBuilder()
+                            .add("background", new JsonBuilder()
+                                    .add("type", "texture")
+                                    .add("id", fluidSlotId))
+                            .add("slotHoverColor", hoverColor)));
+            return this;
+        }
+
+        /**
+         * Set the text color for text fields in UIs with this theme.
+         */
+        public Builder textField(int textColor) {
+            return textField(textColor, 0xFF2F72A8);
+        }
+
+        /**
+         * Set the text color for text fields in UIs with this theme.
+         *
+         * @param textColor   Text color
+         * @param markedColor Color of the highlight on selected text
+         */
+        public Builder textField(int textColor, int markedColor) {
+            theme.elementBuilder.add(b -> b
+                    .add("textField", new JsonBuilder()
+                            .add("textColor", textColor)
+                            .add("markedColor", markedColor)));
+            return this;
+        }
+
+        /**
+         * Set the theme options for a ToggleButton widget.
+         *
+         * @param backgroundId              The main background for the unpressed button
+         * @param hoverBackgroundId         The on-hover background for the unpressed button
+         * @param selectedBackgroundId      The main background for the pressed button
+         * @param selectedHoverBackgroundId The on-hover background for the pressed button
+         * @param selectedColor             The color to apply to the pressed button
+         */
+        public Builder toggleButton(String backgroundId, String hoverBackgroundId,
+                                    String selectedBackgroundId, String selectedHoverBackgroundId, int selectedColor) {
+            return toggleButton(
+                    backgroundId, hoverBackgroundId,
+                    selectedBackgroundId, selectedHoverBackgroundId,
+                    selectedColor, 0xFFBBBBBB, false);
+        }
+
+        /**
+         * Set the theme options for a ToggleButton widget.
+         *
+         * @param backgroundId              The main background for the unpressed button
+         * @param hoverBackgroundId         The on-hover background for the unpressed button
+         * @param selectedBackgroundId      The main background for the pressed button
+         * @param selectedHoverBackgroundId The on-hover background for the pressed button
+         * @param selectedColor             The color to apply to the pressed button
+         * @param textColor                 The color for text overlaid on this button
+         * @param textShadow                Whether to apply text shadow to text overlaid on this button
+         */
+        public Builder toggleButton(String backgroundId, String hoverBackgroundId,
+                                    String selectedBackgroundId, String selectedHoverBackgroundId,
+                                    int selectedColor, int textColor, boolean textShadow) {
+            theme.elementBuilder.add(b -> b
+                    .add("toggleButton", new JsonBuilder()
+                            .add("background", new JsonBuilder()
+                                    .add("type", "texture")
+                                    .add("id", backgroundId))
+                            .add("hoverBackground", new JsonBuilder()
+                                    .add("type", "texture")
+                                    .add("id", hoverBackgroundId))
+                            .add("selectedBackground", new JsonBuilder()
+                                    .add("type", "texture")
+                                    .add("id", selectedBackgroundId))
+                            .add("selectedHoverBackground", new JsonBuilder()
+                                    .add("type", "texture")
+                                    .add("id", selectedHoverBackgroundId))
+                            .add("selectedColor", selectedColor)
+                            .add("textColor", textColor)
+                            .add("textShadow", textShadow)));
+            return this;
+        }
+
+        /**
+         * Simple toggle button configuration for when you want a button with no texture changes on hover.
+         *
+         * @param backgroundId         The unselected background texture
+         * @param selectedBackgroundId The selected background texture
+         * @param selectedColor        The background color when the button is selected
+         */
+        public Builder simpleToggleButton(String backgroundId, String selectedBackgroundId, int selectedColor) {
+            return simpleToggleButton(backgroundId, selectedBackgroundId, selectedColor, 0xFFBBBBBB, false);
+        }
+
+        /**
+         * Simple toggle button configuration for when you want a button with no texture changes on hover.
+         *
+         * @param backgroundId         The unselected background texture
+         * @param selectedBackgroundId The selected background texture
+         * @param selectedColor        The background color when the button is selected
+         * @param textColor            The color for text overlaid on this button
+         * @param textShadow           Whether to apply text shadow to text overlaid on this button
+         */
+        public Builder simpleToggleButton(String backgroundId, String selectedBackgroundId, int selectedColor,
+                                          int textColor, boolean textShadow) {
+            return toggleButton(
+                    backgroundId, backgroundId,
+                    selectedBackgroundId, selectedBackgroundId,
+                    selectedColor, textColor, textShadow);
+        }
+
+        /**
+         * Set a logo supplier for this theme.
+         */
+        public Builder logo(Supplier<UITexture> logo) {
+            theme.logo = logo;
+            return this;
+        }
+
+        public GTGuiTheme build() {
+            return theme;
+        }
+    }
+}
diff --git a/src/main/java/com/gregtechceu/gtceu/common/mui/GTMuiMachineUtil.java b/src/main/java/com/gregtechceu/gtceu/common/mui/GTMuiMachineUtil.java
new file mode 100644
index 00000000000..4869b361dc5
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/common/mui/GTMuiMachineUtil.java
@@ -0,0 +1,75 @@
+package com.gregtechceu.gtceu.common.mui;
+
+import com.gregtechceu.gtceu.api.machine.trait.NotifiableFluidTank;
+
+import net.minecraftforge.items.IItemHandler;
+
+import brachy.modularui.value.sync.ItemSlotSyncHandler;
+import brachy.modularui.value.sync.PanelSyncManager;
+import brachy.modularui.value.sync.SyncHandlers;
+import brachy.modularui.widgets.SlotGroupWidget;
+import brachy.modularui.widgets.slot.FluidSlot;
+import brachy.modularui.widgets.slot.ItemSlot;
+import brachy.modularui.widgets.slot.ModularSlot;
+import brachy.modularui.widgets.slot.SlotGroup;
+
+import java.util.function.UnaryOperator;
+
+public class GTMuiMachineUtil {
+
+    public static SlotGroupWidget createSlotGroupFromInventory(IItemHandler itemHandler, String slotGroupName,
+                                                               int maxSlots, char key, PanelSyncManager syncManager,
+                                                               String... matrix) {
+        return createSlotGroupFromInventory(itemHandler, slotGroupName, maxSlots, key, i -> i, syncManager, matrix);
+    }
+
+    public static SlotGroupWidget createSlotGroupFromInventory(IItemHandler itemHandler,
+                                                               String slotGroupName, int maxSlots, char key,
+                                                               UnaryOperator<ItemSlot> slotModifier,
+                                                               PanelSyncManager syncManager,
+                                                               String... matrix) {
+        SlotGroup slotGroup = new SlotGroup(slotGroupName, maxSlots);
+
+        return SlotGroupWidget.builder()
+                .matrix(matrix)
+                .key(key, i -> {
+                    ModularSlot slot = new ModularSlot(itemHandler, i);
+                    ItemSlotSyncHandler syncHandler = new ItemSlotSyncHandler(slot.slotGroup(slotGroup));
+                    syncManager.syncValue(slotGroupName, i, syncHandler);
+                    return slotModifier.apply(new ItemSlot()
+                            .syncHandler(slotGroupName, i));
+                })
+                .build();
+    }
+
+    public static String[] createSquareMatrix(int size, char key) {
+        size = (int) Math.sqrt(size);
+        String[] matrix = new String[size];
+        for (int i = 0; i < size; i++) {
+            matrix[i] = String.valueOf(key).repeat(size);
+        }
+        return matrix;
+    }
+
+    public static SlotGroupWidget createSquareSlotGroupFromInventory(IItemHandler itemHandler,
+                                                                     String slotGroupName,
+                                                                     PanelSyncManager syncManager) {
+        return createSlotGroupFromInventory(itemHandler, slotGroupName, itemHandler.getSlots(), 'I', syncManager,
+                createSquareMatrix(itemHandler.getSlots(), 'I'));
+    }
+
+    public static SlotGroupWidget createSlotGroupFromInventory(PanelSyncManager syncManager,
+                                                               NotifiableFluidTank fluidTank,
+                                                               String syncHandlerName, int maxSlots, char key,
+                                                               String... matrix) {
+        for (int i = 0; i < maxSlots; i++) {
+            syncManager.syncValue(syncHandlerName, i, SyncHandlers.fluidSlot(fluidTank.getStorages()[i]));
+        }
+
+        return SlotGroupWidget.builder()
+                .matrix(matrix)
+                .key(key, i -> new FluidSlot()
+                        .syncHandler(syncHandlerName, i))
+                .build();
+    }
+}
diff --git a/src/main/java/com/gregtechceu/gtceu/common/mui/GTMuiRecipeTypes.java b/src/main/java/com/gregtechceu/gtceu/common/mui/GTMuiRecipeTypes.java
new file mode 100644
index 00000000000..58ec5af2045
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/common/mui/GTMuiRecipeTypes.java
@@ -0,0 +1,5 @@
+package com.gregtechceu.gtceu.common.mui;
+
+public class GTMuiRecipeTypes {
+
+}
diff --git a/src/main/java/com/gregtechceu/gtceu/common/mui/GTMuiWidgets.java b/src/main/java/com/gregtechceu/gtceu/common/mui/GTMuiWidgets.java
new file mode 100644
index 00000000000..773fcd8d530
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/common/mui/GTMuiWidgets.java
@@ -0,0 +1,707 @@
+package com.gregtechceu.gtceu.common.mui;
+
+import com.gregtechceu.gtceu.api.GTValues;
+import com.gregtechceu.gtceu.api.capability.IControllable;
+import com.gregtechceu.gtceu.api.capability.recipe.IO;
+import com.gregtechceu.gtceu.api.cover.filter.Filter;
+import com.gregtechceu.gtceu.api.cover.filter.FilterHandler;
+import com.gregtechceu.gtceu.api.machine.MachineDefinition;
+import com.gregtechceu.gtceu.api.machine.feature.IHasBatterySlot;
+import com.gregtechceu.gtceu.api.machine.feature.IHasCircuitSlot;
+import com.gregtechceu.gtceu.api.machine.feature.IRecipeLogicMachine;
+import com.gregtechceu.gtceu.api.machine.feature.IVoidable;
+import com.gregtechceu.gtceu.api.machine.feature.multiblock.IDistinctPart;
+import com.gregtechceu.gtceu.api.recipe.gui.GTRecipeTypeUILayout;
+import com.gregtechceu.gtceu.common.cover.data.BucketMode;
+import com.gregtechceu.gtceu.common.item.behavior.IntCircuitBehaviour;
+import com.gregtechceu.gtceu.common.machine.trait.AutoOutputTrait;
+import com.gregtechceu.gtceu.config.ConfigHolder;
+import com.gregtechceu.gtceu.utils.GTMath;
+
+import net.minecraft.network.chat.Component;
+import net.minecraft.util.Mth;
+import net.minecraft.util.StringRepresentable;
+import net.minecraft.world.item.ItemStack;
+import net.minecraft.world.item.Items;
+
+import brachy.modularui.api.IPanelHandler;
+import brachy.modularui.api.drawable.IDrawable;
+import brachy.modularui.api.drawable.IKey;
+import brachy.modularui.drawable.*;
+import brachy.modularui.drawable.text.TextRenderer;
+import brachy.modularui.factory.SidedPosGuiData;
+import brachy.modularui.screen.ModularPanel;
+import brachy.modularui.screen.UISettings;
+import brachy.modularui.theme.ThemeAPI;
+import brachy.modularui.utils.Alignment;
+import brachy.modularui.utils.Color;
+import brachy.modularui.utils.MouseData;
+import brachy.modularui.value.BoolValue;
+import brachy.modularui.value.sync.*;
+import brachy.modularui.widget.EmptyWidget;
+import brachy.modularui.widget.ParentWidget;
+import brachy.modularui.widgets.*;
+import brachy.modularui.widgets.layout.Flow;
+import brachy.modularui.widgets.layout.Grid;
+import brachy.modularui.widgets.slot.FluidSlot;
+import brachy.modularui.widgets.slot.ItemSlot;
+import brachy.modularui.widgets.slot.ModularSlot;
+import brachy.modularui.widgets.textfield.TextFieldWidget;
+import com.mojang.blaze3d.platform.InputConstants;
+import it.unimi.dsi.fastutil.booleans.BooleanConsumer;
+import org.jetbrains.annotations.Nullable;
+
+import java.util.function.*;
+
+public class GTMuiWidgets {
+
+    public static Flow createTitleBar(MachineDefinition definition, int panelWidth) {
+        UITexture background = GTGuiTextures.BACKGROUND;
+        if (!definition.getThemeId().equals(ThemeAPI.DEFAULT_ID)) {
+            background = (UITexture) ThemeAPI.INSTANCE.getTheme(definition.getThemeId()).getPanelTheme().theme()
+                    .getBackground();
+        }
+        if (background == null) {
+            background = GTGuiTextures.BACKGROUND;
+        }
+
+        return createTitleBar(definition, panelWidth, background);
+    }
+
+    public static Flow createTitleBar(MachineDefinition definition, int panelWidth, UITexture background) {
+        return createTitleBar(definition.asStack(), panelWidth, background);
+    }
+
+    public static Flow createTitleBar(ItemStack stack, int panelWidth, UITexture background) {
+        var name = stack.getHoverName().getString();
+        name = name.replaceAll("§.", "").trim();
+        return createTitleBar(new ItemDrawable(stack).asIcon(), name, panelWidth, background);
+    }
+
+    public static Flow createTitleBar(Icon icon, String text, int panelWidth, UITexture background) {
+        int borderRadius = 5;
+        int iconSize = 16;
+        int minPanelWidth = (int) (panelWidth * 0.9f) - (iconSize + (borderRadius * 3));
+        int textTitleWidth = TextRenderer.getFont().width(text);
+
+        int textRows = (int) Math.ceil((double) textTitleWidth / minPanelWidth);
+        int textHeightPerRow = (int) (IKey.renderer.getFontHeight());
+        int textHeight = textHeightPerRow * textRows + borderRadius;
+
+        int rowWidth = Math.min((int) (0.9 * panelWidth), (iconSize + (borderRadius * 4) + textTitleWidth));
+
+        return Flow.row()
+                .coverChildrenHeight()
+                .mainAxisAlignment(Alignment.MainAxis.CENTER)
+                .crossAxisAlignment(Alignment.CrossAxis.CENTER)
+                .width(rowWidth)
+                .top(-(textHeight + borderRadius))
+                .horizontalCenter()
+                .background(background.getSubArea(0f, 0f, 1.0f, 0.75f))
+                .child(icon.size(iconSize)
+                        .asWidget()
+                        .marginLeft(borderRadius))
+                .child(IKey.str(text)
+                        .asWidget()
+                        .margin(borderRadius, borderRadius, borderRadius, 1)
+                        .size(Math.min(minPanelWidth, textTitleWidth), textHeight));
+    }
+
+    public static ToggleButton createToggleButton(BooleanSupplier getter, BooleanConsumer setter, UITexture texture,
+                                                  String langKey) {
+        var value = new BooleanSyncValue(getter, setter);
+        return new ToggleButton()
+                .value(value)
+                .overlay(texture)
+                .tooltipAutoUpdate(true)
+                .tooltipBuilder(
+                        (r) -> r.addLine(IKey.lang(langKey + (value.getBoolValue() ? ".enabled" : ".disabled"))));
+    }
+
+    public static ToggleButton createToggleButton(BooleanSupplier getter, BooleanConsumer setter, UITexture background,
+                                                  UITexture selectedBackground, String langKey) {
+        var value = new BooleanSyncValue(getter, setter);
+        return new ToggleButton()
+                .value(value)
+                .selectedBackground(selectedBackground)
+                .background(background)
+                .tooltipAutoUpdate(true)
+                .tooltipBuilder(
+                        (r) -> r.addLine(IKey.lang(langKey + (value.getBoolValue() ? ".enabled" : ".disabled"))));
+    }
+
+    public static ToggleButton createPowerButton(IRecipeLogicMachine recipeLogicMachine) {
+        return createToggleButton(
+                () -> recipeLogicMachine.getRecipeLogic().isWorkingEnabled(),
+                recipeLogicMachine::setWorkingEnabled,
+                GTGuiTextures.BUTTON_POWER[0],
+                GTGuiTextures.BUTTON_POWER[1],
+                "behaviour.soft_hammer");
+    }
+
+    public static ToggleButton createPowerButton(IControllable workable) {
+        return createToggleButton(
+                workable::isWorkingEnabled,
+                workable::setWorkingEnabled,
+                GTGuiTextures.BUTTON_POWER[0],
+                GTGuiTextures.BUTTON_POWER[1],
+                "behaviour.soft_hammer");
+    }
+
+    public static ProgressWidget createProgressBar(IRecipeLogicMachine workableMachine, PanelSyncManager syncManager,
+                                                   UITexture texture, int size) {
+        DoubleSyncValue progressPercent = syncManager.getOrCreateSyncHandler("progressPercent", DoubleSyncValue.class,
+                () -> new DoubleSyncValue(() -> {
+                    if (workableMachine.getMaxProgress() == 0.0f) return 0.0f;
+                    return workableMachine.getProgress() / (double) workableMachine.getMaxProgress();
+                }));
+
+        return new ProgressWidget()
+                .texture(texture, size)
+                .value(progressPercent);
+    }
+
+    public static FluidSlot createTankWidget() {
+        return new FluidSlot().size(20, 58).alwaysShowFull(false);
+    }
+
+    public static ItemSlot createBatterySlot(IHasBatterySlot batterySlot, PanelSyncManager syncManager) {
+        ItemSlotSyncHandler battery = new ItemSlotSyncHandler(new ModularSlot(batterySlot.getChargerInventory(), 0));
+        syncManager.syncValue("battery", battery);
+        return new ItemSlot().syncHandler("battery").background(GTGuiTextures.SLOT, GTGuiTextures.CHARGER_OVERLAY);
+    }
+
+    public static CycleButtonWidget createVoidingButton(IVoidable voidable) {
+        var value = new EnumSyncValue<>(IVoidable.VoidingMode.class, voidable::getVoidingMode,
+                voidable::setVoidingMode);
+
+        return new CycleButtonWidget()
+                .overlay(GTGuiTextures.BUTTON_VOID_MULTIBLOCK)
+                .value(value)
+                .tooltipBuilder(
+                        r -> r.addLine(IKey.dynamic(() -> Component.translatable(value.getValue().getTooltip()))));
+    }
+
+    public static ToggleButton createDistinctnessButton(IDistinctPart distinct) {
+        return createToggleButton(distinct::isDistinct, distinct::setDistinct, GTGuiTextures.BUTTON_DISTINCT[0],
+                GTGuiTextures.BUTTON_DISTINCT[1],
+                "gtceu.multiblock.universal.distinct");
+    }
+
+    public static ToggleButton createAutoOutputItemButton(AutoOutputTrait autoOutput) {
+        return createToggleButton(autoOutput::isAutoOutputItems, autoOutput::setAllowAutoOutputItems,
+                GTGuiTextures.BUTTON_ITEM_OUTPUT, "gtceu.gui.item_auto_output");
+    }
+
+    public static ToggleButton createAutoOutputFluidButton(AutoOutputTrait autoOutput) {
+        return createToggleButton(autoOutput::isAutoOutputFluids, autoOutput::setAllowAutoOutputFluids,
+                GTGuiTextures.BUTTON_FLUID_OUTPUT, "gtceu.gui.fluid_auto_output");
+    }
+
+    public static ToggleButton createInputFromOutputItem(AutoOutputTrait autoOutput) {
+        return createToggleButton(autoOutput::allowsItemInputFromOutputSide,
+                autoOutput::setAllowItemInputFromOutputSide, GTGuiTextures.BUTTON_ITEM_OUTPUT,
+                "gtceu.gui.item_input_from_output");
+    }
+
+    public static ToggleButton createInputFromOutputFluid(AutoOutputTrait autoOutput) {
+        return createToggleButton(autoOutput::allowsFluidInputFromOutputSide,
+                autoOutput::setAllowFluidInputFromOutputSide, GTGuiTextures.BUTTON_FLUID_OUTPUT,
+                "gtceu.gui.fluid_input_from_output");
+    }
+
+    private static IntSyncValue createCircuitSlotSyncValue(Consumer<ItemStack> circuitSetter,
+                                                           Supplier<ItemStack> circuitGetter) {
+        return new IntSyncValue(() -> {
+            if (circuitGetter.get().isEmpty()) return -1;
+            return IntCircuitBehaviour.getCircuitConfiguration(circuitGetter.get());
+        },
+                (v) -> circuitSetter.accept(v < 0 ? ItemStack.EMPTY :
+                        IntCircuitBehaviour.stack(v)));
+    }
+
+    public static ModularPanel<?> createCircuitSlotPanel(IntSyncValue circuitSyncValue, PanelSyncManager syncManager) {
+        syncManager.syncValue("circuit_slot", circuitSyncValue);
+        Grid buttonGrid = new Grid()
+                .coverChildren()
+                .mapTo(8, 32, i -> new ToggleButton()
+                        .size(18)
+                        .padding(1)
+                        .overlay(new ItemDrawable().setItem(IntCircuitBehaviour.stack(i + 1)))
+                        .value(new BoolValue.Dynamic(() -> (i + 1) == circuitSyncValue.getIntValue(),
+                                (v) -> {
+                                    if (v) circuitSyncValue.setValue(i + 1);
+                                })));
+
+        return new Dialog<>("circuit_panel")
+                .disablePanelsBelow(false)
+                .draggable(true)
+                .closeOnOutOfBoundsClick(true)
+                .height(105)
+                .child(Flow.col()
+                        .padding(2)
+                        .fullHeight()
+                        .coverChildren()
+                        .childPadding(7)
+                        .top(3)
+                        .leftRel(0.5f)
+                        .child(IKey.lang("item.gtceu.circuit.integrated.gui").asWidget())
+                        .child(buttonGrid));
+    }
+
+    public static ModularPanel<?> createCircuitSlotPanel(Consumer<ItemStack> circuitSetter,
+                                                         Supplier<ItemStack> circuitGetter,
+                                                         PanelSyncManager syncManager) {
+        IntSyncValue circuitSyncValue = createCircuitSlotSyncValue(circuitSetter, circuitGetter);
+        return createCircuitSlotPanel(circuitSyncValue, syncManager);
+    }
+
+    public static ButtonWidget<?> createCircuitSlotPanel(IHasCircuitSlot machine, ModularPanel<?> parentPanel,
+                                                         PanelSyncManager syncManager) {
+        IntSyncValue circuitSyncValue = createCircuitSlotSyncValue(
+                i -> machine.getCircuitInventory().setStackInSlot(0, i),
+                () -> machine.getCircuitInventory().getStackInSlot(0));
+        IPanelHandler circuitPanelHandler = syncManager.syncedPanel("circuit_panel", true,
+                (sm, sh) -> createCircuitSlotPanel(circuitSyncValue, sm)
+                        .relative(parentPanel)
+                        .leftRel(0.0f, -4, 1f));
+
+        return new ButtonWidget<>()
+                .size(18)
+                .onMousePressed((x, y, b) -> {
+                    if (b == InputConstants.MOUSE_BUTTON_LEFT || b == InputConstants.MOUSE_BUTTON_RIGHT) {
+                        circuitPanelHandler.openPanel();
+                    } else if (b == InputConstants.MOUSE_BUTTON_MIDDLE) {
+                        circuitSyncValue.setValue(0);
+                    }
+                    return true;
+                })
+                .onMouseScrolled((x, y, delta) -> {
+                    int newValue = nextCircuitValue(machine.getCircuitInventory().getStackInSlot(0),
+                            circuitSyncValue.getIntValue(), delta);
+                    circuitSyncValue.setValue(newValue);
+                    return true;
+                })
+                .overlay(new DynamicDrawable(() -> {
+                    if (machine.getCircuitInventory().getStackInSlot(0).isEmpty()) {
+                        return new DrawableStack(new ItemDrawable(IntCircuitBehaviour.stack(0)),
+                                new ItemDrawable(Items.BARRIER)).asIcon().size(16);
+                    }
+                    return new ItemDrawable(machine.getCircuitInventory().getStackInSlot(0))
+                            .asIcon().size(16);
+                }))
+                .tooltipAutoUpdate(true)
+                .tooltipBuilder((r) -> r.addLine(IKey.lang(Component.translatable("metaitem.int_circuit.configuration",
+                        (machine.getCircuitInventory().getStackInSlot(0).isEmpty() ? 0 :
+                                IntCircuitBehaviour
+                                        .getCircuitConfiguration(machine.getCircuitInventory().getStackInSlot(0)))))));
+    }
+
+    private static int nextCircuitValue(ItemStack stack, int current, double delta) {
+        if (delta > 0) {
+            if (current == IntCircuitBehaviour.CIRCUIT_MAX) {
+                // if at max, loop around to no circuit
+                return 0;
+            } else if (stack.isEmpty()) {
+                // if at no circuit, skip 0 and return 1
+                return 1;
+            } else {
+                // normal case: increment by 1
+                return current + 1;
+            }
+        } else {
+            if (stack.isEmpty() ||
+                    (current == 0 && !ConfigHolder.INSTANCE.machines.ghostCircuit)) {
+                // if at no circuit, loop around to max
+                return IntCircuitBehaviour.CIRCUIT_MAX;
+            } else if (current == 1 && ConfigHolder.INSTANCE.machines.ghostCircuit) {
+                // if at 1, skip 0 and return no circuit
+                return -1;
+            } else {
+                // normal case: decrement by 1
+                return current - 1;
+            }
+        }
+    }
+
+    public static IDrawable.DrawableWidget createGTLogo() {
+        if (GTValues.XMAS.getAsBoolean()) {
+            return new IDrawable.DrawableWidget(GTGuiTextures.GREGTECH_LOGO_XMAS);
+        }
+        return new IDrawable.DrawableWidget(GTGuiTextures.GREGTECH_LOGO);
+    }
+
+    public static String[] createGrid(int amount, int rowSize, boolean output, char key) {
+        int rows = (int) Math.ceil((float) amount / rowSize);
+        String[] grid = new String[rows];
+        for (int i = 0; i < rows; i++) {
+            StringBuilder r = new StringBuilder();
+            if (output) {
+                for (int j = 0; j < rowSize; j++) {
+                    if ((i * rowSize + j) > (amount - 1)) {
+                        r.insert(0, " ");
+                    } else {
+                        r.insert(0, key);
+                    }
+                }
+            } else {
+                for (int j = 0; j < rowSize; j++) {
+                    if ((i * rowSize + j) > (amount - 1)) {
+                        r.append(" ");
+                    } else {
+                        r.append(key);
+                    }
+                }
+            }
+            grid[i] = r.toString();
+        }
+
+        return grid;
+    }
+
+    public static ParentWidget<?> createXEIWidget(GTRecipeTypeUILayout layout) {
+        return new ParentWidget<>();
+    }
+
+    public static CycleButtonWidget createIOCycleButton(EnumSyncValue<IO> syncValue, boolean allowExtendedIO) {
+        // Done so the cycle button doesn't create states for every IO enum entry
+
+        IntSyncValue syncVal = new IntSyncValue(syncValue::getIntValue, syncValue::setIntValue);
+
+        var cycleButton = new CycleButtonWidget()
+                .stateCount(allowExtendedIO ? 4 : 2)
+                .stateOverlay(IO.IN, IO.IN.getUiTexture())
+                .stateOverlay(IO.OUT, IO.OUT.getUiTexture())
+                .value(syncVal)
+                .tooltipBuilder(
+                        r -> r.addLine(IKey.dynamic(() -> Component.translatable(syncValue.getValue().getTooltip()))));
+
+        if (allowExtendedIO) {
+            cycleButton.stateOverlay(IO.BOTH, IO.BOTH.getUiTexture());
+            cycleButton.stateOverlay(IO.NONE, IO.NONE.getUiTexture());
+        }
+
+        return cycleButton;
+    }
+
+    public static <T, S extends Filter<T, S>> ParentWidget<?> createFilterRow(ParentWidget<?> existingRow,
+                                                                              FilterHandler<T, S> filterHandler,
+                                                                              SidedPosGuiData data,
+                                                                              PanelSyncManager syncManager,
+                                                                              UISettings settings) {
+        var filterSlot = filterHandler.getFilterSlot();
+        // TODO get the panel to use the right sync handler when swapping from one item filter to the next
+        var panelHandler = syncManager.syncedPanel("filterPanel", true,
+                (sm, sh) -> filterHandler.loadFilter(filterSlot.getStackInSlot(0)).getPanel(data, sm, settings));
+
+        DynamicSyncHandler filterButton = new DynamicSyncHandler()
+                .widgetProvider((sm, buf) -> {
+                    ItemStack stack = buf.readItem();
+                    if (stack.isEmpty()) return new EmptyWidget();
+                    stack = filterSlot.getStackInSlot(0);
+                    S filter = filterHandler.loadFilter(stack);
+
+                    return new ButtonWidget<>()
+                            .onMousePressed((x, y, b) -> {
+                                panelHandler.openPanel();
+                                return true;
+                            });
+                });
+        return existingRow.child(new ItemSlot()
+                .slot(new ModularSlot(filterSlot, 0)
+                        .changeListener((stack, amount, client, init) -> filterButton
+                                .notifyUpdate(packet -> packet.writeItem(stack)))))
+                .child(new DynamicSyncedWidget<>().syncHandler(filterButton));
+    }
+
+    public static <T, S extends Filter<T, S>> ParentWidget<?> createFilterRow(FilterHandler<T, S> filterHandler,
+                                                                              SidedPosGuiData data,
+                                                                              PanelSyncManager syncManager,
+                                                                              UISettings settings) {
+        return createFilterRow(Flow.row().coverChildrenHeight().childPadding(2), filterHandler, data, syncManager,
+                settings);
+    }
+
+    private static int getIncrementValue(MouseData data, int step) {
+        int adjust = step;
+        if (data.shift()) adjust *= 4;
+        if (data.ctrl()) adjust *= 16;
+        if (data.alt()) adjust *= 64;
+        return adjust;
+    }
+
+    private static long getIncrementValue(MouseData data, long step) {
+        long adjust = step;
+        if (data.shift()) adjust *= 4;
+        if (data.ctrl()) adjust *= 16;
+        if (data.alt()) adjust *= 64;
+        return adjust;
+    }
+
+    private static IKey createAdjustOverlay(boolean increment) {
+        return createAdjustOverlay(increment, 1);
+    }
+
+    private static IKey createAdjustOverlay(boolean increment, long step) {
+        final StringBuilder builder = new StringBuilder();
+        builder.append(increment ? '+' : '-');
+        builder.append(getIncrementValue(MouseData.create(-1), step));
+
+        float scale = 1f;
+        if (builder.length() == 3) {
+            scale = 0.8f;
+        } else if (builder.length() == 4) {
+            scale = 0.6f;
+        } else if (builder.length() > 4) {
+            scale = 0.5f;
+        }
+        return IKey.str(builder.toString())
+                .color(Color.WHITE.main)
+                .scale(scale);
+    }
+
+    public static ParentWidget<?> createIntInputWithButtons(IntSyncValue syncValue, IntSupplier minValue,
+                                                            IntSupplier maxValue) {
+        return createIntInputWithButtons(syncValue, minValue, maxValue, 1, GTGuiTextures.DISPLAY);
+    }
+
+    public static ParentWidget<?> createIntInputWithButtons(IntSyncValue syncValue, IntSupplier minValue,
+                                                            IntSupplier maxValue, int step, IDrawable background) {
+        StringSyncValue formattedValue = new StringSyncValue(syncValue::getStringValue,
+                syncValue::setStringValue);
+
+        var textField = new TextFieldWidget() {
+
+            @Override
+            public boolean onMouseScrolled(double mouseX, double mouseY, double delta) {
+                int inc = (int) delta * getIncrementValue(MouseData.create(-1), 1);
+                int val = Mth.clamp(syncValue.getIntValue() + inc, minValue.getAsInt(),
+                        maxValue.getAsInt());
+                syncValue.setIntValue(val, true, true);
+                return true;
+            }
+        }.left(18).right(18)
+                .setTextAlignment(Alignment.Center)
+                .setTextColor(Color.WHITE.darker(1))
+                .setNumbers(minValue, maxValue)
+                .value(formattedValue)
+                .background(background);
+
+        return Flow.row()
+                .coverChildrenHeight()
+                .widthRel(1.0f)
+                .child(new ButtonWidget<>()
+                        .width(18)
+                        .onMousePressed((x, y, button) -> {
+                            int val = syncValue.getIntValue() - getIncrementValue(MouseData.create(button), step);
+                            val = Mth.clamp(val, minValue.getAsInt(), maxValue.getAsInt());
+                            syncValue.setIntValue(val, true, true);
+                            return true;
+                        })
+                        .onUpdateListener(w -> w.overlay(createAdjustOverlay(false, step))))
+                .child(textField)
+                .child(new ButtonWidget<>()
+                        .width(18).right(0)
+                        .onMousePressed((x, y, button) -> {
+                            int val = syncValue.getIntValue() + getIncrementValue(MouseData.create(button), step);
+                            val = Mth.clamp(val, minValue.getAsInt(), maxValue.getAsInt());
+                            syncValue.setIntValue(val, true, true);
+                            return true;
+                        })
+                        .onUpdateListener(w -> w.overlay(createAdjustOverlay(true, step))));
+    }
+
+    public static ParentWidget<?> createLongInputWithButtons(LongSyncValue syncValue, LongSupplier minValue,
+                                                             LongSupplier maxValue) {
+        return createLongInputWithButtons(syncValue, minValue, maxValue, 1, GTGuiTextures.DISPLAY);
+    }
+
+    public static ParentWidget<?> createLongInputWithButtons(LongSyncValue syncValue, LongSupplier minValue,
+                                                             LongSupplier maxValue, long step, IDrawable background) {
+        StringSyncValue formattedValue = new StringSyncValue(syncValue::getStringValue,
+                syncValue::setStringValue);
+
+        var textField = new TextFieldWidget() {
+
+            @Override
+            public boolean onMouseScrolled(double mouseX, double mouseY, double delta) {
+                long inc = (long) delta * getIncrementValue(MouseData.create(-1), 1);
+                long min = minValue.getAsLong();
+                long max = maxValue.getAsLong();
+                long value = syncValue.getLongValue() + inc;
+                syncValue.setLongValue(GTMath.clamp(value, minValue.getAsLong(), maxValue.getAsLong()),
+                        true, true);
+                return true;
+            }
+        }.left(18).right(18)
+                .setTextAlignment(Alignment.Center)
+                .setTextColor(Color.WHITE.darker(1))
+                .setNumbersLong(minValue, maxValue)
+                .value(formattedValue)
+                .background(background);
+
+        return Flow.row()
+                .coverChildrenHeight()
+                .widthRel(1.0f)
+                .child(new ButtonWidget<>()
+                        .width(18)
+                        .onMousePressed((x, y, button) -> {
+                            long value = syncValue.getLongValue() - getIncrementValue(MouseData.create(button), step);
+                            syncValue.setLongValue(GTMath.clamp(value, minValue.getAsLong(), maxValue.getAsLong()),
+                                    true, true);
+                            return true;
+                        })
+                        .onUpdateListener(w -> w.overlay(createAdjustOverlay(false, step))))
+                .child(textField)
+                .child(new ButtonWidget<>()
+                        .width(18).right(0)
+                        .onMousePressed((x, y, button) -> {
+                            long value = syncValue.getLongValue() + getIncrementValue(MouseData.create(button), step);
+                            long min = minValue.getAsLong();
+                            long max = maxValue.getAsLong();
+                            syncValue.setLongValue(value < min ? min : Math.min(value, max), true, true);
+                            return true;
+                        }).onUpdateListener(w -> w.overlay(createAdjustOverlay(true, step))));
+    }
+
+    public static ParentWidget<?> createIntInputWithBucketMode(IntSyncValue intSyncValue,
+                                                               EnumSyncValue<BucketMode> bucketModeSyncValue,
+                                                               IntSupplier maxMB) {
+        StringSyncValue formattedValue = new StringSyncValue(
+                () -> String.valueOf(intSyncValue.getValue()),
+                (v) -> intSyncValue.setValue(Integer.parseInt(v), true,
+                        true));
+
+        var textField = new TextFieldWidget() {
+
+            @Override
+            public boolean onMouseScrolled(double mouseX, double mouseY, double delta) {
+                int inc = (int) delta * (getIncrementValue(MouseData.create(-1), 1) *
+                        bucketModeSyncValue.getValue().multiplier);
+                int val = Mth.clamp(intSyncValue.getIntValue() + inc, 0, maxMB.getAsInt());
+                intSyncValue.setIntValue(val, true, true);
+                return true;
+            }
+        }.left(18).right(36)
+                .setTextAlignment(Alignment.Center)
+                .setTextColor(Color.WHITE.darker(1))
+                .setNumbers(0, maxMB.getAsInt())
+                .value(formattedValue)
+                .background(GTGuiTextures.DISPLAY);
+
+        return Flow.row()
+                .coverChildrenHeight()
+                .widthRel(1.0f)
+                .child(new ButtonWidget<>()
+                        .width(18)
+                        .onMousePressed((x, y, button) -> {
+                            int val = intSyncValue.getIntValue() - (getIncrementValue(MouseData.create(button), 1) *
+                                    bucketModeSyncValue.getValue().multiplier);
+                            val = Mth.clamp(val, 0, maxMB.getAsInt());
+                            intSyncValue.setIntValue(val, true, true);
+                            return true;
+                        })
+                        .onUpdateListener(w -> w.overlay(createAdjustOverlay(false))))
+                .child(textField)
+                .child(new ButtonWidget<>()
+                        .right(18)
+                        .width(18)
+                        .onMousePressed((x, y, button) -> {
+                            int val = intSyncValue.getIntValue() + (getIncrementValue(MouseData.create(button), 1) *
+                                    bucketModeSyncValue.getValue().multiplier);
+                            val = Mth.clamp(val, 0, maxMB.getAsInt());
+                            intSyncValue.setIntValue(val, true, true);
+                            return true;
+                        })
+                        .onUpdateListener(w -> w.overlay(createAdjustOverlay(true))))
+                .child(new CycleButtonWidget()
+                        .right(0)
+                        .width(18)
+                        .value(bucketModeSyncValue)
+                        .background(BucketMode.BUCKET.getIcon(), BucketMode.MILLI_BUCKET.getIcon()));
+    }
+
+    public static class EnumRowBuilder<T extends Enum<T>> {
+
+        private @Nullable EnumSyncValue<T> syncValue;
+        private final Class<T> enumValue;
+        private @Nullable IKey lang;
+        private IDrawable @Nullable [] background;
+        private @Nullable IDrawable selectedBackground;
+        private IDrawable @Nullable [] overlay;
+
+        public EnumRowBuilder(Class<T> enumValue) {
+            this.enumValue = enumValue;
+        }
+
+        public EnumRowBuilder<T> value(EnumSyncValue<T> syncValue) {
+            this.syncValue = syncValue;
+            return this;
+        }
+
+        public EnumRowBuilder<T> lang(IKey lang) {
+            this.lang = lang;
+            return this;
+        }
+
+        public EnumRowBuilder<T> background(IDrawable... background) {
+            this.background = background;
+            return this;
+        }
+
+        public EnumRowBuilder<T> selectedBackground(IDrawable selectedBackground) {
+            this.selectedBackground = selectedBackground;
+            return this;
+        }
+
+        public EnumRowBuilder<T> overlay(IDrawable... overlay) {
+            this.overlay = overlay;
+            return this;
+        }
+
+        public EnumRowBuilder<T> overlay(int size, IDrawable... overlay) {
+            this.overlay = new IDrawable[overlay.length];
+            for (int i = 0; i < overlay.length; i++) {
+                this.overlay[i] = overlay[i].asIcon().size(size);
+            }
+            return this;
+        }
+
+        private BoolValue.Dynamic boolValueOf(EnumSyncValue<T> syncValue, T value) {
+            return new BoolValue.Dynamic(() -> syncValue.getValue() == value, $ -> syncValue.setValue(value));
+        }
+
+        public Flow build() {
+            var row = Flow.row().coverChildrenHeight().widthRel(1f);
+            if (this.enumValue != null && this.syncValue != null) {
+                for (var enumVal : enumValue.getEnumConstants()) {
+                    var button = new ToggleButton().size(18).marginRight(2)
+                            .value(boolValueOf(this.syncValue, enumVal));
+
+                    if (this.background != null && this.background.length > 0)
+                        button.background(this.background);
+                    else
+                        button.background(GuiTextures.MC_BUTTON);
+
+                    if (this.selectedBackground != null)
+                        button.selectedBackground(this.selectedBackground);
+                    else
+                        button.selectedBackground(GuiTextures.MC_BUTTON_DISABLED);
+
+                    if (this.overlay != null)
+                        button.overlay(this.overlay[enumVal.ordinal()]);
+
+                    if (enumVal instanceof StringRepresentable serializable) {
+                        button.addTooltipLine(IKey.lang(serializable.getSerializedName()));
+                    }
+                    row.child(button);
+                }
+            }
+
+            if (this.lang != null)
+                row.child(this.lang.asWidget().posRel(Alignment.CenterRight).height(18));
+
+            return row;
+        }
+    }
+}
diff --git a/src/main/java/com/gregtechceu/gtceu/common/mui/GTMultiblockTextUtil.java b/src/main/java/com/gregtechceu/gtceu/common/mui/GTMultiblockTextUtil.java
new file mode 100644
index 00000000000..e3778f297e4
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/common/mui/GTMultiblockTextUtil.java
@@ -0,0 +1,496 @@
+package com.gregtechceu.gtceu.common.mui;
+
+import com.gregtechceu.gtceu.api.GTValues;
+import com.gregtechceu.gtceu.api.capability.recipe.FluidRecipeCapability;
+import com.gregtechceu.gtceu.api.capability.recipe.ItemRecipeCapability;
+import com.gregtechceu.gtceu.api.machine.multiblock.WorkableElectricMultiblockMachine;
+import com.gregtechceu.gtceu.api.machine.multiblock.WorkableMultiblockMachine;
+import com.gregtechceu.gtceu.api.machine.steam.SteamEnergyRecipeHandler;
+import com.gregtechceu.gtceu.api.recipe.GTRecipe;
+import com.gregtechceu.gtceu.api.recipe.RecipeHelper;
+import com.gregtechceu.gtceu.api.recipe.content.Content;
+import com.gregtechceu.gtceu.api.recipe.ingredient.IntProviderFluidIngredient;
+import com.gregtechceu.gtceu.api.recipe.ingredient.IntProviderIngredient;
+import com.gregtechceu.gtceu.utils.FormattingUtil;
+import com.gregtechceu.gtceu.utils.GTUtil;
+
+import net.minecraft.ChatFormatting;
+import net.minecraft.network.chat.Component;
+import net.minecraft.network.chat.HoverEvent;
+import net.minecraft.network.chat.MutableComponent;
+import net.minecraft.world.item.ItemStack;
+import net.minecraftforge.fluids.FluidStack;
+
+import brachy.modularui.api.drawable.IKey;
+import brachy.modularui.drawable.FluidDrawable;
+import brachy.modularui.drawable.ItemDrawable;
+import brachy.modularui.screen.RichTooltip;
+import brachy.modularui.utils.Alignment;
+import brachy.modularui.utils.Color;
+import brachy.modularui.value.sync.*;
+import brachy.modularui.widget.Widget;
+import brachy.modularui.widgets.DynamicSyncedWidget;
+import brachy.modularui.widgets.TextWidget;
+import brachy.modularui.widgets.layout.Flow;
+import org.jetbrains.annotations.Nullable;
+
+import java.util.Optional;
+import java.util.function.Supplier;
+
+public class GTMultiblockTextUtil {
+
+    public static TextWidget<?> addEnergyUsageLine(WorkableElectricMultiblockMachine weMachine,
+                                                   PanelSyncManager syncManager) {
+        LongSyncValue energyUsage = syncManager.getOrCreateSyncHandler("energyUsage", LongSyncValue.class,
+                () -> new LongSyncValue(() -> {
+                    var energyList = weMachine.getEnergyContainer();
+                    return Math.max(energyList.getInputVoltage(), energyList.getOutputVoltage());
+                }));
+        BooleanSyncValue isFormed = syncManager.getOrCreateSyncHandler("isFormed", BooleanSyncValue.class,
+                () -> new BooleanSyncValue(weMachine::isFormed));
+        BooleanSyncValue isActive = syncManager.getOrCreateSyncHandler("isActive", BooleanSyncValue.class,
+                () -> new BooleanSyncValue(() -> weMachine.getRecipeLogic().isActive()));
+
+        return IKey.dynamic(() -> {
+            String energyFormatted = FormattingUtil.formatNumbers(energyUsage.getLongValue());
+
+            byte voltageTier = GTUtil.getFloorTierByVoltage(energyUsage.getLongValue());
+            Component voltageName = Component.literal(
+                    GTValues.VNF[voltageTier]);
+
+            MutableComponent bodyText = Component.translatable("gtceu.multiblock.max_energy_per_tick",
+                    energyFormatted, voltageName).withStyle(ChatFormatting.GRAY);
+            Component hoverText = Component.translatable("gtceu.multiblock.max_energy_per_tick_hover")
+                    .withStyle(ChatFormatting.GRAY);
+            return bodyText
+                    .withStyle(style -> style.withHoverEvent(new HoverEvent(HoverEvent.Action.SHOW_TEXT, hoverText)));
+        })
+                .color(Color.WHITE.main)
+                .asWidget()
+                .setEnabledIf(widget -> isFormed.getBoolValue() && isActive.getBoolValue());
+    }
+
+    public static TextWidget<?> addEnergyUsageExactLine(WorkableElectricMultiblockMachine weMachine,
+                                                        PanelSyncManager syncManager) {
+        LongSyncValue energyUsage = syncManager.getOrCreateSyncHandler("energyUsage", LongSyncValue.class,
+                () -> new LongSyncValue(() -> {
+                    var energyList = weMachine.getEnergyContainer();
+                    return Math.max(energyList.getInputVoltage(), energyList.getOutputVoltage());
+                }));
+        return addEnergyUsageExactLine(weMachine, syncManager, energyUsage);
+    }
+
+    public static TextWidget<?> addEnergyUsageExactLine(WorkableElectricMultiblockMachine weMachine,
+                                                        PanelSyncManager syncManager, LongSyncValue energyUsage) {
+        BooleanSyncValue isFormed = syncManager.getOrCreateSyncHandler("isFormed", BooleanSyncValue.class,
+                () -> new BooleanSyncValue(weMachine::isFormed));
+
+        return IKey.dynamic(() -> {
+            if (energyUsage.getLongValue() <= 0) return Component.empty();
+            String energyFormatted = FormattingUtil.formatNumbers(energyUsage.getLongValue());
+            // wrap in text component to keep it from being formatted
+            Component voltageName = Component.literal(
+                    GTValues.VNF[GTUtil.getTierByVoltage(energyUsage.getLongValue())]);
+
+            return Component.translatable("gtceu.multiblock.energy_consumption",
+                    energyFormatted, voltageName).withStyle(ChatFormatting.GRAY);
+        })
+                .asWidget()
+                .setEnabledIf(widget -> isFormed.getBoolValue());
+    }
+
+    public static IKey addEnergyTierLine(boolean formed, int tier) {
+        if (!formed || tier < GTValues.ULV || tier > GTValues.MAX)
+            return IKey.EMPTY;
+
+        Component voltageName = Component.literal(GTValues.VNF[tier]);
+        MutableComponent bodyText = Component.translatable(
+                "gtceu.multiblock.max_recipe_tier",
+                voltageName).withStyle(ChatFormatting.GRAY);
+        Component hoverText = Component.translatable("gtceu.multiblock.max_recipe_tier_hover")
+                .withStyle(ChatFormatting.GRAY);
+        return IKey.dynamic(() -> bodyText
+                .withStyle(style -> style.withHoverEvent(new HoverEvent(HoverEvent.Action.SHOW_TEXT, hoverText))));
+    }
+
+    public static TextWidget<?> addProgressLine(WorkableMultiblockMachine rlMachine, PanelSyncManager syncManager) {
+        BooleanSyncValue isFormed = syncManager.getOrCreateSyncHandler("isFormed", BooleanSyncValue.class,
+                () -> new BooleanSyncValue(rlMachine::isFormed));
+
+        BooleanSyncValue isActive = syncManager.getOrCreateSyncHandler("isActive", BooleanSyncValue.class,
+                () -> new BooleanSyncValue(() -> rlMachine.getRecipeLogic().isActive()));
+        IntSyncValue currentProgress = syncManager.getOrCreateSyncHandler("currentProgress", IntSyncValue.class,
+                () -> new IntSyncValue(() -> rlMachine.getRecipeLogic().getProgress()));
+        IntSyncValue maxProgress = syncManager.getOrCreateSyncHandler("maxProgress", IntSyncValue.class,
+                () -> new IntSyncValue(() -> rlMachine.getRecipeLogic().getMaxProgress()));
+        DoubleSyncValue progressPercent = syncManager.getOrCreateSyncHandler("progressPercent", DoubleSyncValue.class,
+                () -> new DoubleSyncValue(() -> rlMachine.getRecipeLogic().getProgressPercent()));
+
+        return IKey.dynamic(() -> {
+            int progress = (int) (progressPercent.getDoubleValue() * 100.f);
+            float current = (float) currentProgress.getDoubleValue() / 20.f;
+            float max = (float) maxProgress.getDoubleValue() / 20.f;
+            return Component.translatable("gtceu.multiblock.progress",
+                    String.format("%.2f", current), String.format("%.2f", max), progress);
+        })
+                .color(Color.WHITE.main)
+                .asWidget()
+                .setEnabledIf(widget -> isFormed.getBoolValue() && isActive.getBoolValue());
+    }
+
+    public static TextWidget<?> addProgressLinePercentOnly(WorkableMultiblockMachine rlMachine,
+                                                           PanelSyncManager syncManager) {
+        BooleanSyncValue isFormed = syncManager.getOrCreateSyncHandler("isFormed", BooleanSyncValue.class,
+                () -> new BooleanSyncValue(rlMachine::isFormed));
+        BooleanSyncValue isActive = syncManager.getOrCreateSyncHandler("isActive", BooleanSyncValue.class,
+                () -> new BooleanSyncValue(() -> rlMachine.getRecipeLogic().isActive()));
+        DoubleSyncValue progressPercent = syncManager.getOrCreateSyncHandler("progressPercent", DoubleSyncValue.class,
+                () -> new DoubleSyncValue(() -> rlMachine.getRecipeLogic().getProgressPercent()));
+
+        return IKey.dynamic(() -> {
+            int currentProgress = (int) (progressPercent.getDoubleValue() * 100);
+            return Component.translatable("gtceu.multiblock.progress_percent", currentProgress);
+        })
+                .color(Color.WHITE.main)
+                .asWidget()
+                .setEnabledIf(widget -> isFormed.getBoolValue() && isActive.getBoolValue());
+    }
+
+    public static TextWidget<?> addEnergyTierLine(WorkableElectricMultiblockMachine rlMachine,
+                                                  PanelSyncManager syncManager) {
+        BooleanSyncValue isFormed = syncManager.getOrCreateSyncHandler("isFormed", BooleanSyncValue.class,
+                () -> new BooleanSyncValue(rlMachine::isFormed));
+
+        IntSyncValue tier = syncManager.getOrCreateSyncHandler("energyTier", IntSyncValue.class,
+                () -> new IntSyncValue(rlMachine::getTier));
+
+        return IKey.dynamic(() -> {
+            Component voltageName = Component.literal(GTValues.VNF[tier.getIntValue()]);
+            return Component.translatable(
+                    "gtceu.multiblock.max_recipe_tier",
+                    voltageName).withStyle(ChatFormatting.GRAY);
+        })
+                .asWidget()
+                .tooltip(new RichTooltip().add(Component.translatable("gtceu.multiblock.max_recipe_tier_hover")
+                        .withStyle(ChatFormatting.GRAY)))
+                .setEnabledIf(widget -> isFormed.getBoolValue());
+    }
+
+    public static TextWidget<?> addParallelLine(WorkableMultiblockMachine rlMachine, PanelSyncManager syncManager) {
+        IntSyncValue parallelAmount = syncManager.getOrCreateSyncHandler("parallelAmount", IntSyncValue.class,
+                () -> new IntSyncValue(() -> {
+                    if (rlMachine.getRecipeLogic().getLastRecipe() == null) return 0;
+                    return rlMachine.getRecipeLogic().getLastRecipe().parallels;
+                }));
+
+        return IKey.dynamic(() -> {
+            Component runs = Component.literal(FormattingUtil.formatNumbers(parallelAmount.getIntValue()))
+                    .withStyle(ChatFormatting.DARK_PURPLE);
+            String key = "gtceu.multiblock.parallel";
+            return Component.translatable(key, runs)
+                    .withStyle(ChatFormatting.GRAY);
+        }).asWidget()
+                .setEnabledIf(widget -> parallelAmount.getIntValue() > 1);
+    }
+
+    public static TextWidget<?> addBatchModeLine(WorkableMultiblockMachine rlMachine, PanelSyncManager syncManager) {
+        BooleanSyncValue batchEnabled = syncManager.getOrCreateSyncHandler("batchEnabled", BooleanSyncValue.class,
+                () -> new BooleanSyncValue(rlMachine::isBatchEnabled));
+        IntSyncValue batchAmount = syncManager.getOrCreateSyncHandler("batchAmount", IntSyncValue.class,
+                () -> new IntSyncValue(() -> {
+                    if (rlMachine.getRecipeLogic().getLastRecipe() == null) return 0;
+                    return rlMachine.getRecipeLogic().getLastRecipe().batchParallels;
+                }));
+
+        return IKey.dynamic(() -> {
+            Component runs = Component.literal(FormattingUtil.formatNumbers(batchAmount.getIntValue()))
+                    .withStyle(ChatFormatting.DARK_PURPLE);
+            String key = "gtceu.multiblock.batch_enabled";
+            return Component.translatable(key, runs)
+                    .withStyle(ChatFormatting.GRAY);
+        }).asWidget()
+                .setEnabledIf(widget -> batchEnabled.getBoolValue() && batchAmount.getIntValue() > 1);
+    }
+
+    public static TextWidget<?> addSubtickParallelsLine(WorkableMultiblockMachine rlMachine,
+                                                        PanelSyncManager syncManager) {
+        IntSyncValue subtickAmount = syncManager.getOrCreateSyncHandler("subtickAmount", IntSyncValue.class,
+                () -> new IntSyncValue(() -> {
+                    if (rlMachine.getRecipeLogic().getLastRecipe() == null) return 0;
+                    return rlMachine.getRecipeLogic().getLastRecipe().subtickParallels;
+                }));
+
+        return IKey.dynamic(() -> {
+            Component runs = Component.literal(FormattingUtil.formatNumbers(subtickAmount.getIntValue()))
+                    .withStyle(ChatFormatting.DARK_PURPLE);
+            String key = "gtceu.multiblock.subtick_parallels";
+            return Component.translatable(key, runs)
+                    .withStyle(ChatFormatting.GRAY);
+        }).asWidget()
+                .setEnabledIf(widget -> subtickAmount.getIntValue() > 1);
+    }
+
+    public static TextWidget<?> addTotalRunsLine(WorkableMultiblockMachine rlMachine, PanelSyncManager syncManager) {
+        IntSyncValue totalRunAmount = syncManager.getOrCreateSyncHandler("totalRunAmount", IntSyncValue.class,
+                () -> new IntSyncValue(() -> {
+                    if (rlMachine.getRecipeLogic().getLastRecipe() == null) return 0;
+                    return rlMachine.getRecipeLogic().getLastRecipe().getTotalRuns();
+                }));
+
+        return IKey.dynamic(() -> {
+            Component runs = Component.literal(FormattingUtil.formatNumbers(totalRunAmount.getIntValue()))
+                    .withStyle(ChatFormatting.DARK_PURPLE);
+            String key = "gtceu.multiblock.total_runs";
+            return Component.translatable(key, runs)
+                    .withStyle(ChatFormatting.GRAY);
+        }).asWidget()
+                .setEnabledIf(widget -> totalRunAmount.getIntValue() > 1);
+    }
+
+    public static TextWidget<?> addSteamUsageLine(@Nullable SteamEnergyRecipeHandler steamRH,
+                                                  PanelSyncManager syncManager) {
+        IntSyncValue steamAmount = syncManager.getOrCreateSyncHandler("steamTank", IntSyncValue.class,
+                () -> new IntSyncValue(() -> {
+                    if (steamRH == null) return 0;
+                    return steamRH.getSteamTank().getFluidInTank(0).getAmount();
+                }));
+        IntSyncValue steamCapacity = syncManager.getOrCreateSyncHandler("steamCapacity", IntSyncValue.class,
+                () -> new IntSyncValue(() -> {
+                    if (steamRH == null) return 0;
+                    return steamRH.getSteamTank().getTankCapacity(0);
+                }));
+
+        BooleanSyncValue hasSteamHandler = syncManager.getOrCreateSyncHandler("hasSteam", BooleanSyncValue.class,
+                () -> new BooleanSyncValue(() -> steamRH != null));
+
+        return IKey
+                .dynamic(() -> Component.translatable("gtceu.multiblock.steam.steam_stored",
+                        FormattingUtil.formatNumbers(steamAmount.getIntValue()),
+                        FormattingUtil.formatNumbers(steamCapacity.getIntValue())))
+                .color(Color.WHITE.main)
+                .asWidget()
+                .setEnabledIf((w) -> hasSteamHandler.getBoolValue());
+    }
+
+    public static TextWidget<?> addWorkingStatusLine(WorkableMultiblockMachine rlMachine,
+                                                     PanelSyncManager syncManager) {
+        return addWorkingStatusLine(rlMachine, syncManager,
+                () -> Component.translatable("gtceu.multiblock.work_paused").withStyle(ChatFormatting.GOLD),
+                () -> Component.translatable("gtceu.multiblock.running").withStyle(ChatFormatting.GREEN),
+                () -> Component.translatable("gtceu.multiblock.idling").withStyle(ChatFormatting.GRAY));
+    }
+
+    public static TextWidget<?> addWorkingStatusLine(WorkableMultiblockMachine rlMachine,
+                                                     PanelSyncManager syncManager,
+                                                     Supplier<Component> runningPerfectly) {
+        return addWorkingStatusLine(rlMachine, syncManager,
+                () -> Component.translatable("gtceu.multiblock.work_paused").withStyle(ChatFormatting.GOLD),
+                runningPerfectly,
+                () -> Component.translatable("gtceu.multiblock.idling").withStyle(ChatFormatting.GRAY));
+    }
+
+    public static TextWidget<?> addWorkingStatusLine(WorkableMultiblockMachine rlMachine, PanelSyncManager syncManager,
+                                                     Supplier<Component> workPaused,
+                                                     Supplier<Component> runningPerfectly,
+                                                     Supplier<Component> idling) {
+        BooleanSyncValue isFormed = syncManager.getOrCreateSyncHandler("isFormed", BooleanSyncValue.class,
+                () -> new BooleanSyncValue(rlMachine::isFormed));
+        BooleanSyncValue isActive = syncManager.getOrCreateSyncHandler("isActive", BooleanSyncValue.class,
+                () -> new BooleanSyncValue(() -> rlMachine.getRecipeLogic().isActive()));
+        BooleanSyncValue isWorkingEnabled = syncManager.getOrCreateSyncHandler("isWorkingEnabled",
+                BooleanSyncValue.class,
+                () -> new BooleanSyncValue(() -> rlMachine.getRecipeLogic().isWorkingEnabled()));
+
+        return IKey
+                .dynamic(() -> {
+                    if (!isFormed.getBoolValue()) return Component.empty();
+                    if (!isWorkingEnabled.getBoolValue()) {
+                        return workPaused.get();
+                    }
+                    if (isActive.getBoolValue()) {
+                        return runningPerfectly.get();
+                    }
+                    return idling.get();
+                })
+                .asWidget()
+                .setEnabledIf((w) -> isFormed.getBoolValue());
+    }
+
+    public static DynamicSyncedWidget<?> addOutputLines(WorkableMultiblockMachine rlmachine,
+                                                        PanelSyncManager syncManager) {
+        GenericSyncValue<GTRecipe> recipeSyncValue = syncManager.getOrCreateSyncHandler("GTRecipe",
+                GenericSyncValue.class,
+                () -> GenericSyncValue.builder(GTRecipe.class)
+                        .getter(() -> rlmachine.getRecipeLogic().getLastRecipe())
+                        .setter((newRecipe) -> {})
+                        .adapter(GTByteBufAdapters.GTRECIPE)
+                        .copy(GTRecipe::copy)
+                        .build());
+
+        DynamicLinkedSyncHandler<GenericSyncValue<GTRecipe>> dynamicLinkedSyncHandler = new DynamicLinkedSyncHandler<>(
+                recipeSyncValue)
+                .widgetProvider((syncManager1, recipeSyncHandler) -> {
+                    var list = Flow.column()
+                            .widthRel(1)
+                            .coverChildrenHeight()
+                            .crossAxisAlignment(Alignment.CrossAxis.START);
+                    GTRecipe recipe = recipeSyncHandler.getValue();
+                    if (recipe == null) return list;
+
+                    for (var output : recipe.getOutputContents(ItemRecipeCapability.CAP)) {
+                        var widget = createItemLineForOutput(output, recipe);
+                        if (widget.isEmpty()) continue;
+                        list.child(widget.get().width(187 - 3 - 3 - 2 - 2));
+                    }
+
+                    for (var output : recipe.getOutputContents(FluidRecipeCapability.CAP)) {
+                        var widget = createFluidLineForOutput(output, recipe);
+                        if (widget.isEmpty()) continue;
+                        list.child(widget.get().width(187 - 3 - 3 - 2 - 2));
+                    }
+
+                    return list;
+                });
+
+        return new DynamicSyncedWidget<>()
+                .widthRel(1)
+                .coverChildrenHeight()
+                .syncHandler(dynamicLinkedSyncHandler);
+    }
+
+    public static Optional<Widget<?>> createItemLineForOutput(Content itemOutput, GTRecipe recipe) {
+        int runs = recipe.getTotalRuns();
+        var function = recipe.getType().getChanceFunction();
+
+        int recipeTier = RecipeHelper.getPreOCRecipeEuTier(recipe);
+        int chanceTier = recipeTier + recipe.ocLevel;
+        double maxDurationSec = (double) recipe.duration / 20.0;
+
+        boolean rounded = false;
+        ItemStack stack;
+        // number of items output by a non-ranged ingredient
+        int count = 0;
+        // number of items output, but stored as a double. Used for accurate items/second display.
+        double countD = 1;
+        // number of items output which is actually displayed. Can be either a number, or a range.
+        Component displaycount;
+        if (itemOutput.content instanceof IntProviderIngredient provider) {
+            rounded = true;
+            stack = provider.getMaxSizeStack();
+            displaycount = Component.translatable("gtceu.gui.content.range",
+                    provider.getCountProvider().getMinValue(),
+                    provider.getCountProvider().getMaxValue());
+            if (itemOutput.chance < itemOutput.maxChance) {
+                countD = countD * runs * function.getBoostedChance(itemOutput, recipeTier, chanceTier) /
+                        itemOutput.maxChance;
+            }
+            countD = countD * provider.getMidRoll();
+        } else {
+            var stacks = ItemRecipeCapability.CAP.of(itemOutput.content).getItems();
+            if (stacks.length == 0) return Optional.empty();
+            stack = stacks[0];
+            count = stack.getCount();
+            countD *= count;
+            if (itemOutput.chance < itemOutput.maxChance) {
+                rounded = true;
+                countD = countD * runs * function.getBoostedChance(itemOutput, recipeTier, chanceTier) /
+                        itemOutput.maxChance;
+            }
+            count = Math.max(1, (int) Math.round(countD));
+            displaycount = Component.literal(String.valueOf(count));
+        }
+        if (countD < maxDurationSec) {
+            String key = "gtceu.multiblock.output_line." + (rounded ? "2" : "0");
+            return Optional.of(
+                    Flow.row()
+                            .coverChildren()
+                            .childPadding(2)
+                            .child(new ItemDrawable(stack).asWidget())
+                            .child(
+                                    IKey.lang(
+                                            Component.translatable(key, stack.getHoverName(), displaycount,
+                                                    FormattingUtil.formatNumber2Places(maxDurationSec / countD)))
+                                            .asWidget()));
+        } else {
+            String key = "gtceu.multiblock.output_line." + (rounded ? "3" : "1");
+            return Optional.of(
+                    Flow.row()
+                            .coverChildren()
+                            .childPadding(2)
+                            .child(new ItemDrawable(stack).asWidget())
+                            .child(
+                                    IKey.lang(
+                                            Component.translatable(key, stack.getHoverName(), displaycount,
+                                                    FormattingUtil.formatNumber2Places(countD / maxDurationSec)))
+                                            .asWidget()));
+        }
+    }
+
+    public static Optional<Widget<?>> createFluidLineForOutput(Content fluidOutput, GTRecipe recipe) {
+        int runs = recipe.getTotalRuns();
+        var function = recipe.getType().getChanceFunction();
+
+        int recipeTier = RecipeHelper.getPreOCRecipeEuTier(recipe);
+        int chanceTier = recipeTier + recipe.ocLevel;
+        double maxDurationSec = (double) recipe.duration / 20.0;
+
+        boolean rounded = false;
+        FluidStack stack;
+        // amount of fluid output by a non-ranged ingredient
+        int amount = 0;
+        // amount of fluid output, but stored as a double. Used for accurate fluid/second display.
+        double amountD = 1;
+        // amount of fluid output which is actually displayed. Can be either a number, or a range.
+        Component displaycount;
+        if (fluidOutput.content instanceof IntProviderFluidIngredient provider) {
+            rounded = true;
+            stack = provider.getMaxSizeStack();
+            displaycount = Component.translatable("gtceu.gui.content.range",
+                    provider.getCountProvider().getMinValue(),
+                    provider.getCountProvider().getMaxValue());
+            if (fluidOutput.chance < fluidOutput.maxChance) {
+                amountD = amountD * runs * function.getBoostedChance(fluidOutput, recipeTier, chanceTier) /
+                        fluidOutput.maxChance;
+            }
+            amountD = amountD * provider.getMidRoll();
+        } else {
+            var stacks = FluidRecipeCapability.CAP.of(fluidOutput.content).getStacks();
+            if (stacks.length == 0) return Optional.empty();
+            stack = stacks[0];
+            amount = stack.getAmount();
+            amountD *= amount;
+            if (fluidOutput.chance < fluidOutput.maxChance) {
+                rounded = true;
+                amountD = amountD * runs * function.getBoostedChance(fluidOutput, recipeTier, chanceTier) /
+                        fluidOutput.maxChance;
+            }
+            amount = Math.max(1, (int) Math.round(amountD));
+            displaycount = Component.literal(String.valueOf(amount));
+        }
+        if (amountD < maxDurationSec) {
+            String key = "gtceu.multiblock.output_line." + (rounded ? "2" : "0");
+            return Optional.of(
+                    Flow.row()
+                            .coverChildren()
+                            .childPadding(2)
+                            .child(new FluidDrawable(stack).asWidget())
+                            .child(
+                                    IKey.lang(
+                                            Component.translatable(key, stack.getDisplayName(), displaycount,
+                                                    FormattingUtil.formatNumber2Places(maxDurationSec / amountD)))
+                                            .asWidget()));
+        } else {
+            String key = "gtceu.multiblock.output_line." + (rounded ? "3" : "1");
+            return Optional.of(
+                    Flow.row()
+                            .coverChildren()
+                            .childPadding(2)
+                            .child(new FluidDrawable(stack).asWidget())
+                            .child(
+                                    IKey.lang(
+                                            Component.translatable(key, stack.getDisplayName(), displaycount,
+                                                    FormattingUtil.formatNumber2Places(amountD / maxDurationSec)))
+                                            .asWidget()));
+        }
+    }
+}
diff --git a/src/main/java/com/gregtechceu/gtceu/common/mui/GTSingleblockMachinePanels.java b/src/main/java/com/gregtechceu/gtceu/common/mui/GTSingleblockMachinePanels.java
new file mode 100644
index 00000000000..ea29de3fd39
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/common/mui/GTSingleblockMachinePanels.java
@@ -0,0 +1,148 @@
+package com.gregtechceu.gtceu.common.mui;
+
+import com.gregtechceu.gtceu.GTCEu;
+import com.gregtechceu.gtceu.api.machine.MetaMachine;
+import com.gregtechceu.gtceu.api.machine.SimpleTieredMachine;
+import com.gregtechceu.gtceu.api.machine.mui.MachineUIPanel;
+import com.gregtechceu.gtceu.api.machine.mui.MachineUIPanelBuilder;
+import com.gregtechceu.gtceu.api.machine.steam.SimpleSteamMachine;
+import com.gregtechceu.gtceu.api.mui.factory.PanelFactory;
+import com.gregtechceu.gtceu.api.recipe.gui.GTRecipeTypeUIs;
+
+import brachy.modularui.factory.PosGuiData;
+import brachy.modularui.screen.ModularPanel;
+import brachy.modularui.screen.UISettings;
+import brachy.modularui.utils.Alignment;
+import brachy.modularui.value.sync.PanelSyncManager;
+import brachy.modularui.widgets.layout.Flow;
+
+public class GTSingleblockMachinePanels {
+
+    public static PanelFactory GENERAL_MACHINE = (PosGuiData data, PanelSyncManager syncManager, UISettings settings,
+                                                  MetaMachine machine) -> {
+        if (!(machine instanceof SimpleTieredMachine simpleTieredMachine)) {
+            GTCEu.LOGGER.error("{} is not a WorkableTieredMachine, can not add slots to its content",
+                    machine.getDefinition().getName());
+            return new ModularPanel<>(machine.getDefinition().getName());
+        }
+
+        return MachineUIPanelBuilder.defaultSimpleSingleblockPanelBuilder(machine).mainContents((parent) -> {
+            var inputItemGrid = GTMuiWidgets.createGrid(simpleTieredMachine.importItems.getSize(), 3, false, 'i');
+            var inputFluidGrid = GTMuiWidgets.createGrid(simpleTieredMachine.importFluids.getSize(), 3, false, 'f');
+            var outputItemGrid = GTMuiWidgets.createGrid(simpleTieredMachine.exportItems.getSize(), 3, true, 'i');
+            var outputFluidGrid = GTMuiWidgets.createGrid(simpleTieredMachine.exportFluids.getSize(), 3, true, 'f');
+
+            int slotHeight = Math.max(inputItemGrid.length + inputFluidGrid.length,
+                    outputItemGrid.length + outputFluidGrid.length);
+            boolean hasXEI = GTRecipeTypeUIs.recipeTypeUIs.containsKey(simpleTieredMachine.getRecipeType());
+
+            var theme = machine.getDefinition().getThemeId();
+
+            parent.child(Flow.row()
+                    .size(MachineUIPanel.DEFAULT_CONTENT_WIDTH, 18 + 9 + 18 * Math.max(2, slotHeight))
+                    .childIf(hasXEI, () -> GTRecipeTypeUIs.recipeTypeUIs.get(simpleTieredMachine.getRecipeType())
+                            .getBackedSlotsRow(syncManager, theme, simpleTieredMachine.importItems,
+                                    simpleTieredMachine.exportItems,
+                                    simpleTieredMachine.importFluids, simpleTieredMachine.exportFluids,
+                                    simpleTieredMachine.recipeLogic::getProgressPercent,
+                                    -1)));
+        }).build(syncManager, settings).excludeAreaInRecipeViewer();
+    };
+
+    public static PanelFactory MACERATOR = (PosGuiData data, PanelSyncManager syncManager, UISettings settings,
+                                            MetaMachine machine) -> {
+        if (!(machine instanceof SimpleTieredMachine simpleTieredMachine)) {
+            GTCEu.LOGGER.error("{} is not a SimpleTieredMachine, can not add slots to its content",
+                    machine.getDefinition().getName());
+            return new ModularPanel<>(machine.getDefinition().getName());
+        }
+
+        return MachineUIPanelBuilder.defaultSimpleSingleblockPanelBuilder(machine).mainContents((parent) -> {
+
+            var inputItemGrid = GTMuiWidgets.createGrid(simpleTieredMachine.importItems.getSize(), 3, false, 'i');
+            var inputFluidGrid = GTMuiWidgets.createGrid(simpleTieredMachine.importFluids.getSize(), 3, false, 'f');
+            var outputItemGrid = GTMuiWidgets.createGrid(simpleTieredMachine.exportItems.getSize(), 3, true, 'i');
+            var outputFluidGrid = GTMuiWidgets.createGrid(simpleTieredMachine.exportFluids.getSize(), 3, true, 'f');
+
+            int slotHeight = Math.max(inputItemGrid.length + inputFluidGrid.length,
+                    outputItemGrid.length + outputFluidGrid.length);
+            boolean hasXEI = GTRecipeTypeUIs.recipeTypeUIs.containsKey(simpleTieredMachine.getRecipeType());
+
+            var theme = machine.getDefinition().getThemeId();
+
+            parent.child(Flow.row()
+                    .size(MachineUIPanel.DEFAULT_CONTENT_WIDTH, 18 + 9 + 18 * Math.max(2, slotHeight))
+                    .childIf(hasXEI, () -> GTRecipeTypeUIs.recipeTypeUIs.get(simpleTieredMachine.getRecipeType())
+                            .getBackedSlotsRow(syncManager, theme, simpleTieredMachine.importItems,
+                                    simpleTieredMachine.exportItems,
+                                    simpleTieredMachine.importFluids, simpleTieredMachine.exportFluids,
+                                    simpleTieredMachine.recipeLogic::getProgressPercent,
+                                    simpleTieredMachine.getTier())
+                            .posRel(Alignment.Center)));
+        }).build(syncManager, settings).excludeAreaInRecipeViewer();
+    };
+
+    public static PanelFactory ARC_FURNACE = (PosGuiData data, PanelSyncManager syncManager, UISettings settings,
+                                              MetaMachine machine) -> {
+        if (!(machine instanceof SimpleTieredMachine simpleTieredMachine)) {
+            GTCEu.LOGGER.error("{} is not a WorkableTieredMachine, can not add slots to its content",
+                    machine.getDefinition().getName());
+            return new ModularPanel<>(machine.getDefinition().getName());
+        }
+
+        return MachineUIPanelBuilder.defaultSimpleSingleblockPanelBuilder(machine).mainContents((parent) -> {
+            var inputItemGrid = GTMuiWidgets.createGrid(simpleTieredMachine.importItems.getSize(), 3, false, 'i');
+            var inputFluidGrid = GTMuiWidgets.createGrid(simpleTieredMachine.importFluids.getSize(), 3, false, 'f');
+            var outputItemGrid = GTMuiWidgets.createGrid(simpleTieredMachine.exportItems.getSize(), 3, true, 'i');
+            var outputFluidGrid = GTMuiWidgets.createGrid(simpleTieredMachine.exportFluids.getSize(), 3, true, 'f');
+
+            int slotHeight = Math.max(inputItemGrid.length + inputFluidGrid.length,
+                    outputItemGrid.length + outputFluidGrid.length);
+
+            var theme = machine.getDefinition().getThemeId();
+
+            boolean hasXEI = GTRecipeTypeUIs.recipeTypeUIs.containsKey(simpleTieredMachine.getRecipeType());
+
+            parent.child(Flow.row()
+                    .size(MachineUIPanel.DEFAULT_CONTENT_WIDTH, 18 + 9 + 18 * Math.max(2, slotHeight))
+                    .childIf(hasXEI, () -> GTRecipeTypeUIs.recipeTypeUIs.get(simpleTieredMachine.getRecipeType())
+                            .getBackedSlotsRow(syncManager, theme, simpleTieredMachine.importItems,
+                                    simpleTieredMachine.exportItems,
+                                    simpleTieredMachine.importFluids, simpleTieredMachine.exportFluids,
+                                    simpleTieredMachine.recipeLogic::getProgressPercent,
+                                    0)
+                            .posRel(Alignment.Center)));
+        }).build(syncManager, settings).excludeAreaInRecipeViewer();
+    };
+
+    public static PanelFactory STEAM_MACHINE = (PosGuiData data, PanelSyncManager syncManager, UISettings settings,
+                                                MetaMachine machine) -> {
+        if (!(machine instanceof SimpleSteamMachine steamMachine)) {
+            GTCEu.LOGGER.error("{} is not a SimpleSteamMachine, can not add slots to its content",
+                    machine.getDefinition().getName());
+            return new ModularPanel<>(machine.getDefinition().getName());
+        }
+
+        return MachineUIPanelBuilder.defaultSteamMachineBuilder(machine).mainContents(parent -> {
+            var inputItemGrid = GTMuiWidgets.createGrid(steamMachine.importItems.getSize(), 3, false, 'i');
+            var outputItemGrid = GTMuiWidgets.createGrid(steamMachine.exportItems.getSize(), 3, true, 'i');
+
+            int slotHeight = Math.max(inputItemGrid.length,
+                    outputItemGrid.length);
+
+            boolean hasXEI = GTRecipeTypeUIs.recipeTypeUIs.containsKey(steamMachine.getRecipeType());
+
+            var theme = machine.getDefinition().getThemeId();
+
+            parent.child(Flow.row()
+                    .size(MachineUIPanel.DEFAULT_CONTENT_WIDTH, 18 + 9 + 18 * Math.max(2, slotHeight))
+                    .childIf(hasXEI, () -> GTRecipeTypeUIs.recipeTypeUIs.get(steamMachine.getRecipeType())
+                            .getBackedSlotsRow(syncManager, theme, steamMachine.importItems,
+                                    steamMachine.exportItems,
+                                    null, null,
+                                    steamMachine.recipeLogic::getProgressPercent,
+                                    steamMachine.getTier())
+                            .posRel(Alignment.Center)));
+        }).build(syncManager, settings).excludeAreaInRecipeViewer();
+    };
+}
diff --git a/src/main/java/com/gregtechceu/gtceu/common/mui/drawable/BorderDrawable.java b/src/main/java/com/gregtechceu/gtceu/common/mui/drawable/BorderDrawable.java
new file mode 100644
index 00000000000..55e7c463f40
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/common/mui/drawable/BorderDrawable.java
@@ -0,0 +1,43 @@
+package com.gregtechceu.gtceu.common.mui.drawable;
+
+import brachy.modularui.api.drawable.IDrawable;
+import brachy.modularui.screen.viewport.GuiContext;
+import brachy.modularui.theme.WidgetTheme;
+import lombok.Getter;
+import lombok.Setter;
+import lombok.experimental.Accessors;
+
+import java.util.function.IntSupplier;
+
+@Accessors(fluent = true)
+public class BorderDrawable implements IDrawable {
+
+    @Getter
+    @Setter
+    private IntSupplier color = () -> 0xFFFFFFFF;
+    @Getter
+    @Setter
+    private int borderWidth = 2;
+
+    public BorderDrawable() {}
+
+    public BorderDrawable(int color, int borderWidth) {
+        this.color = () -> color;
+        this.borderWidth = borderWidth;
+    }
+
+    public BorderDrawable(IntSupplier color, int borderWidth) {
+        this.color = color;
+        this.borderWidth = borderWidth;
+    }
+
+    @Override
+    public void draw(GuiContext context, int x, int y, int width, int height, WidgetTheme widgetTheme) {
+        context.getGraphics().fill(x - borderWidth, y - borderWidth, x + borderWidth + width, y, color.getAsInt());
+        context.getGraphics().fill(x - borderWidth, y - borderWidth, x, y + borderWidth + height, color.getAsInt());
+        context.getGraphics().fill(x + width, y - borderWidth, x + width + borderWidth, y + height + borderWidth,
+                color.getAsInt());
+        context.getGraphics().fill(x - borderWidth, y + height, x + borderWidth + width, y + height + borderWidth,
+                color.getAsInt());
+    }
+}
diff --git a/src/main/java/com/gregtechceu/gtceu/common/mui/factory/CentralMonitorUIFactory.java b/src/main/java/com/gregtechceu/gtceu/common/mui/factory/CentralMonitorUIFactory.java
new file mode 100644
index 00000000000..4da57c0019b
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/common/mui/factory/CentralMonitorUIFactory.java
@@ -0,0 +1,371 @@
+package com.gregtechceu.gtceu.common.mui.factory;
+
+import com.gregtechceu.gtceu.GTCEu;
+import com.gregtechceu.gtceu.api.capability.IMonitorComponent;
+import com.gregtechceu.gtceu.api.item.IComponentItem;
+import com.gregtechceu.gtceu.api.item.component.IItemComponent;
+import com.gregtechceu.gtceu.api.item.component.IMonitorModuleItem;
+import com.gregtechceu.gtceu.api.machine.MetaMachine;
+import com.gregtechceu.gtceu.api.mui.factory.PanelFactory;
+import com.gregtechceu.gtceu.common.data.machines.GTMultiMachines;
+import com.gregtechceu.gtceu.common.machine.multiblock.electric.CentralMonitorMachine;
+import com.gregtechceu.gtceu.common.machine.multiblock.electric.monitor.MonitorGroup;
+import com.gregtechceu.gtceu.common.mui.GTGuiTextures;
+import com.gregtechceu.gtceu.common.mui.GTMuiWidgets;
+import com.gregtechceu.gtceu.common.mui.drawable.BorderDrawable;
+import com.gregtechceu.gtceu.common.mui.widgets.SimpleDialog;
+
+import net.minecraft.core.BlockPos;
+import net.minecraft.network.chat.Component;
+import net.minecraft.world.item.ItemStack;
+
+import brachy.modularui.api.GuiAxis;
+import brachy.modularui.api.IPanelHandler;
+import brachy.modularui.api.drawable.IDrawable;
+import brachy.modularui.api.drawable.IKey;
+import brachy.modularui.api.value.IValue;
+import brachy.modularui.api.widget.IWidget;
+import brachy.modularui.drawable.DynamicDrawable;
+import brachy.modularui.drawable.GuiTextures;
+import brachy.modularui.factory.PosGuiData;
+import brachy.modularui.screen.ModularPanel;
+import brachy.modularui.screen.UISettings;
+import brachy.modularui.utils.Alignment;
+import brachy.modularui.value.BoolValue;
+import brachy.modularui.value.sync.*;
+import brachy.modularui.widgets.*;
+import brachy.modularui.widgets.layout.Flow;
+import brachy.modularui.widgets.layout.Grid;
+import brachy.modularui.widgets.slot.ItemSlot;
+import brachy.modularui.widgets.slot.ModularSlot;
+import brachy.modularui.widgets.textfield.TextFieldWidget;
+import com.mojang.blaze3d.platform.InputConstants;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.function.Function;
+import java.util.function.IntSupplier;
+
+import static com.gregtechceu.gtceu.common.mui.GTByteBufAdapters.MONITOR_GROUPS;
+
+public class CentralMonitorUIFactory implements PanelFactory {
+
+    public static final CentralMonitorUIFactory INSTANCE = new CentralMonitorUIFactory();
+
+    @Override
+    public ModularPanel<?> buildUIFunction(PosGuiData data, PanelSyncManager syncManager, UISettings settings,
+                                           MetaMachine metaMachine) {
+        if (!(metaMachine instanceof CentralMonitorMachine machine)) return new ModularPanel<>("main");
+        GenericListSyncHandler<MonitorGroup> groupSync = new GenericListSyncHandler<>(machine::getMonitorGroups,
+                machine::setMonitorGroups, MONITOR_GROUPS, MONITOR_GROUPS,
+                MONITOR_GROUPS, null);
+        syncManager.syncValue("monitor_groups_sync", groupSync);
+        List<MonitorGroup> groups = new ArrayList<>(machine.getMonitorGroups());
+        IPanelHandler helpPanel = syncManager.syncedPanel(
+                "help_panel", true,
+                (syncManager1, panelHandler1) -> createHelpPanel());
+        Function<SortableListWidget.Item<MonitorGroup>, SortableListWidget.Item<MonitorGroup>> processGroupItem = item -> {
+            IPanelHandler panelHandler = syncManager.syncedPanel(
+                    "editor_" + groups.indexOf(item.getWidgetValue()), true,
+                    (syncManager1, panelHandler1) -> this.createGroupEditorPanel(
+                            syncManager1, groupSync,
+                            machine, item.getWidgetValue(),
+                            groups, helpPanel));
+            return item.child(Flow.row()
+                    .height(20)
+                    .child(new TextWidget<>(IKey.dynamic(() -> Component.literal(item.getWidgetValue().getName())))
+                            .paddingLeft(5)
+                            .widthRelOffset(1, -38))
+                    .child(new ButtonWidget<>()
+                            .background(GuiTextures.EDIT)
+                            .hoverBackground(GuiTextures.EDIT, new BorderDrawable())
+                            .onMousePressed((mouseX, mouseY, button) -> {
+                                panelHandler.openPanel();
+                                return true;
+                            }))
+                    .child(new ButtonWidget<>()
+                            .background(GuiTextures.CLOSE)
+                            .hoverBackground(GuiTextures.CLOSE, new BorderDrawable())
+                            .onMousePressed((mouseX, mouseY, button) -> {
+                                groups.remove(item.getWidgetValue());
+                                groupSync.setValue(groups);
+                                item.removeSelfFromList();
+                                return true;
+                            })));
+        };
+        DynamicSyncHandler listHandler = new DynamicSyncHandler()
+                .widgetProvider((psm, buf) -> new SortableListWidget<MonitorGroup>()
+                        .children(groups.stream()
+                                .map(SortableListWidget.Item::new)
+                                .map(processGroupItem)
+                                .toList())
+                        .onChange(groupSync::setValue)
+                        .widthRel(1));
+        listHandler.notifyUpdate(buf -> {});
+        return new Dialog<>("main")
+                .draggable(true)
+                .padding(5)
+                .excludeAreaInRecipeViewer()
+                .child(GTMuiWidgets.createTitleBar(GTMultiMachines.CENTRAL_MONITOR, 176))
+                .child(new Flow(GuiAxis.Y)
+                        .heightRel(1)
+                        .widthRel(1)
+                        .padding(2)
+                        .child(new Flow(GuiAxis.X)
+                                .child(new TextWidget<>(IKey.lang("gtceu.central_monitor.gui.monitor_groups"))
+                                        .leftRel(0))
+                                .child(new ButtonWidget<>()
+                                        .leftRel(1)
+                                        .background(GuiTextures.MC_BUTTON, GuiTextures.ADD)
+                                        .hoverBackground(GuiTextures.MC_BUTTON_HOVERED, GuiTextures.ADD)
+                                        .syncHandler(new InteractionSyncHandler()
+                                                .setOnMousePressed(mouseData -> {
+                                                    MonitorGroup group = new MonitorGroup(getNewGroupName(groupSync));
+                                                    groups.add(group);
+                                                    GTCEu.LOGGER.info("adding group: {} isClient = {}", groups,
+                                                            syncManager.isClient());
+                                                    groupSync.setValue(groups, true, false);
+                                                    listHandler.notifyUpdate(buf -> {});
+                                                })))
+                                .widthRel(1).height(20))
+                        .child(new DynamicSyncedWidget<>()
+                                .syncHandler(listHandler)
+                                .widthRel(1)
+                                .heightRelOffset(() -> 1, -96))
+                        .child(SlotGroupWidget.playerInventory(false)));
+    }
+
+    private ModularPanel<?> createGroupEditorPanel(PanelSyncManager syncManager,
+                                                   GenericListSyncHandler<MonitorGroup> groupSync,
+                                                   CentralMonitorMachine machine, MonitorGroup group,
+                                                   List<MonitorGroup> groups,
+                                                   IPanelHandler helpPanel) {
+        List<List<IWidget>> matrix = new ArrayList<>();
+        int matrixWidth = 0;
+        for (int row = 0; row <= machine.getDownDist() + machine.getUpDist(); row++) {
+            List<IWidget> curRow = new ArrayList<>();
+            matrix.add(curRow);
+            for (int col = 0; col <= machine.getLeftDist() + machine.getRightDist(); col++) {
+                IMonitorComponent component = machine.getComponent(row, col);
+                IDrawable texture = component == null ? GuiTextures.CROSS : component.getIcon();
+                int finalCol = col;
+                int finalRow = row;
+                IPanelHandler slotDialogHandler = component == null || component.getDataItems() == null ?
+                        null :
+                        syncManager.syncedPanel(
+                                "slot_dialog_" + finalCol + "_" + finalRow + "_" + groups.indexOf(group),
+                                true,
+                                (syncManager1, panelHandler1) -> new SimpleDialog<>(
+                                        "slot_number_dialog_" + finalCol + "_" + finalRow + "_" + groups.indexOf(group),
+                                        slot -> {
+                                            group.setTarget(component.getBlockPos());
+                                            group.setDataSlot(slot - 1);
+                                            groupSync.setValue(groups);
+                                        },
+                                        new TextFieldWidget().setNumbers(1, component.getDataItems().getSlots()),
+                                        w -> Integer.parseInt(w.getText()),
+                                        IKey.lang("gtceu.central_monitor.gui.data_slot")).draggable(true)
+                                        .size(160, 80));
+                IntSupplier colorSupplier = () -> {
+                    if (component == null) return 0;
+                    boolean inGroup = group.contains(component.getBlockPos());
+                    BlockPos target = group.getTargetRaw();
+                    boolean isTarget = target != null && target.asLong() == component.getBlockPos().asLong();
+                    if (inGroup && isTarget) return 0xFFFF00FF;
+                    else if (inGroup) return 0xFFFF0000;
+                    else if (isTarget) return 0xFF0000FF;
+                    else return 0;
+                };
+                curRow.add(new ButtonWidget<>()
+                        .margin(1)
+                        .background(texture, new BorderDrawable(colorSupplier, 1), IKey.dynamic(() -> {
+                            if (component == null || component.getDataItems() == null) return Component.empty();
+                            BlockPos target = group.getTargetRaw();
+                            boolean isTarget = target != null && target.asLong() == component.getBlockPos().asLong();
+                            if (isTarget) return Component.literal(String.valueOf(group.getDataSlot() + 1));
+                            else return Component.empty();
+                        }))
+                        .hoverBackground(texture, new BorderDrawable(() -> colorSupplier.getAsInt() | 0x222222, 1))
+                        .onMousePressed((mouseX, mouseY, button) -> {
+                            if (component == null) return true;
+                            if (button == InputConstants.MOUSE_BUTTON_LEFT) {
+                                if (!component.isMonitor()) return true;
+                                if (group.contains(component.getBlockPos())) {
+                                    group.remove(component.getBlockPos());
+                                } else {
+                                    group.add(component.getBlockPos());
+                                }
+                            } else if (button == InputConstants.MOUSE_BUTTON_RIGHT) {
+                                if (slotDialogHandler != null) {
+                                    slotDialogHandler.openPanel();
+                                } else group.setTarget(component.getBlockPos());
+                            }
+                            groupSync.setValue(groups);
+                            return true;
+                        }));
+            }
+            matrixWidth = Math.max(matrixWidth, curRow.size() * 20);
+        }
+        int matrixHeight = matrix.size() * 20;
+        IPanelHandler moduleEditor = createModulePanelHandler(
+                syncManager,
+                group.getItemStackHandler().getStackInSlot(0),
+                group, machine);
+        BoolValue moduleChanged = new BoolValue(false);
+        return new ModularPanel<>("editor_" + groups.indexOf(group) + "_panel")
+                .width(Math.max(matrixWidth, 150))
+                .height(matrixHeight + 60)
+                .excludeAreaInRecipeViewer()
+                .child(Flow.column()
+                        .padding(10)
+                        .child(new TextWidget<>(IKey.lang("gtceu.central_monitor.gui.group_editor")))
+                        .child(Flow.row()
+                                .height(20)
+                                .child(new TextWidget<>(IKey.lang("gtceu.central_monitor.gui.group_name"))
+                                        .paddingRight(4))
+                                .child(new TextFieldWidget()
+                                        .value(SyncHandlers.string(group::getName, group::setName)))
+                                .child(new ItemSlot()
+                                        .slot(group.getItemStackHandler(), 0)
+                                        .name("module_slot")
+                                        .slot(new ModularSlot(group.getItemStackHandler(), 0)
+                                                .changeListener((item, amount, client, init) -> {
+                                                    if (!amount && !init)
+                                                        moduleChanged.setValue(true);
+                                                })))
+                                .child(new ButtonWidget<>()
+                                        .background(
+                                                new DynamicDrawable(() -> moduleChanged.getValue() ?
+                                                        GuiTextures.MC_BUTTON_DISABLED :
+                                                        GuiTextures.MC_BUTTON),
+                                                GuiTextures.EDIT)
+                                        .hoverBackground(
+                                                new DynamicDrawable(() -> moduleChanged.getValue() ?
+                                                        GuiTextures.MC_BUTTON_DISABLED :
+                                                        GuiTextures.MC_BUTTON_HOVERED),
+                                                GuiTextures.EDIT)
+                                        .setEnabledIf(w -> !group.getItemStackHandler().getStackInSlot(0).isEmpty())
+                                        .addTooltipLine(IKey.lang(() -> moduleChanged.getValue() ?
+                                                "gtceu.gui.central_monitor.module_editor_disabled" :
+                                                "gtceu.gui.central_monitor.module_editor_button"))
+                                        .onMousePressed((mouseX, mouseY, button) -> {
+                                            if (moduleEditor != null && !moduleChanged.getValue())
+                                                moduleEditor.openPanel();
+                                            return true;
+                                        })))
+                        .child(new Grid().matrix(matrix).leftRel(0.5f).size(matrixWidth, matrixHeight)))
+                .child(new ButtonWidget<>()
+                        .posRel(Alignment.TopRight)
+                        .background(GuiTextures.HELP)
+                        .hoverBackground(GuiTextures.HELP, new BorderDrawable())
+                        .onMousePressed((mouseX, mouseY, button) -> {
+                            helpPanel.openPanel();
+                            return true;
+                        }));
+    }
+
+    private ModularPanel<?> createHelpPanel() {
+        return new ModularPanel<>("help_panel")
+                .excludeAreaInRecipeViewer()
+                .width(500)
+                .height(300)
+                .resizeableOnDrag(true)
+                .child(Flow.column()
+                        .margin(5)
+                        .child(new TextWidget<>(IKey.lang("gtceu.gui.central_monitor.help")))
+                        .child(Flow.row()
+                                .marginTop(10)
+                                .height(40)
+                                .widthRel(1)
+                                .child(IDrawable.of(new BorderDrawable(0xFFFF0000, 1),
+                                        GTGuiTextures.MONITOR).asWidget()
+                                        .heightRel(1)
+                                        .width(40)
+                                        .padding(11)
+                                        .background(new BorderDrawable(0xFF888888, 1))
+                                        .disableHoverBackground())
+                                .child(new TextWidget<>(IKey.lang("gtceu.gui.central_monitor.in_group"))
+                                        .widthRel(.5f)
+                                        .heightRel(1)
+                                        .padding(5)
+                                        .background(new BorderDrawable(0xFF888888, 1))
+                                        .disableHoverBackground())
+                                .child(new TextWidget<>(IKey.lang("gtceu.gui.central_monitor.left_click"))
+                                        .padding(5)
+                                        .widthRelOffset(.5f, -40)
+                                        .heightRel(1)
+                                        .background(new BorderDrawable(0xFF888888, 1))
+                                        .disableHoverBackground()))
+                        .child(Flow.row()
+                                .height(40)
+                                .widthRel(1)
+                                .child(new IDrawable.DrawableWidget(new BorderDrawable(0xFF0000FF, 1))
+                                        .heightRel(1)
+                                        .width(40)
+                                        .padding(11)
+                                        .background(new BorderDrawable(0xFF888888, 1))
+                                        .disableHoverBackground())
+                                .child(new TextWidget<>(IKey.lang("gtceu.gui.central_monitor.target"))
+                                        .widthRel(.5f)
+                                        .heightRel(1)
+                                        .padding(5)
+                                        .background(new BorderDrawable(0xFF888888, 1))
+                                        .disableHoverBackground())
+                                .child(new TextWidget<>(IKey.lang("gtceu.gui.central_monitor.right_click"))
+                                        .padding(5)
+                                        .widthRelOffset(.5f, -40)
+                                        .heightRel(1)
+                                        .background(new BorderDrawable(0xFF888888, 1))
+                                        .disableHoverBackground()))
+                        .child(Flow.row()
+                                .height(40)
+                                .widthRel(1)
+                                .child(IDrawable.of(new BorderDrawable(0xFFFF00FF, 1),
+                                        GTGuiTextures.MONITOR).asWidget()
+                                        .heightRel(1)
+                                        .width(40)
+                                        .padding(11)
+                                        .background(new BorderDrawable(0xFF888888, 1))
+                                        .disableHoverBackground())
+                                .child(new TextWidget<>(IKey.lang("gtceu.gui.central_monitor.in_group_and_target"))
+                                        .widthRelOffset(1, -40)
+                                        .heightRel(1)
+                                        .padding(5)
+                                        .background(new BorderDrawable(0xFF888888, 1))))
+                        .child(Flow.row()
+                                .height(40)
+                                .widthRel(1)
+                                .child(IDrawable.of(new BorderDrawable(0xFF0000FF, 1),
+                                        GTGuiTextures.DATA_HATCH, IKey.str("7").color(0xFFFFFFFF)).asWidget()
+                                        .heightRel(1)
+                                        .width(40)
+                                        .padding(11)
+                                        .background(new BorderDrawable(0xFF888888, 1))
+                                        .disableHoverBackground())
+                                .child(new TextWidget<>(IKey.lang("gtceu.gui.central_monitor.data_hatch_target"))
+                                        .widthRelOffset(1, -40)
+                                        .heightRel(1)
+                                        .padding(5)
+                                        .background(new BorderDrawable(0xFF888888, 1)))));
+    }
+
+    private IPanelHandler createModulePanelHandler(PanelSyncManager syncManager, ItemStack stack, MonitorGroup group,
+                                                   CentralMonitorMachine machine) {
+        IMonitorModuleItem moduleItem = null;
+        if (stack.getItem() instanceof IComponentItem componentItem) {
+            for (IItemComponent component : componentItem.getComponents()) {
+                if (component instanceof IMonitorModuleItem monitorModuleItem) {
+                    moduleItem = monitorModuleItem;
+                    break;
+                }
+            }
+        }
+        IMonitorModuleItem finalModuleItem = moduleItem;
+        return moduleItem == null ? null : finalModuleItem.createModularPanel(stack, machine, group, syncManager);
+    }
+
+    private String getNewGroupName(IValue<List<MonitorGroup>> groupSync) {
+        return Component.translatable("gtceu.gui.central_monitor.group_default_name", groupSync.getValue().size() + 1)
+                .getString();
+    }
+}
diff --git a/src/main/java/com/gregtechceu/gtceu/common/mui/package-info.java b/src/main/java/com/gregtechceu/gtceu/common/mui/package-info.java
new file mode 100644
index 00000000000..66d4182b975
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/common/mui/package-info.java
@@ -0,0 +1,4 @@
+@NotNullByDefault
+package com.gregtechceu.gtceu.common.mui;
+
+import org.jetbrains.annotations.NotNullByDefault;
diff --git a/src/main/java/com/gregtechceu/gtceu/common/mui/widgets/PopupPanel.java b/src/main/java/com/gregtechceu/gtceu/common/mui/widgets/PopupPanel.java
new file mode 100644
index 00000000000..ad96165910c
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/common/mui/widgets/PopupPanel.java
@@ -0,0 +1,62 @@
+package com.gregtechceu.gtceu.common.mui.widgets;
+
+import com.gregtechceu.gtceu.common.mui.GTGuiTextures;
+
+import brachy.modularui.api.IPanelHandler;
+import brachy.modularui.screen.ModularPanel;
+import brachy.modularui.widgets.ButtonWidget;
+import org.jetbrains.annotations.NotNull;
+
+public class PopupPanel extends ModularPanel<PopupPanel> {
+
+    private boolean deleteCachedPanel;
+
+    public static final int DEFAULT_WIDTH = 176, DEFAULT_HEIGHT = 166;
+
+    public static PopupPanel defaultPopupPanel(String name) {
+        return new PopupPanel(name).size(DEFAULT_WIDTH, DEFAULT_HEIGHT);
+    }
+
+    public static PopupPanel createPopupPanel(String name, int width, int height) {
+        return new PopupPanel(name).size(width, height);
+    }
+
+    private PopupPanel(@NotNull String name) {
+        super(name);
+        center();
+        background(GTGuiTextures.BACKGROUND);
+        child(ButtonWidget.panelCloseButton().top(5).right(5)
+                .onMousePressed((mouseX, mouseY, button) -> {
+                    if (button == 0 || button == 1) {
+                        this.closeIfOpen();
+                        return true;
+                    }
+                    return false;
+                }));
+    }
+
+    @Override
+    public void onClose() {
+        super.onClose();
+        if (deleteCachedPanel && isSynced() && getSyncHandler() instanceof IPanelHandler handler) {
+            handler.deleteCachedPanel();
+        }
+    }
+
+    public PopupPanel deleteCachedPanel(boolean deleteCachedPanel) {
+        this.deleteCachedPanel = deleteCachedPanel;
+        return this;
+    }
+
+    @Override
+    public PopupPanel size(int w, int h) {
+        super.size(w, h);
+        return this;
+    }
+
+    @Override
+    public PopupPanel size(int val) {
+        super.size(val);
+        return this;
+    }
+}
diff --git a/src/main/java/com/gregtechceu/gtceu/common/mui/widgets/SimpleDialog.java b/src/main/java/com/gregtechceu/gtceu/common/mui/widgets/SimpleDialog.java
new file mode 100644
index 00000000000..8b1201a60cd
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/common/mui/widgets/SimpleDialog.java
@@ -0,0 +1,37 @@
+package com.gregtechceu.gtceu.common.mui.widgets;
+
+import brachy.modularui.api.drawable.IKey;
+import brachy.modularui.drawable.GuiTextures;
+import brachy.modularui.utils.Alignment;
+import brachy.modularui.widget.Widget;
+import brachy.modularui.widgets.ButtonWidget;
+import brachy.modularui.widgets.Dialog;
+import brachy.modularui.widgets.TextWidget;
+
+import java.util.function.Consumer;
+import java.util.function.Function;
+
+public class SimpleDialog<T, W extends Widget<W>> extends Dialog<T, SimpleDialog<T, W>> {
+
+    public SimpleDialog(String name, Consumer<T> valueConsumer, W widget, Function<W, T> valueGetter, IKey title) {
+        super(name);
+        child(new TextWidget<>(title).leftRel(0.5f).marginTop(4));
+        child(widget.center());
+        child(new ButtonWidget<>()
+                .background(GuiTextures.CLOSE)
+                .hoverBackground(GuiTextures.CLOSE)
+                .posRel(Alignment.TopRight)
+                .onMousePressed((mouseX, mouseY, button) -> {
+                    closeIfOpen();
+                    return true;
+                }));
+        child(new ButtonWidget<>()
+                .background(GuiTextures.RIGHTLOAD)
+                .hoverBackground(GuiTextures.RIGHTLOAD)
+                .posRel(Alignment.TopCenter)
+                .onMousePressed((mouseX, mouseY, button) -> {
+                    closeWith(valueGetter.apply(widget));
+                    return true;
+                }));
+    }
+}
diff --git a/src/main/java/com/gregtechceu/gtceu/common/mui/widgets/textfield/CodeEditorWidget.java b/src/main/java/com/gregtechceu/gtceu/common/mui/widgets/textfield/CodeEditorWidget.java
new file mode 100644
index 00000000000..614807f3847
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/common/mui/widgets/textfield/CodeEditorWidget.java
@@ -0,0 +1,164 @@
+package com.gregtechceu.gtceu.common.mui.widgets.textfield;
+
+import com.gregtechceu.gtceu.common.mui.GTByteBufAdapters;
+import com.gregtechceu.gtceu.common.mui.GTGuiTextures;
+import com.gregtechceu.gtceu.utils.GTUtil;
+
+import net.minecraft.Util;
+import net.minecraft.network.chat.Component;
+import net.minecraft.network.chat.MutableComponent;
+import net.minecraft.network.chat.Style;
+
+import brachy.modularui.api.value.ISyncOrValue;
+import brachy.modularui.screen.viewport.ModularGuiContext;
+import brachy.modularui.value.sync.GenericListSyncHandler;
+import brachy.modularui.value.sync.StringSyncValue;
+import lombok.AccessLevel;
+import lombok.Getter;
+import lombok.Setter;
+import lombok.experimental.Accessors;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+import java.util.Optional;
+import java.util.function.Supplier;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+
+@Accessors(chain = true, fluent = true)
+public class CodeEditorWidget<T> extends TextEditorWidget<CodeEditorWidget<T>> {
+
+    @Setter
+    @Getter
+    @Nullable
+    protected LanguageDefinition<T> language;
+
+    @Setter
+    @Getter
+    @Nullable
+    protected T langContext;
+
+    @Setter(AccessLevel.PRIVATE)
+    private List<Component> formattedText;
+
+    private long lastEdited = -1;
+
+    public CodeEditorWidget() {}
+
+    public CodeEditorWidget(@Nullable LanguageDefinition<T> language) {
+        this.language = language;
+        GenericListSyncHandler<Component> formattedTextSync = new GenericListSyncHandler<>(
+                this::getTextAsComponents, this::formattedText, GTByteBufAdapters.COMPONENT::deserialize,
+                GTByteBufAdapters.COMPONENT::serialize, GTByteBufAdapters.COMPONENT::areEqual, Component::copy);
+        setSyncOrValue(formattedTextSync);
+    }
+
+    @Override
+    public boolean isValidSyncOrValue(@NotNull ISyncOrValue syncOrValue) {
+        return syncOrValue.isTypeOrEmpty(GenericListSyncHandler.class) ||
+                syncOrValue.isTypeOrEmpty(StringSyncValue.class);
+    }
+
+    public List<Component> getTextAsComponents() {
+        if (language() == null) return handler.getTextAsComponents();
+        if (getSyncHandler().getSyncManager().isClient()) {
+            if (formattedText != null && notEditedForSomeTime()) return formattedText;
+            else return language().formatCode(this.handler.getTextAsString(), langContext);
+        } else {
+            return language().formatCode(this.stringValue.getStringValue(), langContext);
+        }
+    }
+
+    @Override
+    public @NotNull Result onCharTyped(char codePoint, int modifiers) {
+        lastEdited = Util.getEpochMillis();
+        return super.onCharTyped(codePoint, modifiers);
+    }
+
+    @Override
+    public @NotNull Result onKeyPressed(int keyCode, int scanCode, int modifiers) {
+        lastEdited = Util.getEpochMillis();
+        return super.onKeyPressed(keyCode, scanCode, modifiers);
+    }
+
+    @Override
+    public void onRemoveFocus(ModularGuiContext context) {
+        super.onRemoveFocus(context);
+        lastEdited = 0;
+    }
+
+    @Override
+    public void onUpdate() {
+        super.onUpdate();
+        if (notEditedForSomeTime() && getSyncHandler().getSyncManager().isClient() && lastEdited != -1) {
+            this.stringValue.setStringValue(getText());
+            lastEdited = -1;
+        }
+    }
+
+    public boolean notEditedForSomeTime() {
+        return Util.getEpochMillis() - 3000 > lastEdited;
+    }
+
+    public record LanguageDefinition<T>(Pattern tokenPattern, Supplier<ITokenFormatter<T>> tokenFormatter) {
+
+        private static String makeSeparator(List<String> separators) {
+            if (separators.isEmpty()) return "\\X+";
+            else {
+                return separators.stream().reduce("", (s1, s2) -> s1 + '|' + s2).substring(1);
+            }
+        }
+
+        public LanguageDefinition(List<String> separators, Supplier<ITokenFormatter<T>> tokenFormatter) {
+            this(Pattern.compile(makeSeparator(separators)), tokenFormatter);
+        }
+
+        public List<String> splitIntoTokens(String s) {
+            Matcher matcher = tokenPattern.matcher(s);
+            List<String> tokens = new ArrayList<>();
+            List<String> betweenTokens = List.of(tokenPattern.split(s, -1));
+            int i = 0;
+            int skipped = 0;
+            while (matcher.find()) {
+                if (i != 0 || matcher.start() != 0) {
+                    tokens.add(betweenTokens.get(i - skipped));
+                } else skipped++;
+                tokens.add(matcher.group());
+                i++;
+            }
+            if (i != betweenTokens.size()) tokens.add(betweenTokens.get(i));
+            tokens.add("\0");
+            return tokens;
+        }
+
+        public List<Component> formatCode(String code, T context) {
+            List<MutableComponent> output = new ArrayList<>();
+            ITokenFormatter<T> formatter = tokenFormatter.get();
+            splitIntoTokens(code).stream()
+                    .map(token -> formatter.apply(token, context))
+                    .map(Component::copy)
+                    .reduce(Component.empty(), MutableComponent::append)
+                    .visit((style, s) -> {
+                        List<MutableComponent> lines = Arrays.stream(s.split("\\n", -1))
+                                .map(line -> Component.literal(line).withStyle(style))
+                                .toList();
+                        if (lines.isEmpty()) return Optional.empty();
+                        if (!output.isEmpty()) {
+                            GTUtil.getLast(output).append(lines.get(0));
+                            for (int i = 1; i < lines.size(); i++) output.add(lines.get(i));
+                        } else output.addAll(lines);
+                        return Optional.empty();
+                    }, Style.EMPTY);
+            return output.stream()
+                    .map(c -> (Component) c.withStyle(style -> style.withFont(GTGuiTextures.MONOCRAFT_FONT))).toList();
+        }
+    }
+
+    public interface ITokenFormatter<T> {
+
+        Component apply(String s, @Nullable T context);
+    }
+}
diff --git a/src/main/java/com/gregtechceu/gtceu/common/mui/widgets/textfield/TextEditorWidget.java b/src/main/java/com/gregtechceu/gtceu/common/mui/widgets/textfield/TextEditorWidget.java
new file mode 100644
index 00000000000..7695d67e6a9
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/common/mui/widgets/textfield/TextEditorWidget.java
@@ -0,0 +1,82 @@
+package com.gregtechceu.gtceu.common.mui.widgets.textfield;
+
+import brachy.modularui.api.value.IStringValue;
+import brachy.modularui.screen.viewport.ModularGuiContext;
+import brachy.modularui.utils.Alignment;
+import brachy.modularui.value.StringValue;
+import brachy.modularui.widgets.textfield.BaseTextFieldWidget;
+import org.jetbrains.annotations.NotNull;
+
+import java.util.Arrays;
+
+/**
+ * A syncable, multiline text input widget. Meant to edit large amounts of text.
+ */
+public class TextEditorWidget<W extends TextEditorWidget<W>> extends BaseTextFieldWidget<W> {
+
+    protected IStringValue<?> stringValue;
+
+    public TextEditorWidget() {
+        this.handler.setMaxLines(10000);
+        this.setTextAlignment(Alignment.TopLeft);
+    }
+
+    @Override
+    public void onInit() {
+        super.onInit();
+        if (this.stringValue == null) {
+            this.stringValue = new StringValue("");
+        }
+        setText(this.stringValue.getStringValue());
+    }
+
+    @Override
+    public void onRemoveFocus(ModularGuiContext context) {
+        super.onRemoveFocus(context);
+        this.stringValue.setStringValue(getText());
+    }
+
+    @Override
+    public void onUpdate() {
+        super.onUpdate();
+        if (!isFocused()) {
+            String s = this.stringValue.getStringValue();
+            if (!getText().equals(s)) {
+                setText(s);
+            }
+        }
+    }
+
+    @Override
+    public @NotNull Result onCharTyped(char codePoint, int modifiers) {
+        if (codePoint == '\t') {
+            if (this.handler.hasTextMarked()) {
+                int startY = this.handler.getStartCursor().y;
+                int endY = this.handler.getEndCursor().y;
+                for (int y = startY; y < endY; y++) {
+                    this.handler.getText().set(y, "    " + this.handler.getText().get(y));
+                }
+            } else {
+                int y = this.handler.getMainCursor().y;
+                this.handler.getText().set(y, "    " + this.handler.getText().get(y));
+            }
+        }
+        return super.onCharTyped(codePoint, modifiers);
+    }
+
+    @NotNull
+    public String getText() {
+        return this.handler.getText().stream().reduce((s1, s2) -> s1 + '\n' + s2).orElse("");
+    }
+
+    public void setText(@NotNull String text) {
+        this.handler.getText().clear();
+        this.handler.getText().addAll(Arrays.stream(text.split("\n")).toList());
+    }
+
+    public W value(IStringValue<?> stringValue) {
+        this.stringValue = stringValue;
+        super.setSyncOrValue(stringValue);
+        return getThis();
+    }
+}
diff --git a/src/main/java/com/gregtechceu/gtceu/common/network/GTNetwork.java b/src/main/java/com/gregtechceu/gtceu/common/network/GTNetwork.java
index e0b547c23e8..cd868784583 100644
--- a/src/main/java/com/gregtechceu/gtceu/common/network/GTNetwork.java
+++ b/src/main/java/com/gregtechceu/gtceu/common/network/GTNetwork.java
@@ -98,6 +98,10 @@ public static void init() {
         register(CPacketImageRequest.class, CPacketImageRequest::new, NetworkDirection.PLAY_TO_SERVER);
         register(SPacketImageResponse.class, SPacketImageResponse::new, NetworkDirection.PLAY_TO_CLIENT);
 
+        register(SCPacketMonitorGroupNBTChange.class, SCPacketMonitorGroupNBTChange::new, null);
+        register(CPacketImageRequest.class, CPacketImageRequest::new, NetworkDirection.PLAY_TO_SERVER);
+        register(SPacketImageResponse.class, SPacketImageResponse::new, NetworkDirection.PLAY_TO_CLIENT);
+
         register(CPacketKeyDown.class, CPacketKeyDown::new, NetworkDirection.PLAY_TO_SERVER);
 
         register(SPacketSyncOreVeins.class, SPacketSyncOreVeins::new, NetworkDirection.PLAY_TO_CLIENT);
diff --git a/src/main/java/com/gregtechceu/gtceu/common/recipe/type/EquipmentFoundryRecipe.java b/src/main/java/com/gregtechceu/gtceu/common/recipe/type/EquipmentFoundryRecipe.java
new file mode 100644
index 00000000000..a21e4bb8844
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/common/recipe/type/EquipmentFoundryRecipe.java
@@ -0,0 +1,164 @@
+package com.gregtechceu.gtceu.common.recipe.type;
+
+import com.gregtechceu.gtceu.api.GTValues;
+import com.gregtechceu.gtceu.api.capability.GTCapabilityHelper;
+import com.gregtechceu.gtceu.api.item.module.AppliedItemModule;
+import com.gregtechceu.gtceu.api.item.module.IModularItem;
+import com.gregtechceu.gtceu.api.item.module.ITieredItemModule;
+import com.gregtechceu.gtceu.api.item.module.ItemModule;
+import com.gregtechceu.gtceu.common.data.GTItems;
+import com.gregtechceu.gtceu.common.data.GTRecipeTypes;
+import com.gregtechceu.gtceu.utils.GTUtil;
+
+import net.minecraft.MethodsReturnNonnullByDefault;
+import net.minecraft.core.RegistryAccess;
+import net.minecraft.network.FriendlyByteBuf;
+import net.minecraft.resources.ResourceLocation;
+import net.minecraft.util.GsonHelper;
+import net.minecraft.util.Mth;
+import net.minecraft.world.item.ItemStack;
+import net.minecraft.world.item.crafting.*;
+import net.minecraft.world.level.Level;
+import net.minecraftforge.items.wrapper.RecipeWrapper;
+
+import com.google.gson.JsonArray;
+import com.google.gson.JsonObject;
+import lombok.Getter;
+import lombok.RequiredArgsConstructor;
+
+import javax.annotation.ParametersAreNonnullByDefault;
+
+@RequiredArgsConstructor
+@ParametersAreNonnullByDefault
+@MethodsReturnNonnullByDefault
+public class EquipmentFoundryRecipe implements Recipe<RecipeWrapper> {
+
+    @Getter
+    private final ResourceLocation id;
+    @Getter
+    private final Ingredient equipment;
+    @Getter
+    private final Ingredient ingredient;
+    @Getter
+    private final ItemModule[] modules;
+
+    public ItemModule getModule(int tier) {
+        int lowestTier = (modules[0] instanceof ITieredItemModule tieredModule) ? tieredModule.getTier() :
+                GTValues.ULV;
+        return modules[Mth.clamp(tier - lowestTier, 0, modules.length - 1)];
+    }
+
+    public ItemModule getModule(ItemStack ingredient) {
+        int tier = GTUtil.getTier(ingredient.getItem());
+        return getModule(tier);
+    }
+
+    @Override
+    public boolean matches(RecipeWrapper container, Level level) {
+        return matches(container, -1);
+    }
+
+    public boolean matches(RecipeWrapper container, int slot) {
+        ItemStack foundItem = null, foundIngredient = null;
+        for (int i = 0; i < container.getContainerSize(); ++i) {
+            ItemStack stack = container.getItem(i);
+            if (!stack.isEmpty()) {
+                if (equipment.test(stack) && foundItem == null) {
+                    foundItem = stack;
+                } else if (ingredient.test(stack)) {
+                    foundIngredient = stack;
+                }
+            }
+        }
+        if (foundIngredient == null || foundItem == null) return false;
+        ItemModule module = getModule(foundIngredient);
+        IModularItem modularItem = GTCapabilityHelper.getModularItem(foundItem);
+        return modularItem != null &&
+                (slot == -1 ? modularItem.attach(module, true) : modularItem.attach(module, slot, true)) != null;
+    }
+
+    @Override
+    public ItemStack assemble(RecipeWrapper container, RegistryAccess registryAccess) {
+        return assemble(container, -1);
+    }
+
+    public ItemStack assemble(RecipeWrapper container, int slot) {
+        ItemStack result = ItemStack.EMPTY;
+        ItemStack foundIngredient = null;
+
+        for (int i = 0; i < container.getContainerSize(); ++i) {
+            ItemStack stack = container.getItem(i);
+            if (equipment.test(stack) && result.isEmpty()) {
+                result = stack.copy();
+            } else if (ingredient.test(stack)) {
+                foundIngredient = stack;
+                break;
+            }
+        }
+
+        if (foundIngredient == null || result.isEmpty()) {
+            return ItemStack.EMPTY;
+        }
+        ItemModule module = getModule(foundIngredient);
+        IModularItem modularItem = GTCapabilityHelper.getModularItem(result);
+        if (modularItem == null) return ItemStack.EMPTY;
+        if (!module.canApplyTo(result)) return ItemStack.EMPTY;
+        AppliedItemModule attachedModule = slot == -1 ? modularItem.attach(module, false) :
+                modularItem.attach(module, slot, false);
+        if (attachedModule != null) {
+            attachedModule.setModuleItem(foundIngredient);
+            return result;
+        }
+        return ItemStack.EMPTY;
+    }
+
+    @Override
+    public boolean canCraftInDimensions(int width, int height) {
+        return true;
+    }
+
+    @Override
+    public ItemStack getResultItem(RegistryAccess registryAccess) {
+        return GTItems.QUANTUM_CHESTPLATE_ADVANCED.asStack();
+    }
+
+    @Override
+    public RecipeSerializer<?> getSerializer() {
+        return GTRecipeTypes.EQUIPMENT_FOUNDRY_SERIALIZER.get();
+    }
+
+    @Override
+    public RecipeType<?> getType() {
+        return GTRecipeTypes.EQUIPMENT_FOUNDRY_RECIPES.get();
+    }
+
+    public static class Serializer implements RecipeSerializer<EquipmentFoundryRecipe> {
+
+        public EquipmentFoundryRecipe fromJson(ResourceLocation recipeId, JsonObject json) {
+            Ingredient equipment = Ingredient.fromJson(GsonHelper.getAsJsonObject(json, "equipment"), false);
+            Ingredient ingredient = Ingredient.fromJson(GsonHelper.getAsJsonObject(json, "ingredient"), false);
+            JsonArray arr = json.getAsJsonArray("modifier");
+            ItemModule[] modifier = new ItemModule[arr.size()];
+            for (int i = 0; i < arr.size(); i++)
+                modifier[i] = ItemModule.getModuleById(new ResourceLocation(arr.get(i).getAsString()));
+
+            return new EquipmentFoundryRecipe(recipeId, equipment, ingredient, modifier);
+        }
+
+        public EquipmentFoundryRecipe fromNetwork(ResourceLocation recipeId, FriendlyByteBuf buffer) {
+            Ingredient equipment = Ingredient.fromNetwork(buffer);
+            Ingredient ingredient = Ingredient.fromNetwork(buffer);
+            int length = buffer.readInt();
+            ItemModule[] modifier = new ItemModule[length];
+            for (int i = 0; i < length; i++) modifier[i] = ItemModule.getModuleById(buffer.readResourceLocation());
+            return new EquipmentFoundryRecipe(recipeId, equipment, ingredient, modifier);
+        }
+
+        public void toNetwork(FriendlyByteBuf buffer, EquipmentFoundryRecipe recipe) {
+            recipe.equipment.toNetwork(buffer);
+            recipe.ingredient.toNetwork(buffer);
+            buffer.writeInt(recipe.modules.length);
+            for (ItemModule module : recipe.modules) buffer.writeResourceLocation(module.getId());
+        }
+    }
+}
diff --git a/src/main/java/com/gregtechceu/gtceu/config/ConfigHolder.java b/src/main/java/com/gregtechceu/gtceu/config/ConfigHolder.java
index 3248f0c11be..a45bffa4673 100644
--- a/src/main/java/com/gregtechceu/gtceu/config/ConfigHolder.java
+++ b/src/main/java/com/gregtechceu/gtceu/config/ConfigHolder.java
@@ -5,6 +5,7 @@
 
 import net.minecraft.commands.Commands;
 
+import brachy.modularui.screen.RichTooltip;
 import dev.toma.configuration.Configuration;
 import dev.toma.configuration.config.Config;
 import dev.toma.configuration.config.Configurable;
@@ -769,13 +770,6 @@ public static class ClientConfigs {
         @Configurable.Gui.ColorValue
         public String defaultPaintingColor = "#FFFFFF";
         @Configurable
-        @Configurable.Comment({ "The default color to overlay onto Machine (and other) UIs.",
-                "#FFFFFF is no coloring (like GTCE) (default).",
-                "#D2DCFF is the classic blue from GT5." })
-        @Configurable.StringPattern(value = "#[0-9a-fA-F]{1,6}")
-        @Configurable.Gui.ColorValue
-        public String defaultUIColor = "#FFFFFF";
-        @Configurable
         @Configurable.Comment({ "Use VBO cache for multiblock preview.",
                 "Disable if you have issues with rendering multiblocks.", "Default: true" })
         public boolean useVBO = true;
@@ -784,15 +778,13 @@ public static class ClientConfigs {
         @Configurable.Range(min = 1, max = 999)
         public int inWorldPreviewDuration = 10;
         @Configurable
-        @Configurable.Comment({ "Duration of UI animations in ms", "Default: 300" })
-        @Configurable.Range(min = 1)
-        public int animationTime = 300;
-        @Configurable
         public ArmorHud armorHud = new ArmorHud();
         @Configurable
         public RendererConfigs renderer = new RendererConfigs();
         @Configurable
         public TankItemFluidPreview tankItemFluidPreview = new TankItemFluidPreview();
+        @Configurable
+        public UIConfigs ui = new UIConfigs();
 
         public int getDefaultPaintingColor() {
             // OR with full alpha to differentiate from a machine that's painted white (map color 0xffffff)
@@ -816,15 +808,89 @@ public static class ArmorHud {
             public int hudOffsetY = 0;
         }
 
+        public static class RendererConfigs {
+
+            @Configurable
+            @Configurable.Comment({ "Render fluids in multiblocks that support them?", "Default: true" })
+            public boolean renderFluids = true;
+
+            @Configurable
+            @Configurable.Comment({ "Render growing plants in multiblocks that support them?", "Default: true" })
+            public boolean renderGrowingPlants = true;
+
+            @Configurable
+            @Configurable.Comment({ "Whether or not to color material/ore block highlights in the material color",
+                    "Default: true" })
+            public boolean coloredMaterialBlockOutline = true;
+
+            @Configurable
+            @Configurable.Comment({ "Whether or not to color tiered machine highlights in the tier color",
+                    "Default: true" })
+            public boolean coloredTieredMachineOutline = true;
+
+            @Configurable
+            @Configurable.Comment({
+                    "Whether or not to color wire/cable highlights based on voltage tier or material color",
+                    "Default: true" })
+            public boolean coloredWireOutline = true;
+        }
+
         public static class TankItemFluidPreview {
 
             @Configurable
-            @Configurable.Comment({ "Set true to render the including fluid icons to GT Drums" })
+            @Configurable.Comment({ "Set true to render the including fluid icons to GT Drums",
+                    "Default: false" })
             public boolean drum = false;
             @Configurable
-            @Configurable.Comment({ "Set true to render the including fluid icons to Super (Quantum) Tanks" })
+            @Configurable.Comment({ "Set true to render the including fluid icons to Super and Quantum Tanks",
+                    "Default: false" })
             public boolean quantumTank = false;
         }
+
+        public static class UIConfigs {
+
+            @Configurable
+            @Configurable.Comment({
+                    "If progress bar should step in texture pixels or screen pixels. (Screen pixels are way smaller and therefore smoother)",
+                    "Default: true" })
+            public boolean smoothProgressBar = true;
+            @Configurable
+            @Configurable.Comment({ "Duration of UI animations in ms.",
+                    "Default: 100" })
+            @Configurable.Range(min = 1, max = 500)
+            public int animationTime = 100;
+            @Configurable
+            @Configurable.Comment({ "Default tooltip position around the widget or its panel.",
+                    "Default: VERTICAL" })
+            public RichTooltip.Pos tooltipPos = RichTooltip.Pos.NEXT_TO_MOUSE;
+
+            @Configurable
+            @Configurable.Comment({ "The default color to overlay onto Machine (and other) UIs.",
+                    "#FFFFFF is no coloring (like GTCE) (default).",
+                    "#D2DCFF is the classic blue from GT5." })
+            @Configurable.StringPattern(value = "#[0-9a-fA-F]{1,6}")
+            @Configurable.Gui.ColorValue
+            public String defaultUIColor = "#FFFFFF";
+            @Configurable
+            @Configurable.Comment({
+                    "If true, pressing the ESC key in a text field will restore the last text instead of confirming current one.",
+                    "Default: fakse" })
+            public boolean escRestoresLastText = false;
+            @Configurable
+            @Configurable.Comment({
+                    "If true and not specified otherwise, screens will try to use the 'vanilla_dark' theme.",
+                    "Default: false" })
+            public boolean useDarkThemeByDefault = false;
+
+            @Configurable
+            @Configurable.Comment({ "If true, vanilla tooltips will be replaced with MUI's RichTooltip",
+                    "Default: false" })
+            public boolean replaceVanillaTooltips = false;
+
+            public int getDefaultUIColor() {
+                return Long.decode(ConfigHolder.INSTANCE.client.ui.defaultUIColor).intValue() | 0xFF000000;
+            }
+        }
     }
 
     public static class DeveloperConfigs {
@@ -834,6 +900,9 @@ public static class DeveloperConfigs {
                 "Default: false" })
         public boolean debug = false;
         @Configurable
+        @Configurable.Comment({ "Debug UI? (Will draw widget outlines and widget information)", "Default: false" })
+        public boolean debugUI = GTCEu.isDev();
+        @Configurable
         @Configurable.Comment({ "Debug ore vein placement? (will print placed veins to server's debug.log)",
                 "Default: false (no placement printout in debug.log)" })
         public boolean debugWorldgen = false;
@@ -850,31 +919,59 @@ public static class DeveloperConfigs {
         @Configurable.Comment({ "Executes ./gradlew :processResources when F3+T is pressed",
                 "Only works in a development environment", "Default: false" })
         public boolean autoRebuildResources = false;
-    }
-
-    public static class RendererConfigs {
 
         @Configurable
-        @Configurable.Comment({ "Render fluids in multiblocks that support them?", "Default: true" })
-        public boolean renderFluids = true;
+        public DeveloperConfigs.MuiConfigs mui = new DeveloperConfigs.MuiConfigs();
 
-        @Configurable
-        @Configurable.Comment({ "Render growing plants in multiblocks that support them?", "Default: true" })
-        public boolean renderGrowingPlants = true;
+        public static class MuiConfigs {
 
-        @Configurable
-        @Configurable.Comment({ "Whether or not to color material/ore block highlights in the material color",
-                "Default: true" })
-        public boolean coloredMaterialBlockOutline = true;
+            @Configurable
+            @Configurable.Comment({ "Color for outlining widgets in debug mode, in ARGB" })
+            @Configurable.StringPattern(value = "#[0-9a-fA-F]{1,8}")
+            @Configurable.Gui.ColorValue
+            public String textColor = "#dcb42873";
 
-        @Configurable
-        @Configurable.Comment({ "Whether or not to color tiered machine highlights in the tier color",
-                "Default: true" })
-        public boolean coloredTieredMachineOutline = true;
+            @Configurable
+            @Configurable.Comment({ "Color for outlining widgets in debug mode, in ARGB" })
+            @Configurable.StringPattern(value = "#[0-9a-fA-F]{1,8}")
+            @Configurable.Gui.ColorValue
+            public String outlineColor = "#dcb42873";
 
-        @Configurable
-        @Configurable.Comment({ "Whether or not to color wire/cable highlights based on voltage tier or material color",
-                "Default: true" })
-        public boolean coloredWireOutline = true;
+            @Configurable
+            @Configurable.Comment({ "Color for cursor in debug mode, in ARGB" })
+            @Configurable.StringPattern(value = "#[0-9a-fA-F]{1,8}")
+            @Configurable.Gui.ColorValue
+            public String cursorColor = "#ff4cAf50";
+
+            @Configurable
+            @Configurable.Comment({ "Scale of debug text",
+                    "Default: 0.8f" })
+            @Configurable.DecimalRange(min = 0.1f, max = 10.0f)
+            public float scale = 0.8f;
+
+            @Configurable
+            public boolean showHovered = true;
+            @Configurable
+            public boolean showPos = true;
+            @Configurable
+            public boolean showSize = true;
+            @Configurable
+            public boolean showWidgetTheme = true;
+            @Configurable
+            public boolean showExtra = true;
+            @Configurable
+            public boolean showOutline = true;
+
+            @Configurable
+            public boolean showParent = true;
+            @Configurable
+            public boolean showParentPos = true;
+            @Configurable
+            public boolean showParentSize = true;
+            @Configurable
+            public boolean showParentWidgetTheme = true;
+            @Configurable
+            public boolean showParentOutline = true;
+        }
     }
 }
diff --git a/src/main/java/com/gregtechceu/gtceu/core/IGameRenderer.java b/src/main/java/com/gregtechceu/gtceu/core/IGameRenderer.java
new file mode 100644
index 00000000000..6cf45416395
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/core/IGameRenderer.java
@@ -0,0 +1,6 @@
+package com.gregtechceu.gtceu.core;
+
+public interface IGameRenderer {
+
+    double gtceu$getFov(float partialTicks);
+}
diff --git a/src/main/java/com/gregtechceu/gtceu/core/mixins/LivingEntityMixin.java b/src/main/java/com/gregtechceu/gtceu/core/mixins/LivingEntityMixin.java
new file mode 100644
index 00000000000..56715d92f3a
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/core/mixins/LivingEntityMixin.java
@@ -0,0 +1,71 @@
+package com.gregtechceu.gtceu.core.mixins;
+
+import com.gregtechceu.gtceu.api.capability.GTCapabilityHelper;
+import com.gregtechceu.gtceu.api.item.armor.ArmorComponentItem;
+import com.gregtechceu.gtceu.api.item.module.AppliedItemModule;
+import com.gregtechceu.gtceu.api.item.module.IJumpBoostItemModule;
+import com.gregtechceu.gtceu.api.item.module.IModularItem;
+
+import net.minecraft.world.damagesource.DamageSource;
+import net.minecraft.world.effect.MobEffects;
+import net.minecraft.world.entity.EquipmentSlot;
+import net.minecraft.world.entity.LivingEntity;
+import net.minecraft.world.item.ItemStack;
+
+import org.spongepowered.asm.mixin.Mixin;
+import org.spongepowered.asm.mixin.Shadow;
+import org.spongepowered.asm.mixin.Unique;
+import org.spongepowered.asm.mixin.injection.At;
+import org.spongepowered.asm.mixin.injection.Inject;
+import org.spongepowered.asm.mixin.injection.callback.CallbackInfoReturnable;
+
+@Mixin(LivingEntity.class)
+public abstract class LivingEntityMixin {
+
+    @Shadow
+    public abstract Iterable<ItemStack> getArmorSlots();
+
+    @Shadow
+    public abstract void setItemSlot(EquipmentSlot slot, ItemStack stack);
+
+    @Inject(method = "getDamageAfterArmorAbsorb",
+            at = @At(value = "INVOKE",
+                     target = "Lnet/minecraft/world/entity/LivingEntity;hurtArmor(Lnet/minecraft/world/damagesource/DamageSource;F)V"))
+    private void gtceu$adjustArmorAbsorption(DamageSource damageSource, float damageAmount,
+                                             CallbackInfoReturnable<Float> cir) {
+        float armorDamage = Math.max(1.0F, damageAmount / 4.0F);
+        int i = 0;
+        for (ItemStack itemStack : this.getArmorSlots()) {
+            if (itemStack.getItem() instanceof ArmorComponentItem armorItem) {
+                EquipmentSlot slot = EquipmentSlot.byTypeAndIndex(EquipmentSlot.Type.ARMOR, i);
+                armorItem.damageItem(itemStack, (int) armorDamage, (LivingEntity) (Object) this, entity -> {});
+                if (itemStack.getCount() == 0) {
+                    this.setItemSlot(slot, ItemStack.EMPTY);
+                }
+            }
+            ++i;
+        }
+    }
+
+    @Unique
+    private LivingEntity gtceu$self() {
+        return (LivingEntity) (Object) this;
+    }
+
+    @Inject(method = "getJumpBoostPower", at = @At("HEAD"), cancellable = true)
+    private void gtceu$adjustJumpBoost(CallbackInfoReturnable<Float> cir) {
+        float add = 0;
+        for (ItemStack stack : this.getArmorSlots()) {
+            IModularItem modularItem = GTCapabilityHelper.getModularItem(stack);
+            if (modularItem == null) continue;
+            for (AppliedItemModule module : modularItem.getAppliedModules()) {
+                if (module.getModule() instanceof IJumpBoostItemModule jumpBoostModule) {
+                    add += jumpBoostModule.getJumpBoost(module);
+                }
+            }
+        }
+        cir.setReturnValue(add + (gtceu$self().hasEffect(MobEffects.JUMP) ?
+                0.1F * ((float) gtceu$self().getEffect(MobEffects.JUMP).getAmplifier() + 1.0F) : 0.0F));
+        cir.cancel();
+    }
+}
diff --git a/src/main/java/com/gregtechceu/gtceu/core/mixins/RangedAttributeAccessor.java b/src/main/java/com/gregtechceu/gtceu/core/mixins/RangedAttributeAccessor.java
new file mode 100644
index 00000000000..f4df091ee85
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/core/mixins/RangedAttributeAccessor.java
@@ -0,0 +1,15 @@
+package com.gregtechceu.gtceu.core.mixins;
+
+import net.minecraft.world.entity.ai.attributes.RangedAttribute;
+
+import org.spongepowered.asm.mixin.Mixin;
+import org.spongepowered.asm.mixin.Mutable;
+import org.spongepowered.asm.mixin.gen.Accessor;
+
+@Mixin(RangedAttribute.class)
+public interface RangedAttributeAccessor {
+
+    @Accessor("maxValue")
+    @Mutable
+    void gtceu$setMaxValue(double maxValue);
+}
diff --git a/src/main/java/com/gregtechceu/gtceu/core/mixins/TransientCraftingContainerAccessor.java b/src/main/java/com/gregtechceu/gtceu/core/mixins/TransientCraftingContainerAccessor.java
new file mode 100644
index 00000000000..6d45815c969
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/core/mixins/TransientCraftingContainerAccessor.java
@@ -0,0 +1,19 @@
+package com.gregtechceu.gtceu.core.mixins;
+
+import net.minecraft.core.NonNullList;
+import net.minecraft.world.inventory.AbstractContainerMenu;
+import net.minecraft.world.inventory.TransientCraftingContainer;
+import net.minecraft.world.item.ItemStack;
+
+import org.spongepowered.asm.mixin.Mixin;
+import org.spongepowered.asm.mixin.gen.Accessor;
+
+@Mixin(TransientCraftingContainer.class)
+public interface TransientCraftingContainerAccessor {
+
+    @Accessor("items")
+    NonNullList<ItemStack> gtceu$getActualItems();
+
+    @Accessor
+    AbstractContainerMenu getMenu();
+}
diff --git a/src/main/java/com/gregtechceu/gtceu/core/mixins/client/AbstractWidgetMixin.java b/src/main/java/com/gregtechceu/gtceu/core/mixins/client/AbstractWidgetMixin.java
new file mode 100644
index 00000000000..abb3918d7d1
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/core/mixins/client/AbstractWidgetMixin.java
@@ -0,0 +1,32 @@
+package com.gregtechceu.gtceu.core.mixins.client;
+
+import net.minecraft.client.gui.GuiGraphics;
+import net.minecraft.client.gui.components.AbstractWidget;
+
+import brachy.modularui.overlay.OverlayStack;
+import org.objectweb.asm.Opcodes;
+import org.spongepowered.asm.mixin.Mixin;
+import org.spongepowered.asm.mixin.Shadow;
+import org.spongepowered.asm.mixin.injection.At;
+import org.spongepowered.asm.mixin.injection.Inject;
+import org.spongepowered.asm.mixin.injection.callback.CallbackInfo;
+
+/**
+ * This mixin fixes some visual bugs that can happen with overlays.
+ */
+@Mixin(AbstractWidget.class)
+public abstract class AbstractWidgetMixin {
+
+    @Shadow
+    protected boolean isHovered;
+
+    @Inject(method = "render",
+            at = @At(value = "FIELD",
+                     opcode = Opcodes.PUTFIELD,
+                     target = "Lnet/minecraft/client/gui/components/AbstractWidget;isHovered:Z"))
+    public void gtceu$fixHoveredState(GuiGraphics guiGraphics, int mouseX, int mouseY,
+                                      float partialTick, CallbackInfo ci) {
+        // fixes buttons being hovered when an overlay element is already hovered
+        this.isHovered &= !OverlayStack.isHoveringOverlay();
+    }
+}
diff --git a/src/main/java/com/gregtechceu/gtceu/core/mixins/client/GameRendererMixin.java b/src/main/java/com/gregtechceu/gtceu/core/mixins/client/GameRendererMixin.java
new file mode 100644
index 00000000000..9073c7bc439
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/core/mixins/client/GameRendererMixin.java
@@ -0,0 +1,38 @@
+package com.gregtechceu.gtceu.core.mixins.client;
+
+import com.gregtechceu.gtceu.core.IGameRenderer;
+
+import net.minecraft.client.Camera;
+import net.minecraft.client.Minecraft;
+import net.minecraft.client.renderer.GameRenderer;
+
+import com.mojang.blaze3d.vertex.PoseStack;
+import org.spongepowered.asm.mixin.Final;
+import org.spongepowered.asm.mixin.Mixin;
+import org.spongepowered.asm.mixin.Shadow;
+
+@Mixin(GameRenderer.class)
+public abstract class GameRendererMixin implements IGameRenderer {
+
+    @Shadow
+    @Final
+    Minecraft minecraft;
+
+    @Shadow
+    protected abstract double getFov(Camera activeRenderInfo, float partialTicks, boolean useFOVSetting);
+
+    @Shadow
+    @Final
+    private Camera mainCamera;
+
+    @Shadow
+    protected abstract void bobHurt(PoseStack poseStack, float partialTicks);
+
+    @Shadow
+    protected abstract void bobView(PoseStack poseStack, float partialTicks);
+
+    @Override
+    public double gtceu$getFov(float partialTicks) {
+        return getFov(mainCamera, partialTicks, true);
+    }
+}
diff --git a/src/main/java/com/gregtechceu/gtceu/core/mixins/client/GuiGraphicsAccessor.java b/src/main/java/com/gregtechceu/gtceu/core/mixins/client/GuiGraphicsAccessor.java
index 23dc158d2f9..8fd3b372608 100644
--- a/src/main/java/com/gregtechceu/gtceu/core/mixins/client/GuiGraphicsAccessor.java
+++ b/src/main/java/com/gregtechceu/gtceu/core/mixins/client/GuiGraphicsAccessor.java
@@ -2,7 +2,10 @@
 
 import net.minecraft.client.gui.GuiGraphics;
 
+import com.mojang.blaze3d.vertex.PoseStack;
 import org.spongepowered.asm.mixin.Mixin;
+import org.spongepowered.asm.mixin.Mutable;
+import org.spongepowered.asm.mixin.gen.Accessor;
 import org.spongepowered.asm.mixin.gen.Invoker;
 
 @Mixin(GuiGraphics.class)
@@ -10,4 +13,8 @@ public interface GuiGraphicsAccessor {
 
     @Invoker
     void callFlushIfUnmanaged();
+
+    @Mutable
+    @Accessor
+    void setPose(PoseStack pose);
 }
diff --git a/src/main/java/com/gregtechceu/gtceu/core/mixins/client/GuiGraphicsMixin.java b/src/main/java/com/gregtechceu/gtceu/core/mixins/client/GuiGraphicsMixin.java
index 45a34910a9e..ac9d4c29c34 100644
--- a/src/main/java/com/gregtechceu/gtceu/core/mixins/client/GuiGraphicsMixin.java
+++ b/src/main/java/com/gregtechceu/gtceu/core/mixins/client/GuiGraphicsMixin.java
@@ -1,19 +1,41 @@
 package com.gregtechceu.gtceu.core.mixins.client;
 
 import com.gregtechceu.gtceu.client.util.RenderUtil;
+import com.gregtechceu.gtceu.config.ConfigHolder;
 
+import net.minecraft.client.gui.Font;
 import net.minecraft.client.gui.GuiGraphics;
+import net.minecraft.network.chat.Component;
+import net.minecraft.network.chat.FormattedText;
+import net.minecraft.util.FormattedCharSequence;
 import net.minecraft.world.entity.LivingEntity;
+import net.minecraft.world.inventory.tooltip.TooltipComponent;
 import net.minecraft.world.item.ItemStack;
 import net.minecraft.world.level.Level;
 
+import brachy.modularui.drawable.text.FontRenderHelper;
+import brachy.modularui.screen.RichTooltip;
+import brachy.modularui.screen.viewport.GuiContext;
 import com.llamalad7.mixinextras.injector.wrapmethod.WrapMethod;
 import com.llamalad7.mixinextras.injector.wrapoperation.Operation;
+import com.llamalad7.mixinextras.sugar.Local;
 import org.jetbrains.annotations.Nullable;
 import org.spongepowered.asm.mixin.Mixin;
+import org.spongepowered.asm.mixin.Shadow;
+import org.spongepowered.asm.mixin.Unique;
+import org.spongepowered.asm.mixin.injection.At;
+import org.spongepowered.asm.mixin.injection.Inject;
+import org.spongepowered.asm.mixin.injection.callback.CallbackInfo;
+
+import java.util.List;
+import java.util.Optional;
+import java.util.stream.Collectors;
 
 @Mixin(GuiGraphics.class)
-public class GuiGraphicsMixin {
+public abstract class GuiGraphicsMixin {
+
+    @Shadow(remap = false)
+    private ItemStack tooltipStack;
 
     @WrapMethod(method = "renderItem(Lnet/minecraft/world/entity/LivingEntity;Lnet/minecraft/world/level/Level;Lnet/minecraft/world/item/ItemStack;IIII)V")
     private void gtceu$renderResearchItemContent(@Nullable LivingEntity entity, @Nullable Level level,
@@ -24,4 +46,85 @@ public class GuiGraphicsMixin {
             original.call(entity, level, stack, x, y, seed, z);
         }
     }
+
+    @Inject(method = "renderTooltip(Lnet/minecraft/client/gui/Font;Ljava/util/List;Ljava/util/Optional;II)V",
+            at = @At(value = "HEAD"),
+            cancellable = true)
+    private void gtceu$replaceWithRichTooltip(Font font, List<Component> tooltipLines,
+                                              Optional<TooltipComponent> visualComponent, int mouseX, int mouseY,
+                                              CallbackInfo ci) {
+        // funny cast to get from List<Component> to List<FormattedText>
+        // I just don't want to copy the list unnecessarily
+        // this is safe because Component extends FormattedText
+        // noinspection unchecked
+        gtceu$drawRichTooltip(font, (List<FormattedText>) (List<?>) tooltipLines, visualComponent, mouseX, mouseY, ci);
+    }
+
+    @Inject(
+            method = {
+                    "renderTooltip(Lnet/minecraft/client/gui/Font;Ljava/util/List;Lnet/minecraft/client/gui/screens/inventory/tooltip/ClientTooltipPositioner;II)V",
+                    "renderTooltip(Lnet/minecraft/client/gui/Font;Ljava/util/List;II)V"
+            },
+            at = @At(value = "HEAD"),
+            cancellable = true)
+    private void gtceu$replaceWithRichTooltip(CallbackInfo ci,
+                                              @Local(argsOnly = true) Font font,
+                                              @Local(argsOnly = true) List<FormattedCharSequence> tooltipLines,
+                                              @Local(ordinal = 0, argsOnly = true) int mouseX,
+                                              @Local(ordinal = 1, argsOnly = true) int mouseY) {
+        List<FormattedText> text = tooltipLines.stream()
+                .map(FontRenderHelper::getComponentFromCharSequence)
+                .collect(Collectors.toList());
+        gtceu$drawRichTooltip(font, text, Optional.empty(), mouseX, mouseY, ci);
+    }
+
+    @Inject(method = "renderComponentTooltip*",
+            at = @At(
+                     value = "INVOKE",
+                     target = "Lnet/minecraftforge/client/ForgeHooksClient;gatherTooltipComponents(Lnet/minecraft/world/item/ItemStack;Ljava/util/List;IIILnet/minecraft/client/gui/Font;)Ljava/util/List;",
+                     remap = false),
+            cancellable = true)
+    private void gtceu$replaceWithRichTooltip2(CallbackInfo ci,
+                                               @Local(argsOnly = true) Font font,
+                                               @Local(argsOnly = true) List<FormattedText> tooltipLines,
+                                               @Local(ordinal = 0, argsOnly = true) int mouseX,
+                                               @Local(ordinal = 1, argsOnly = true) int mouseY) {
+        gtceu$drawRichTooltip(font, tooltipLines, Optional.empty(), mouseX, mouseY, ci);
+    }
+
+    @Unique
+    private void gtceu$drawRichTooltip(Font font, List<FormattedText> textLines,
+                                       Optional<TooltipComponent> tooltipComponent, int mouseX, int mouseY,
+                                       CallbackInfo ci) {
+        if (!ConfigHolder.INSTANCE.client.ui.replaceVanillaTooltips || textLines.isEmpty()) {
+            return;
+        }
+
+        RichTooltip tooltip = new RichTooltip();
+        tooltip.parent(area -> RichTooltip.findIngredientArea(area, mouseX, mouseY));
+        // Other positions don't really work due to the lack of GuiContext in non-modular uis
+        tooltip.add(textLines.get(0)).newLine();
+        // vanilla inserts the bundle tooltip here so we need to do it as the 2nd item too
+        tooltipComponent.ifPresent(tooltip::addLine);
+
+        if (!this.tooltipStack.isEmpty()) {
+            tooltip.spaceLine();
+        }
+        for (int i = 1, n = textLines.size(); i < n; i++) {
+            tooltip.add(textLines.get(i)).newLine();
+        }
+
+        GuiContext context = GuiContext.getDefault();
+        GuiGraphics lastGraphics = context.getGraphics();
+
+        context.setOverrideFont(font);
+        context.setGraphics((GuiGraphics) (Object) this);
+        tooltip.draw(context, this.tooltipStack);
+
+        context.setGraphics(lastGraphics);
+        // the override font is removed at the end of RichTooltip#draw; no need to duplicate that here
+
+        // Cancel vanilla tooltip rendering
+        ci.cancel();
+    }
 }
diff --git a/src/main/java/com/gregtechceu/gtceu/core/mixins/client/KeyMappingAccessor.java b/src/main/java/com/gregtechceu/gtceu/core/mixins/client/KeyMappingAccessor.java
new file mode 100644
index 00000000000..f67b071db06
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/core/mixins/client/KeyMappingAccessor.java
@@ -0,0 +1,17 @@
+package com.gregtechceu.gtceu.core.mixins.client;
+
+import net.minecraft.client.KeyMapping;
+import net.minecraftforge.client.settings.KeyMappingLookup;
+
+import org.apache.commons.lang3.NotImplementedException;
+import org.spongepowered.asm.mixin.Mixin;
+import org.spongepowered.asm.mixin.gen.Accessor;
+
+@Mixin(KeyMapping.class)
+public interface KeyMappingAccessor {
+
+    @Accessor
+    static KeyMappingLookup getMAP() {
+        throw new NotImplementedException("KeyBindingMap getMAP()");
+    }
+}
diff --git a/src/main/java/com/gregtechceu/gtceu/core/mixins/client/KeyboardHandlerMixin.java b/src/main/java/com/gregtechceu/gtceu/core/mixins/client/KeyboardHandlerMixin.java
new file mode 100644
index 00000000000..be66b6bfcd4
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/core/mixins/client/KeyboardHandlerMixin.java
@@ -0,0 +1,39 @@
+package com.gregtechceu.gtceu.core.mixins.client;
+
+import com.gregtechceu.gtceu.client.CharTypedEvent;
+import com.gregtechceu.gtceu.client.EarlyKeyPressEvent;
+
+import net.minecraft.client.KeyboardHandler;
+import net.minecraft.client.Minecraft;
+import net.minecraftforge.common.MinecraftForge;
+
+import org.spongepowered.asm.mixin.Final;
+import org.spongepowered.asm.mixin.Mixin;
+import org.spongepowered.asm.mixin.Shadow;
+import org.spongepowered.asm.mixin.injection.At;
+import org.spongepowered.asm.mixin.injection.Inject;
+import org.spongepowered.asm.mixin.injection.callback.CallbackInfo;
+
+@Mixin(KeyboardHandler.class)
+public class KeyboardHandlerMixin {
+
+    @Shadow
+    @Final
+    private Minecraft minecraft;
+
+    @Inject(method = "charTyped", at = @At(value = "HEAD"), cancellable = true)
+    private void onCharTyped(long windowPointer, int codePoint, int modifiers, CallbackInfo ci) {
+        if (windowPointer == this.minecraft.getWindow().getWindow()) {
+            CharTypedEvent event = new CharTypedEvent((char) codePoint, modifiers);
+            if (MinecraftForge.EVENT_BUS.post(event)) ci.cancel();
+        }
+    }
+
+    @Inject(method = "keyPress", at = @At(value = "HEAD"), cancellable = true)
+    private void onKeyPressed(long windowPointer, int key, int scanCode, int action, int modifiers, CallbackInfo ci) {
+        if (windowPointer == this.minecraft.getWindow().getWindow()) {
+            EarlyKeyPressEvent event = new EarlyKeyPressEvent(key, scanCode, action, modifiers);
+            if (MinecraftForge.EVENT_BUS.post(event)) ci.cancel();
+        }
+    }
+}
diff --git a/src/main/java/com/gregtechceu/gtceu/core/mixins/ldlib/SyncUtilsMixin.java b/src/main/java/com/gregtechceu/gtceu/core/mixins/ldlib/SyncUtilsMixin.java
deleted file mode 100644
index e5ee1297b51..00000000000
--- a/src/main/java/com/gregtechceu/gtceu/core/mixins/ldlib/SyncUtilsMixin.java
+++ /dev/null
@@ -1,24 +0,0 @@
-package com.gregtechceu.gtceu.core.mixins.ldlib;
-
-import com.lowdragmc.lowdraglib.syncdata.SyncUtils;
-
-import net.minecraftforge.fluids.FluidStack;
-
-import org.spongepowered.asm.mixin.Mixin;
-import org.spongepowered.asm.mixin.injection.At;
-import org.spongepowered.asm.mixin.injection.Inject;
-import org.spongepowered.asm.mixin.injection.callback.CallbackInfoReturnable;
-
-@Mixin(SyncUtils.class)
-public class SyncUtilsMixin {
-
-    @Inject(method = "isChanged", at = @At("HEAD"), cancellable = true, remap = false)
-    private static void gtceu$isChanged(Object oldValue, Object newValue, CallbackInfoReturnable<Boolean> cir) {
-        if (oldValue instanceof FluidStack fluidStack) {
-            if (!(newValue instanceof FluidStack)) {
-                cir.setReturnValue(true);
-            }
-            cir.setReturnValue(!fluidStack.isFluidStackIdentical((FluidStack) newValue));
-        }
-    }
-}
diff --git a/src/main/java/com/gregtechceu/gtceu/data/lang/LangHandler.java b/src/main/java/com/gregtechceu/gtceu/data/lang/LangHandler.java
index 091a1564988..11211bb4d32 100644
--- a/src/main/java/com/gregtechceu/gtceu/data/lang/LangHandler.java
+++ b/src/main/java/com/gregtechceu/gtceu/data/lang/LangHandler.java
@@ -385,6 +385,35 @@ public static void init(RegistrateLangProvider provider) {
         provider.add("metaarmor.tooltip.freezing", "Prevents Freezing");
         provider.add("metaarmor.tooltip.breath", "Replenishes Underwater Breath Bar");
         provider.add("metaarmor.tooltip.autoeat", "Replenishes Food Bar by Using Food from Inventory");
+        provider.add("metaarmor.tooltip.modifier.speed", "Running Speed Module (%s)");
+        provider.add("metaarmor.tooltip.modifier.jump", "Jump Module (%s)");
+        provider.add("metaarmor.tooltip.modifier.damage_block", "Energy Shield Module (%s)");
+        provider.add("metaarmor.tooltip.modifier.attack_speed", "Attack Speed Module (%s)");
+        provider.add("metaarmor.tooltip.modifier.attack_damage", "Attack Damage Module (%s)");
+        provider.add("metaarmor.tooltip.modifier.battery", "Battery Module (%s)");
+        provider.add("metaarmor.tooltip.modifier.block_reach", "Reach Module (%s)");
+        provider.add("metaarmor.tooltip.modifier.jetpack", "Jetpack Module (%s)");
+        provider.add("metaarmor.tooltip.modifier.movement_speed", "Movement Speed Module (%s)");
+        provider.add("metaarmor.tooltip.modifier.sneak_speed", "Sneak Speed Module (%s)");
+        provider.add("metaarmor.tooltip.modifier.step_height", "Step Height Module (%s)");
+        provider.add("metaarmor.tooltip.modifier.swim_speed", "Swim Speed Module (%s)");
+        provider.add("metaarmor.tooltip.modifier.sensor", "Explosion Reporting Module (%s)");
+        provider.add("metaarmor.tooltip.modifier.wireless_charging", "Wireless Charging Module (%s)");
+        provider.add("metaarmor.tooltip.modifier.creative_flight", "Creative Flight Module");
+        provider.add("metaarmor.tooltip.modifier.battery.hud.info", "Storing %s/%s EU");
+        provider.add("metaarmor.tooltip.modifier.battery.hud.helmet", "Helmet battery: %s");
+        provider.add("metaarmor.tooltip.modifier.battery.hud.chestplate", "Chestplate battery: %s");
+        provider.add("metaarmor.tooltip.modifier.battery.hud.leggings", "Leggings battery: %s");
+        provider.add("metaarmor.tooltip.modifier.battery.hud.boots", "Boots battery: %s");
+        provider.add("metaarmor.tooltip.modifier.fluid_storage", "Additional fluid storage (%s)");
+        provider.add("metaarmor.tooltip.modifier.fluid_storage.tooltip", "Storing %s/%s mB of %s");
+        provider.add("metaarmor.tooltip.modifier", " - %s: %s");
+        provider.add("metaarmor.tooltip.modifier.empty", "Empty");
+        provider.add("metaarmor.tooltip.modifier_slot.universal", "Universal");
+        provider.add("metaarmor.tooltip.modifier_slot.tiered", "Tiered (%s)");
+        provider.add("metaarmor.tooltip.modifiers", "Module slots:");
+        provider.add("gtceu.modules", "Modules:");
+        provider.add("gtceu.machine.exploded", "%s exploded at (%d, %d, %d)");
         provider.add("metaarmor.hud.status.enabled", "§aON");
         provider.add("metaarmor.hud.status.disabled", "§cOFF");
         provider.add("metaarmor.hud.energy_lvl", "Energy Level: %s");
@@ -399,6 +428,51 @@ public static void init(RegistrateLangProvider provider) {
         provider.add("metaarmor.energy_share.tooltip", "Supply mode: %s");
         provider.add("metaarmor.energy_share.tooltip.guide",
                 "To change mode shift-right click when holding item");
+        provider.add("gtceu.module.speed", "Increases sprint speed by %s%%");
+        provider.add("gtceu.module.jump", "Increases jump height by %s blocks");
+        provider.add("gtceu.module.damage_block",
+                "Blocks any amount of damage with EU (%s EU per HP, requires any battery module)");
+        provider.add("gtceu.module.attack_speed", "Increases attack speed by %s%%");
+        provider.add("gtceu.module.attack_damage", "Increases attack damage by %s%%");
+        provider.add("gtceu.module.battery",
+                "Allows the item to store energy or increases its capacity (capacity is equal to the battery's)");
+        provider.add("gtceu.module.block_reach", "Increases block reach by %s blocks");
+        provider.add("gtceu.module.liquid_fuel_jetpack",
+                "Makes the chestplate work like a liquid fueled jetpack (requires any fluid storage module)");
+        provider.add("gtceu.module.jetpack", "Makes the chestplate work like a jetpack (requires any battery module)");
+        provider.add("gtceu.module.advanced_jetpack",
+                "Makes the chestplate work like an advanced jetpack (requires any battery module)");
+        provider.add("gtceu.module.movement_speed", "Increases all movement speed by %s%%");
+        provider.add("gtceu.module.sneak_speed", "Increases sneaking speed by %s%%");
+        provider.add("gtceu.module.step_height", "Increases step height by %s blocks");
+        provider.add("gtceu.module.swim_speed", "Increases swim speed by %s%%");
+        provider.add("gtceu.module.sensor", "Reports machine explosions (for machines placed by the player)");
+        provider.add("gtceu.module.wireless_charging",
+                "Allows wireless charging in the range of %s blocks (1A %s max), bind to a charger by right-clicking on it");
+        provider.add("gtceu.module.wireless_charging.interdimensional",
+                "%s blocks, 1A %s max, interdimensional if an at least %s field generator is present");
+        provider.add("gtceu.module.creative_flight", "Allows creative flight (consumes %s EU/t while flying)");
+        provider.add("gtceu.module.fluid_storage",
+                "Allows the item to store liquids or increases its capacity (capacity is equal to the tank's)");
+        provider.add("gtceu.module.nightvision", "Provides night vision (consumes %s EU/t while active)");
+        provider.add("gtceu.module.ppe",
+                "Provides protection from environmental hazards if applied to all armor pieces");
+        provider.add("gtceu.module.damage_block.short", "%s EU per HP");
+        provider.add("gtceu.module.short_percentage", "... by %s%%");
+        provider.add("gtceu.module.wireless_charging.short", "%s blocks, 1A %s max");
+        provider.add("gtceu.module.block_reach.short", "... by %s blocks");
+        provider.add("gtceu.module.gui.enabled", "Enabled:");
+        provider.add("gtceu.module.gui.jump_boost", "Boost:");
+        provider.add("gtceu.module.gui.power", "Power:");
+        provider.add("gtceu.module.gui.charge", "Charge:");
+        provider.add("emi.category.gtceu.equipment_foundry", "Equipment Foundry");
+        provider.add("gtceu.equipment_foundry.gui.applied_to", "Applied to:");
+        provider.add("gtceu.equipment_foundry.gui.module_item", "Module item:");
+        provider.add("gtceu.equipment_foundry.gui.supports_tiers", "Module tiers: %s-%s");
+        provider.add("gtceu.equipment_foundry.gui.tier", "Viewing stats for tier: %s");
+        provider.add("gtceu.equipment_foundry.gui.tier_too_high", "No module item exists for this tier");
+        provider.add("gtceu.equipment_foundry.gui.tooltip.tier_switch",
+                "Left-click to increase tier by 1\nRight-click to decrease tier by 1");
         provider.add("metaitem.record.sus.tooltip", "§7Leonz - Among Us Drip");
         provider.add("item.gtceu.nan_certificate.tooltip", "Challenge Accepted!");
         provider.add("item.gtceu.blacklight.tooltip", "Long-Wave §dUltraviolet§7 light source");
@@ -514,6 +588,7 @@ public static void init(RegistrateLangProvider provider) {
                 "§eInverted§r - in this mode, the cover will require a signal stronger than the set redstone level to run");
         multilineLang(provider, "cover.machine_controller.invert.disabled",
                 "§eNormal§r - in this mode, the cover will require a signal weaker than the set redstone level to run");
+        provider.add("cover.machine_controller.control", "Controller Target");
         provider.add("cover.machine_controller.redstone", "Min Redstone Strength: %d");
         provider.add("cover.machine_controller.suspend_powerfail", "Prevent Power Failing:");
         provider.add("cover.machine_controller.mode.machine", "Control Machine");
@@ -524,20 +599,23 @@ public static void init(RegistrateLangProvider provider) {
         provider.add("cover.machine_controller.mode.cover_east", "Control Cover (East)");
         provider.add("cover.machine_controller.mode.cover_west", "Control Cover (West)");
         provider.add("cover.machine_controller.mode.null", "Control Nothing");
+
+        provider.add("cover.ender_link.tooltip.channel_description", "Channel description");
+        provider.add("cover.ender_link.tooltip.channel_name", "Channel ID (32-bit hexadecimal value)");
+        provider.add("cover.ender_link.description_empty", "Empty Description");
+        provider.add("cover.ender_link.tooltip.list_button", "Show channel list");
+        provider.add("cover.ender_link.tooltip.clear_button", "Clear channel description");
+
+        provider.add("cover.ender_link.public.tooltip", "Public mode: Accessible to all players");
+        provider.add("cover.ender_link.protected.tooltip", "Protected Mode: Accessible to players on the same team.");
+        provider.add("cover.ender_link.private.tooltip",
+                "Private mode: Only accessible to the player who placed this cover");
+
         provider.add("cover.ender_fluid_link.title", "Ender Fluid Link");
         provider.add("cover.ender_item_link.title", "Ender Item Link");
         provider.add("cover.ender_redstone_link.title", "Ender Redstone Link");
         provider.add("cover.ender_fluid_link.iomode.enabled", "I/O Enabled");
         provider.add("cover.ender_fluid_link.iomode.disabled", "I/O Disabled");
-        provider.add("cover.ender_fluid_link.tooltip.channel_description", "Set channel description with input text");
-        provider.add("cover.ender_fluid_link.tooltip.channel_name", "Set channel name with input text");
-        provider.add("cover.ender_fluid_link.tooltip.list_button", "Show channel list");
-        provider.add("cover.ender_fluid_link.tooltip.clear_button", "Clear channel description");
-        multilineLang(provider, "cover.ender_fluid_link.private.tooltip.disabled",
-                "Switch to private tank mode\nPrivate mode uses the player who originally placed the cover");
-        provider.add("cover.ender_fluid_link.private.tooltip.enabled", "Switch to public tank mode");
-        multilineLang(provider, "cover.ender_fluid_link.incomplete_hex",
-                "Inputted color is incomplete!\nIt will be applied once complete (all 8 hex digits)\nClosing the gui will lose edits!");
         provider.add("cover.detector_base.message_normal_state", "Monitoring Status: Normal");
         provider.add("cover.detector_base.message_inverted_state", "Monitoring Status: Inverted");
 
@@ -742,6 +820,7 @@ public static void init(RegistrateLangProvider provider) {
         provider.add("item.gtceu.small_iridium_metal_residue_dust", "Small Pile of Iridium Metal Residue");
         provider.add("item.gtceu.iridium_metal_residue_dust", "Iridium Metal Residue");
 
+        provider.add("behaviour.charger_linked", "Linked charger");
         provider.add("behaviour.hoe", "Can till dirt");
         provider.add("behaviour.soft_hammer", "Activates and Deactivates Machines");
         provider.add("behaviour.soft_hammer.enabled", "Working Enabled");
@@ -907,6 +986,7 @@ public static void init(RegistrateLangProvider provider) {
         provider.add("gtceu.machine.workbench.tab.container", "Container");
 
         provider.add("gtceu.machine.parallel_hatch.display", "Adjust the maximum parallel of the multiblock");
+        provider.add("gtceu.machine.parallel_hatch.parallel_ui", "Parallels");
         provider.add("gtceu.machine.basic.input_from_output_side.allow", "Allow Input from Output Side: ");
         provider.add("gtceu.machine.basic.input_from_output_side.disallow",
                 "Disallow Input from Output Side: ");
@@ -1193,8 +1273,10 @@ public static void init(RegistrateLangProvider provider) {
                 "Muffler Hatch must have a block of airspace in front of it.");
         provider.add("gtceu.multiblock.universal.rotor_obstructed", "Rotor is Obstructed!");
         provider.add("gtceu.multiblock.universal.distinct", "Distinct Buses:");
-        provider.add("gtceu.multiblock.universal.distinct.no", "No");
-        provider.add("gtceu.multiblock.universal.distinct.yes", "Yes");
+
+        provider.add("gtceu.multiblock.universal.distinct.enabled", "Distinct Buses: §eEnabled");
+        provider.add("gtceu.multiblock.universal.distinct.disabled", "Distinct Buses: §eDisabled");
+
         provider.add("gtceu.multiblock.universal.distinct.info",
                 "If enabled, each Item Input Bus will be treated as fully distinct from each other for recipe lookup. Useful for things like Programmed Circuits, Extruder Shapes, etc.");
         provider.add("gtceu.multiblock.parallel", "Performing up to %d Recipes in Parallel");
@@ -1313,12 +1395,19 @@ public static void init(RegistrateLangProvider provider) {
         provider.add("gtceu.gui.circuit.title", "Circuit Settings");
         multiLang(provider, "gtceu.gui.output_setting.tooltips", "left-click to tune the item auto output",
                 "right-click to tune the fluid auto output.");
-        provider.add("gtceu.gui.item_auto_output.allow_input.enabled",
-                "allow items input from the output side");
-        provider.add("gtceu.gui.item_auto_output.allow_input.disabled",
-                "disable items input from the output side");
+
         provider.add("gtceu.gui.item_auto_output.enabled", "Item Auto Output: §aEnabled");
         provider.add("gtceu.gui.item_auto_output.disabled", "Item Auto Output: §cDisabled");
+
+        provider.add("gtceu.gui.item_input_from_output.enabled", "Allow Item Input from Output Side: §aEnabled");
+        provider.add("gtceu.gui.item_input_from_output.disabled", "Allow Item Input from Output Side: §cDisabled");
+
+        provider.add("gtceu.gui.fluid_auto_output.enabled", "Fluid Auto Output: §aEnabled");
+        provider.add("gtceu.gui.fluid_auto_output.disabled", "Fluid Auto Output: §cDisabled");
+
+        provider.add("gtceu.gui.fluid_input_from_output.enabled", "Allow Fluid Input from Output Side: §aEnabled");
+        provider.add("gtceu.gui.fluid_input_from_output.disabled", "Allow Fluid Input from Output Side: §cDisabled");
+
         multilineLang(provider, "gtceu.gui.item_auto_output.unselected",
                 """
                         Item Auto Output
@@ -1330,12 +1419,6 @@ public static void init(RegistrateLangProvider provider) {
                         §7The machine's item output is set to another direction.
                         §7Click to move the output to the currently selected side.
                         """);
-        provider.add("gtceu.gui.fluid_auto_output.allow_input.enabled",
-                "allow fluids input from the output side");
-        provider.add("gtceu.gui.fluid_auto_output.allow_input.disabled",
-                "disable fluids input from the output side");
-        provider.add("gtceu.gui.fluid_auto_output.enabled", "Fluid Auto Output: §aEnabled");
-        provider.add("gtceu.gui.fluid_auto_output.disabled", "Fluid Auto Output: §cDisabled");
         multilineLang(provider, "gtceu.gui.fluid_auto_output.unselected",
                 """
                         Fluid Auto Output
@@ -1390,9 +1473,11 @@ public static void init(RegistrateLangProvider provider) {
         provider.add("gtceu.gui.content.units.per_tick", "/t");
         provider.add("gtceu.gui.content.units.per_second", "/s");
 
+        provider.add("gtceu.gui.pattern_buffer.set_custom_name", "Set Custom Name: ");
         provider.add("gtceu.gui.me_network.online", "Network Status: §2Online§r");
         provider.add("gtceu.gui.me_network.offline", "Network Status: §4Offline§r");
         provider.add("gtceu.gui.waiting_list", "Sending Queue:");
+        provider.add("gtceu.gui.waiting_list_empty", "Sending Queue: §2Empty");
         provider.add("gtceu.gui.config_slot", "§fConfig Slot§r");
         provider.add("gtceu.gui.config_slot.set", "§7Click to §bset/select§7 config slot.§r");
         provider.add("gtceu.gui.config_slot.scroll", "§7Scroll wheel to §achange§7 config amount.§r");
@@ -1400,6 +1485,11 @@ public static void init(RegistrateLangProvider provider) {
         provider.add("gtceu.gui.config_slot.set_only", "§7Click to §bset§7 config slot.§r");
         provider.add("gtceu.gui.config_slot.auto_pull_managed", "§4Disabled:§7 Managed by Auto-Pull");
         provider.add("gtceu.gui.me_bus.auto_pull_button", "Click to toggle automatic item pulling from ME");
+        provider.add("gtceu.gui.me_network.auto_pull_toggle", "Toggle Auto-Pull");
+        provider.add("gtceu.gui.me_network.empty", "Empty");
+        provider.add("gtceu.gui.me_network.stocking_settings", "Stocking Settings");
+        provider.add("gtceu.gui.me_network.min_stack_size", "Min Stack Size:");
+        provider.add("gtceu.gui.me_network.ticks_per_cycle", "Ticks Per Cycle:");
 
         // Decor Stuff
         replace(provider, "block.gtceu.yellow_stripes_block.a", "Yellow Stripes Block");
@@ -1761,7 +1851,60 @@ public static void init(RegistrateLangProvider provider) {
         provider.add("gtceu.gui.central_monitor.text_scale", "Text scale");
         provider.add("gtceu.gui.central_monitor.group", "Group: %s");
         provider.add("gtceu.gui.central_monitor.group_default_name", "Group #%d");
-        provider.add("gtceu.gui.central_monitor.none", "none");
+        provider.add("gtceu.gui.central_monitor.pause",
+                "Pause placeholder execution.\nText won't be updated, and code won't be run.");
+        provider.add("gtceu.gui.central_monitor.resume", "Unpause placeholder execution.");
+        provider.add("gtceu.gui.central_monitor.update_once",
+                "Update text and run all placeholders in it exactly once.");
+        provider.add("gtceu.gui.central_monitor.help",
+                """
+                        A monitor group is a collection of any amount of monitors in the multiblock.
+                        For a group to display anything, it needs 2 things:
+                         - you to select the monitors that you want to display something on
+                         - an inserted and configured monitor module
+                        A module must be inserted in the slot to the right of the group name textbox.
+                        When you insert it, a button will appear to configure the module (for example just enter the text to display)
+                        Then you have to select at least 1 monitor in the grid below the group name textbox, here are types of selections:""");
+        provider.add("gtceu.gui.central_monitor.in_group",
+                "Monitors selected this way are added to the group, and will be used to display stuff");
+        provider.add("gtceu.gui.central_monitor.left_click", "Select/unselect a monitor by left-clicking it");
+        provider.add("gtceu.gui.central_monitor.target",
+                "The block selected this way is considered a target, to be used with placeholders in a text module.");
+        provider.add("gtceu.gui.central_monitor.right_click",
+                "Select a block by right-clicking it. Only 1 block can be a target.");
+        provider.add("gtceu.gui.central_monitor.in_group_and_target",
+                "The monitor selected this way is used for displaying and as a target at the same time.");
+        provider.add("gtceu.gui.central_monitor.data_hatch_target",
+                "If you select a data hatch as a target, you will be prompted to enter a slot number. Then the block that the data stick in the specified slot is linked to (via right-clicking a wireless transmitter cover) will be considered the target instead.");
+        provider.add("gtceu.gui.central_monitor.text_module_help",
+                """
+                        This module displays text that can have placeholders.
+                        Placeholders are strings like "{energy}" that when displayed, will display their value instead (in this case the amount of energy).
+                        They can also do some other things, such as set a redstone output/read redstone input, run calculations, etc.
+                        Some placeholders, like {energy} must have a target to function. A target is basically any block that can accept covers or is part of the
+                        central monitor multiblock. For example {energy} displays the amount of energy in its target block, usually a battery buffer or a PSS.
+                        Select a target in the monitor group editing window, check out the help page there for more info.
+                        Here's an example usage of placeholders, that displays some energy info and sends a redstone signal when energy is <50%:
+                        """);
+        provider.add("gtceu.gui.central_monitor.url", "Input image URL:");
+        provider.add("gtceu.gui.central_monitor.gui_module_info",
+                "To select a block to get the GUI from, select a target in the monitor group editor.");
+        provider.add("gtceu.gui.central_monitor.module_editor_disabled",
+                "You recently changed the module, please re-open this GUI to edit it");
+        provider.add("gtceu.gui.central_monitor.module_editor_button", "Edit module");;
+        provider.add("gtceu.item.tooltip.image_url", "Image URL: %s");
+        provider.add("gtceu.placeholder_editor.unclosed_bracket", "Unclosed bracket (\"}\")");
+        provider.add("gtceu.placeholder_editor.unclosed_brackets", "%d brackets (\"}\") are unclosed");
+        provider.add("gtceu.placeholder_editor.unclosed_escape", "Unclosed escape (\"']\")");
+        provider.add("gtceu.placeholder_editor.unclosed_escapes", "%d escapes (\"']\") are unclosed");
+        provider.add("gtceu.placeholder_editor.extra_closing_bracket", "Extra closing bracket");
+        provider.add("gtceu.placeholder_editor.no_placeholder", "Placeholder with name '%s' does not exist");
+        provider.add("gtceu.placeholder_editor.constant_value",
+                "This expression always evaluates to the same result.\nConsider replacing it with a constant.");
+        provider.add("gtceu.placeholder_editor.write_in_if", """
+                Placeholders inside {if} are executed regardless of the condition.
+                This means that, for example, "{if 0 {redstone set 15}}" will produce redstone output.
+                To avoid this, use "{eval {if <condition> "<code>" "<else_code>"}}".""");
         provider.add("gtceu.central_monitor.size", "Size: (%d+1+%d)x(%d+1+%d)");
         provider.add("gtceu.computer_monitor_cover.error.invalid_number", "Invalid number '%s'!");
         provider.add("gtceu.computer_monitor_cover.error.wrong_number_of_args", "Expected %d args, got %d!");
@@ -1781,9 +1924,11 @@ public static void init(RegistrateLangProvider provider) {
                 "Input string to display on line %d here.",
                 "It can have placeholders, for example: 'Energy: {energy}/{energyCapacity} EU'",
                 "Placeholders can also be inside other placeholders.");
-        multiLang(provider, "gtceu.gui.computer_monitor_cover.slot_tooltip",
-                "A slot for items that some placeholders can reference",
-                "Slot number: %d");
+        provider.add("gtceu.gui.computer_monitor_cover.slot_tooltip",
+                """
+                        A slot for items that some placeholders can reference
+                        Slot number: %d
+                        """);
         multiLang(provider, "gtceu.gui.computer_monitor_cover.second_page_textbox_tooltip",
                 "Input placeholder to be used in place of %s '{}' here.",
                 "For example, you can have a string 'Energy: {}/{} EU' and 'energy' and 'energyCapacity' in these text boxes.");;
@@ -1793,6 +1938,10 @@ public static void init(RegistrateLangProvider provider) {
         provider.add("gtceu.computer_monitor_cover.error.no_ae", "Cover holder does not have an AE2 network!");
         provider.add("gtceu.computer_monitor_cover.error.not_supported",
                 "This feature is not supported by this block/cover!");
+        provider.add("gtceu.central_monitor.gui.monitor_groups", "Monitor groups");
+        provider.add("gtceu.central_monitor.gui.group_editor", "Editing monitor group");
+        provider.add("gtceu.central_monitor.gui.group_name", "Name:");
+        provider.add("gtceu.central_monitor.gui.data_slot", "Set slot number of data stick");
         provider.add("gtceu.central_monitor.gui.create_group", "Create group");
         provider.add("gtceu.central_monitor.gui.remove_from_group", "Remove from group");
         provider.add("gtceu.central_monitor.gui.set_target", "Set target");
@@ -1808,6 +1957,7 @@ public static void init(RegistrateLangProvider provider) {
                 "Place the cover on the target block, right-click it with a data stick and put that data stick into a data access hatch in the multiblock.",
                 "Then select the data access hatch as the target, and set the slot index of your data stick in the number field that appeared.");
         provider.add("gtceu.tooltip.player_bind", "Bound to player: %s");
+        provider.add("gtceu.gui.item_collector.range", "Range: ");
     }
 
     /**
diff --git a/src/main/java/com/gregtechceu/gtceu/data/lang/MachineLang.java b/src/main/java/com/gregtechceu/gtceu/data/lang/MachineLang.java
index 0efc336ac21..93348fc679d 100644
--- a/src/main/java/com/gregtechceu/gtceu/data/lang/MachineLang.java
+++ b/src/main/java/com/gregtechceu/gtceu/data/lang/MachineLang.java
@@ -476,12 +476,9 @@ protected static void init(RegistrateLangProvider provider) {
         provider.add("gtceu.machine.miner.fluid_usage", "Uses §f%d mB/t §7of §f%s§7, doubled per overclock.");
         provider.add("gtceu.machine.miner.multi.description",
                 "A multiblock mining machine that covers a large area and produces huge quantity of ore.");
-        provider.add("gtceu.machine.miner.startx", "sX: %d");
-        provider.add("gtceu.machine.miner.starty", "sY: %d");
-        provider.add("gtceu.machine.miner.startz", "sZ: %d");
-        provider.add("gtceu.machine.miner.minex", "mX: %d");
-        provider.add("gtceu.machine.miner.miney", "mY: %d");
-        provider.add("gtceu.machine.miner.minez", "mZ: %d");
+        provider.add("gtceu.machine.miner.x", "sX: %d, mX: %d");
+        provider.add("gtceu.machine.miner.y", "sY: %d, mY: %d");
+        provider.add("gtceu.machine.miner.z", "sZ: %d, mZ: %d");
         provider.add("gtceu.machine.miner.radius", "Radius: %d");
         provider.add("gtceu.machine.miner.chunkradius", "Chunk Radius: %d");
         provider.add("gtceu.machine.miner.progress", "Progress: %d/%d");
@@ -971,8 +968,7 @@ protected static void init(RegistrateLangProvider provider) {
         provider.add("gtceu.multiblock.hpca.warning_no_computation", "- No computation providers");
         provider.add("gtceu.multiblock.hpca.warning_low_cooling", "- Not enough cooling");
         provider.add("gtceu.multiblock.hpca.info_max_computation", "Max CWU/t: %s");
-        provider.add("gtceu.multiblock.hpca.info_max_cooling_demand", "Cooling Demand: %s");
-        provider.add("gtceu.multiblock.hpca.info_max_cooling_available", "Cooling Available: %s");
+        provider.add("gtceu.multiblock.hpca.info_cooling_demand", "Cooling Demand: %s / %d");
         provider.add("gtceu.multiblock.hpca.info_max_coolant_required", "Coolant Needed: %s");
         provider.add("gtceu.multiblock.hpca.info_coolant_name", "PCB Coolant");
         provider.add("gtceu.multiblock.hpca.info_bridging_enabled", "Bridging Enabled");
@@ -988,7 +984,8 @@ protected static void init(RegistrateLangProvider provider) {
         provider.add("gtceu.creative.energy.voltage", "Voltage");
         provider.add("gtceu.creative.energy.sink", "Sink");
         provider.add("gtceu.creative.energy.source", "Source");
-        provider.add("gtceu.creative.computation.average", "Average Requested CWUt");
+        provider.add("gtceu.creative.computation.average", "Average CWU/tick: %d");
+        provider.add("gtceu.creative.computation.max_usage", "Max CWU/tick:");
         provider.add("gtceu.creative.activity.on", "Active");
         provider.add("gtceu.creative.activity.off", "Not active");
     }
diff --git a/src/main/java/com/gregtechceu/gtceu/data/loot/ChestGenHooks.java b/src/main/java/com/gregtechceu/gtceu/data/loot/ChestGenHooks.java
index 3cf4e1b8c0c..d594593e556 100644
--- a/src/main/java/com/gregtechceu/gtceu/data/loot/ChestGenHooks.java
+++ b/src/main/java/com/gregtechceu/gtceu/data/loot/ChestGenHooks.java
@@ -162,9 +162,6 @@ public LootItemFunctionType getType() {
 
         @Override
         protected ItemStack run(ItemStack itemStack, LootContext context) {
-            if (stack.getDamageValue() != 0) {
-                itemStack.setDamageValue(stack.getDamageValue());
-            }
             CompoundTag tagCompound = stack.getTag();
             if (tagCompound != null) {
                 itemStack.setTag(tagCompound.copy());
diff --git a/src/main/java/com/gregtechceu/gtceu/data/recipe/CustomTags.java b/src/main/java/com/gregtechceu/gtceu/data/recipe/CustomTags.java
index fdaa30c2445..d0d53d14915 100644
--- a/src/main/java/com/gregtechceu/gtceu/data/recipe/CustomTags.java
+++ b/src/main/java/com/gregtechceu/gtceu/data/recipe/CustomTags.java
@@ -125,6 +125,7 @@ public class CustomTags {
     public static final TagKey<Item> PPE_ARMOR = TagUtil.createModItemTag("ppe_armor");
     public static final TagKey<Item> STEP_BOOTS = TagUtil.createModItemTag("step_boots");
     public static final TagKey<Item> RUBBER_LOGS = TagUtil.createModItemTag("rubber_logs");
+    public static final TagKey<Item> FLUID_CONTAINERS = TagUtil.createModItemTag("fluid_containers");
 
     public static final TagKey<Block> CLEANROOM_DOORS = TagUtil.createModBlockTag("cleanroom_doors");
 
diff --git a/src/main/java/com/gregtechceu/gtceu/data/recipe/VanillaRecipeHelper.java b/src/main/java/com/gregtechceu/gtceu/data/recipe/VanillaRecipeHelper.java
index cc9e0345d30..ce64b7b5631 100644
--- a/src/main/java/com/gregtechceu/gtceu/data/recipe/VanillaRecipeHelper.java
+++ b/src/main/java/com/gregtechceu/gtceu/data/recipe/VanillaRecipeHelper.java
@@ -10,6 +10,7 @@
 import com.gregtechceu.gtceu.api.data.chemical.material.stack.MaterialEntry;
 import com.gregtechceu.gtceu.api.data.chemical.material.stack.MaterialStack;
 import com.gregtechceu.gtceu.api.data.tag.TagPrefix;
+import com.gregtechceu.gtceu.api.item.module.ItemModule;
 import com.gregtechceu.gtceu.api.item.tool.GTToolType;
 import com.gregtechceu.gtceu.api.item.tool.ToolHelper;
 import com.gregtechceu.gtceu.data.recipe.builder.*;
@@ -317,7 +318,7 @@ public static void addStrictSizeShapedRecipe(Consumer<FinishedRecipe> provider,
      * <li>{@code 'w'} - {@code craftingToolWrench}</li>
      * <li>{@code 'x'} - {@code craftingToolWireCutter}</li>
      * </ul>
-     * 
+     *
      * @param setMaterialInfoData whether to add material decomposition information to the recipe output
      *
      * @param matchSize
@@ -660,6 +661,47 @@ public static void addToolUpgradingRecipe(@NotNull Consumer<FinishedRecipe> prov
                 template, addition);
     }
 
+    public static void addEquipmentFoundryRecipe(Consumer<FinishedRecipe> provider, @NotNull ResourceLocation regName,
+                                                 @NotNull Ingredient equipment,
+                                                 @NotNull Object ingredient, @NotNull ItemModule[] modifiers) {
+        var builder = new EquipmentFoundryRecipeBuilder(regName).equipment(equipment).modifier(modifiers);
+        if (ingredient instanceof Ingredient ing) {
+            builder.ingredient(ing);
+        } else if (ingredient instanceof ItemStack itemStack) {
+            builder.ingredient(itemStack);
+        } else if (ingredient instanceof TagKey<?> key) {
+            builder.ingredient((TagKey<Item>) key);
+        } else if (ingredient instanceof ItemLike itemLike) {
+            builder.ingredient(itemLike);
+        } else if (ingredient instanceof MaterialEntry entry) {
+            TagKey<Item> tag = ChemicalHelper.getTag(entry.tagPrefix(), entry.material());
+            if (tag != null) {
+                builder.ingredient(tag);
+            } else builder.ingredient(ChemicalHelper.get(entry.tagPrefix(), entry.material()));
+        } else if (ingredient instanceof Character c) {
+            builder.ingredient(ToolHelper.getToolFromSymbol(c).itemTags.get(0));
+        }
+        builder.save(provider);
+    }
+
+    public static void addEquipmentFoundryRecipe(Consumer<FinishedRecipe> provider, @NotNull String regName,
+                                                 @NotNull Ingredient equipment,
+                                                 @NotNull Object ingredient, @NotNull ItemModule[] modifiers) {
+        addEquipmentFoundryRecipe(provider, GTCEu.id(regName), equipment, ingredient, modifiers);
+    }
+
+    public static void addEquipmentFoundryRecipe(Consumer<FinishedRecipe> provider, @NotNull String regName,
+                                                 @NotNull Ingredient equipment,
+                                                 @NotNull Object ingredient, @NotNull ItemModule modifier) {
+        addEquipmentFoundryRecipe(provider, GTCEu.id(regName), equipment, ingredient, modifier);
+    }
+
+    public static void addEquipmentFoundryRecipe(Consumer<FinishedRecipe> provider, @NotNull ResourceLocation regName,
+                                                 @NotNull Ingredient equipment,
+                                                 @NotNull Object ingredient, @NotNull ItemModule modifier) {
+        addEquipmentFoundryRecipe(provider, regName, equipment, ingredient, new ItemModule[] { modifier });
+    }
+
     /**
      * @param material the material to check
      * @return if the material is a wood
diff --git a/src/main/java/com/gregtechceu/gtceu/data/recipe/builder/EquipmentFoundryRecipeBuilder.java b/src/main/java/com/gregtechceu/gtceu/data/recipe/builder/EquipmentFoundryRecipeBuilder.java
new file mode 100644
index 00000000000..4cde7a3fc5f
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/data/recipe/builder/EquipmentFoundryRecipeBuilder.java
@@ -0,0 +1,107 @@
+package com.gregtechceu.gtceu.data.recipe.builder;
+
+import com.gregtechceu.gtceu.api.item.module.ItemModule;
+import com.gregtechceu.gtceu.common.data.GTRecipeTypes;
+
+import net.minecraft.data.recipes.FinishedRecipe;
+import net.minecraft.resources.ResourceLocation;
+import net.minecraft.tags.TagKey;
+import net.minecraft.world.item.Item;
+import net.minecraft.world.item.ItemStack;
+import net.minecraft.world.item.crafting.Ingredient;
+import net.minecraft.world.item.crafting.RecipeSerializer;
+import net.minecraft.world.level.ItemLike;
+import net.minecraftforge.common.crafting.StrictNBTIngredient;
+
+import com.google.gson.JsonArray;
+import com.google.gson.JsonObject;
+import lombok.Setter;
+import lombok.experimental.Accessors;
+import lombok.experimental.Tolerate;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+
+import java.util.function.Consumer;
+
+@Accessors(chain = true, fluent = true)
+public class EquipmentFoundryRecipeBuilder {
+
+    @Setter
+    private ResourceLocation id;
+    @Setter
+    private Ingredient equipment;
+    @Setter
+    private Ingredient ingredient;
+    @Setter
+    private ItemModule[] modifier;
+
+    public EquipmentFoundryRecipeBuilder(@Nullable ResourceLocation id) {
+        this.id = id;
+    }
+
+    @Tolerate
+    public EquipmentFoundryRecipeBuilder ingredient(TagKey<Item> itemStack) {
+        return ingredient(Ingredient.of(itemStack));
+    }
+
+    @Tolerate
+    public EquipmentFoundryRecipeBuilder ingredient(ItemStack itemStack) {
+        if (itemStack.hasTag()) {
+            ingredient = StrictNBTIngredient.of(itemStack);
+        } else {
+            ingredient = Ingredient.of(itemStack);
+        }
+        return this;
+    }
+
+    @Tolerate
+    public EquipmentFoundryRecipeBuilder ingredient(ItemLike itemLike) {
+        return ingredient(Ingredient.of(itemLike));
+    }
+
+    protected ResourceLocation defaultId() {
+        return modifier[0].getId();
+    }
+
+    public void toJson(JsonObject json) {
+        json.add("equipment", equipment.toJson());
+        json.add("ingredient", ingredient.toJson());
+
+        JsonArray arr = new JsonArray();
+        for (ItemModule module : modifier) arr.add(module.getId().toString());
+        json.add("modifier", arr);
+    }
+
+    public void save(Consumer<FinishedRecipe> consumer) {
+        consumer.accept(new FinishedRecipe() {
+
+            @Override
+            public void serializeRecipeData(@NotNull JsonObject pJson) {
+                toJson(pJson);
+            }
+
+            @Override
+            public @NotNull ResourceLocation getId() {
+                var _id = id == null ? defaultId() : id;
+                return _id.withPrefix("equipment_foundry/");
+            }
+
+            @Override
+            public @NotNull RecipeSerializer<?> getType() {
+                return GTRecipeTypes.EQUIPMENT_FOUNDRY_SERIALIZER.get();
+            }
+
+            @Nullable
+            @Override
+            public JsonObject serializeAdvancement() {
+                return null;
+            }
+
+            @Nullable
+            @Override
+            public ResourceLocation getAdvancementId() {
+                return null;
+            }
+        });
+    }
+}
diff --git a/src/main/java/com/gregtechceu/gtceu/data/recipe/builder/ShapedEnergyTransferRecipeBuilder.java b/src/main/java/com/gregtechceu/gtceu/data/recipe/builder/ShapedEnergyTransferRecipeBuilder.java
index 9fb82764ffd..c8d69c8d1a9 100644
--- a/src/main/java/com/gregtechceu/gtceu/data/recipe/builder/ShapedEnergyTransferRecipeBuilder.java
+++ b/src/main/java/com/gregtechceu/gtceu/data/recipe/builder/ShapedEnergyTransferRecipeBuilder.java
@@ -2,9 +2,7 @@
 
 import com.gregtechceu.gtceu.GTCEu;
 import com.gregtechceu.gtceu.api.recipe.ShapedEnergyTransferRecipe;
-
-import com.lowdragmc.lowdraglib.utils.Builder;
-import com.lowdragmc.lowdraglib.utils.NBTToJsonConverter;
+import com.gregtechceu.gtceu.utils.data.NBTToJsonConverter;
 
 import net.minecraft.core.registries.BuiltInRegistries;
 import net.minecraft.data.recipes.FinishedRecipe;
@@ -22,17 +20,21 @@
 import com.google.gson.JsonObject;
 import org.jetbrains.annotations.Nullable;
 
+import java.util.*;
 import java.util.function.Consumer;
 
-public class ShapedEnergyTransferRecipeBuilder extends Builder<Ingredient, ShapedEnergyTransferRecipeBuilder> {
+public class ShapedEnergyTransferRecipeBuilder {
 
     protected ItemStack output = ItemStack.EMPTY;
     protected Ingredient chargeIngredient = Ingredient.EMPTY;
-    protected ResourceLocation id;
-    protected String group;
+    protected @Nullable ResourceLocation id;
+    protected @Nullable String group;
     protected boolean transferMaxCharge;
     protected boolean overrideCharge;
 
+    protected List<String[]> shape = new ArrayList<>();
+    protected Map<Character, Ingredient> ingredientMap = new LinkedHashMap<>();
+
     public ShapedEnergyTransferRecipeBuilder(@Nullable ResourceLocation id) {
         this.id = id;
     }
@@ -41,6 +43,16 @@ public ShapedEnergyTransferRecipeBuilder() {
         this(null);
     }
 
+    public ShapedEnergyTransferRecipeBuilder aisle(String... data) {
+        this.shape.add(data);
+        return this;
+    }
+
+    public ShapedEnergyTransferRecipeBuilder where(char symbol, Ingredient value) {
+        this.ingredientMap.put(symbol, value);
+        return this;
+    }
+
     public ShapedEnergyTransferRecipeBuilder pattern(String slice) {
         return aisle(slice);
     }
@@ -109,9 +121,10 @@ public ShapedEnergyTransferRecipeBuilder group(String group) {
         return this;
     }
 
-    @Override
     public ShapedEnergyTransferRecipeBuilder shallowCopy() {
-        var builder = super.shallowCopy();
+        var builder = new ShapedEnergyTransferRecipeBuilder();
+        builder.shape = new ArrayList<>(this.shape);
+        builder.ingredientMap = new HashMap<>(this.ingredientMap);
         builder.output = output.copy();
         return builder;
     }
@@ -131,9 +144,9 @@ public void toJson(JsonObject json) {
             json.add("pattern", pattern);
         }
 
-        if (!symbolMap.isEmpty()) {
+        if (!ingredientMap.isEmpty()) {
             JsonObject key = new JsonObject();
-            symbolMap.forEach((k, v) -> key.add(k.toString(), v.toJson()));
+            ingredientMap.forEach((k, v) -> key.add(k.toString(), v.toJson()));
             json.add("key", key);
         }
 
diff --git a/src/main/java/com/gregtechceu/gtceu/data/recipe/builder/ShapedRecipeBuilder.java b/src/main/java/com/gregtechceu/gtceu/data/recipe/builder/ShapedRecipeBuilder.java
index b871319e325..5e53597c787 100644
--- a/src/main/java/com/gregtechceu/gtceu/data/recipe/builder/ShapedRecipeBuilder.java
+++ b/src/main/java/com/gregtechceu/gtceu/data/recipe/builder/ShapedRecipeBuilder.java
@@ -2,9 +2,7 @@
 
 import com.gregtechceu.gtceu.GTCEu;
 import com.gregtechceu.gtceu.api.recipe.StrictShapedRecipe;
-
-import com.lowdragmc.lowdraglib.utils.Builder;
-import com.lowdragmc.lowdraglib.utils.NBTToJsonConverter;
+import com.gregtechceu.gtceu.utils.data.NBTToJsonConverter;
 
 import net.minecraft.core.registries.BuiltInRegistries;
 import net.minecraft.data.recipes.FinishedRecipe;
@@ -22,16 +20,20 @@
 import com.google.gson.JsonObject;
 import org.jetbrains.annotations.Nullable;
 
+import java.util.*;
 import java.util.function.Consumer;
 
-public class ShapedRecipeBuilder extends Builder<Ingredient, ShapedRecipeBuilder> {
+public class ShapedRecipeBuilder {
 
     protected ItemStack output = ItemStack.EMPTY;
-    protected ResourceLocation id;
-    protected String group;
+    protected @Nullable ResourceLocation id;
+    protected @Nullable String group;
     protected boolean isStrict;
     protected boolean matchSize;
 
+    protected List<String[]> shape = new ArrayList<>();
+    protected Map<Character, Ingredient> ingredientMap = new LinkedHashMap<>();
+
     public ShapedRecipeBuilder(@Nullable ResourceLocation id) {
         this.id = id;
     }
@@ -40,6 +42,16 @@ public ShapedRecipeBuilder() {
         this(null);
     }
 
+    public ShapedRecipeBuilder aisle(String... data) {
+        this.shape.add(data);
+        return this;
+    }
+
+    public ShapedRecipeBuilder where(char symbol, Ingredient value) {
+        this.ingredientMap.put(symbol, value);
+        return this;
+    }
+
     public ShapedRecipeBuilder pattern(String slice) {
         return aisle(slice);
     }
@@ -62,13 +74,13 @@ public ShapedRecipeBuilder define(char cha, Ingredient ingredient) {
 
     public ShapedRecipeBuilder output(ItemStack itemStack) {
         this.output = itemStack.copy();
-        return (ShapedRecipeBuilder) this;
+        return this;
     }
 
     public ShapedRecipeBuilder output(ItemStack itemStack, int count) {
         this.output = itemStack.copy();
         this.output.setCount(count);
-        return (ShapedRecipeBuilder) this;
+        return this;
     }
 
     public ShapedRecipeBuilder output(ItemStack itemStack, int count, CompoundTag nbt) {
@@ -104,9 +116,10 @@ public ShapedRecipeBuilder matchSize(boolean matchSize) {
         return this;
     }
 
-    @Override
     public ShapedRecipeBuilder shallowCopy() {
-        var builder = super.shallowCopy();
+        ShapedRecipeBuilder builder = new ShapedRecipeBuilder();
+        builder.shape = new ArrayList<>(this.shape);
+        builder.ingredientMap = new HashMap<>(this.ingredientMap);
         builder.output = output.copy();
         return builder;
     }
@@ -126,9 +139,9 @@ public void toJson(JsonObject json) {
             json.add("pattern", pattern);
         }
 
-        if (!symbolMap.isEmpty()) {
+        if (!ingredientMap.isEmpty()) {
             JsonObject key = new JsonObject();
-            symbolMap.forEach((k, v) -> key.add(k.toString(), v.toJson()));
+            ingredientMap.forEach((k, v) -> key.add(k.toString(), v.toJson()));
             json.add("key", key);
         }
 
diff --git a/src/main/java/com/gregtechceu/gtceu/data/recipe/builder/ShapelessRecipeBuilder.java b/src/main/java/com/gregtechceu/gtceu/data/recipe/builder/ShapelessRecipeBuilder.java
index 4bfe7950b25..d61a6c21421 100644
--- a/src/main/java/com/gregtechceu/gtceu/data/recipe/builder/ShapelessRecipeBuilder.java
+++ b/src/main/java/com/gregtechceu/gtceu/data/recipe/builder/ShapelessRecipeBuilder.java
@@ -1,8 +1,7 @@
 package com.gregtechceu.gtceu.data.recipe.builder;
 
 import com.gregtechceu.gtceu.GTCEu;
-
-import com.lowdragmc.lowdraglib.utils.NBTToJsonConverter;
+import com.gregtechceu.gtceu.utils.data.NBTToJsonConverter;
 
 import net.minecraft.core.registries.BuiltInRegistries;
 import net.minecraft.data.recipes.FinishedRecipe;
diff --git a/src/main/java/com/gregtechceu/gtceu/data/recipe/builder/SimpleCookingRecipeBuilder.java b/src/main/java/com/gregtechceu/gtceu/data/recipe/builder/SimpleCookingRecipeBuilder.java
index cd8d604e533..ad3b7c532a2 100644
--- a/src/main/java/com/gregtechceu/gtceu/data/recipe/builder/SimpleCookingRecipeBuilder.java
+++ b/src/main/java/com/gregtechceu/gtceu/data/recipe/builder/SimpleCookingRecipeBuilder.java
@@ -1,8 +1,7 @@
 package com.gregtechceu.gtceu.data.recipe.builder;
 
 import com.gregtechceu.gtceu.GTCEu;
-
-import com.lowdragmc.lowdraglib.utils.NBTToJsonConverter;
+import com.gregtechceu.gtceu.utils.data.NBTToJsonConverter;
 
 import net.minecraft.core.registries.BuiltInRegistries;
 import net.minecraft.data.recipes.FinishedRecipe;
diff --git a/src/main/java/com/gregtechceu/gtceu/data/recipe/misc/CraftingRecipeLoader.java b/src/main/java/com/gregtechceu/gtceu/data/recipe/misc/CraftingRecipeLoader.java
index 1d2936362ba..b2eec819464 100644
--- a/src/main/java/com/gregtechceu/gtceu/data/recipe/misc/CraftingRecipeLoader.java
+++ b/src/main/java/com/gregtechceu/gtceu/data/recipe/misc/CraftingRecipeLoader.java
@@ -30,9 +30,6 @@
 public class CraftingRecipeLoader {
 
     public static void init(Consumer<FinishedRecipe> provider) {
-        // todo facades
-        // registerFacadeRecipe(provider, Iron, 4);
-
         VanillaRecipeHelper.addShapedRecipe(provider, "small_wooden_pipe", ChemicalHelper.get(pipeSmallFluid, Wood),
                 "sWr", 'W', ItemTags.PLANKS);
         VanillaRecipeHelper.addShapedRecipe(provider, "normal_wooden_pipe", ChemicalHelper.get(pipeNormalFluid, Wood),
diff --git a/src/main/java/com/gregtechceu/gtceu/data/recipe/misc/EquipmentFoundryRecipes.java b/src/main/java/com/gregtechceu/gtceu/data/recipe/misc/EquipmentFoundryRecipes.java
new file mode 100644
index 00000000000..088ec51368c
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/data/recipe/misc/EquipmentFoundryRecipes.java
@@ -0,0 +1,125 @@
+package com.gregtechceu.gtceu.data.recipe.misc;
+
+import com.gregtechceu.gtceu.api.data.chemical.ChemicalHelper;
+import com.gregtechceu.gtceu.common.data.GTItemModules;
+import com.gregtechceu.gtceu.common.data.GTItems;
+import com.gregtechceu.gtceu.data.recipe.CustomTags;
+import com.gregtechceu.gtceu.data.recipe.VanillaRecipeHelper;
+
+import net.minecraft.data.recipes.FinishedRecipe;
+import net.minecraft.world.item.crafting.Ingredient;
+import net.minecraftforge.common.Tags;
+
+import java.util.function.Consumer;
+
+import static com.gregtechceu.gtceu.api.data.tag.TagPrefix.*;
+import static com.gregtechceu.gtceu.common.data.GTMaterials.*;
+
+public class EquipmentFoundryRecipes {
+
+    public static void init(Consumer<FinishedRecipe> provider) {
+        VanillaRecipeHelper.addEquipmentFoundryRecipe(provider, "speed",
+                Ingredient.of(Tags.Items.ARMORS_LEGGINGS),
+                CustomTags.ELECTRIC_MOTORS, GTItemModules.SPEED);
+
+        VanillaRecipeHelper.addEquipmentFoundryRecipe(provider, "energy_shield",
+                Ingredient.of(Tags.Items.ARMORS_CHESTPLATES),
+                CustomTags.FIELD_GENERATORS, GTItemModules.DAMAGE_BLOCK);
+
+        VanillaRecipeHelper.addEquipmentFoundryRecipe(provider, "attack_speed",
+                Ingredient.of(Tags.Items.ARMORS_CHESTPLATES),
+                CustomTags.ELECTRIC_MOTORS, GTItemModules.ATTACK_SPEED);
+
+        VanillaRecipeHelper.addEquipmentFoundryRecipe(provider, "attack_damage",
+                Ingredient.of(Tags.Items.ARMORS_CHESTPLATES),
+                CustomTags.ELECTRIC_PISTONS, GTItemModules.ATTACK_DAMAGE);
+
+        VanillaRecipeHelper.addEquipmentFoundryRecipe(provider, "block_reach",
+                Ingredient.of(Tags.Items.ARMORS_CHESTPLATES),
+                CustomTags.ROBOT_ARMS, GTItemModules.BLOCK_REACH);
+
+        VanillaRecipeHelper.addEquipmentFoundryRecipe(provider, "sneak_speed",
+                Ingredient.of(Tags.Items.ARMORS_LEGGINGS),
+                CustomTags.CONVEYOR_MODULES, GTItemModules.SNEAK_SPEED);
+
+        VanillaRecipeHelper.addEquipmentFoundryRecipe(provider, "speed_attribute",
+                Ingredient.of(Tags.Items.ARMORS_BOOTS),
+                CustomTags.ELECTRIC_MOTORS, GTItemModules.MOVEMENT_SPEED_ATTR);
+
+        VanillaRecipeHelper.addEquipmentFoundryRecipe(provider, "respiration",
+                Ingredient.of(Tags.Items.ARMORS_HELMETS),
+                CustomTags.ELECTRIC_PUMPS, GTItemModules.AIR_SUPPLIER);
+
+        VanillaRecipeHelper.addEquipmentFoundryRecipe(provider, "autoeat",
+                Ingredient.of(Tags.Items.ARMORS_HELMETS),
+                CustomTags.ROBOT_ARMS, GTItemModules.AUTO_EAT);
+
+        VanillaRecipeHelper.addEquipmentFoundryRecipe(provider, "swim_speed",
+                Ingredient.of(Tags.Items.ARMORS_BOOTS),
+                CustomTags.ELECTRIC_PUMPS, GTItemModules.SWIM_SPEED);
+
+        VanillaRecipeHelper.addEquipmentFoundryRecipe(provider, "step_height",
+                Ingredient.of(Tags.Items.ARMORS_BOOTS),
+                CustomTags.ELECTRIC_PISTONS, GTItemModules.STEP_HEIGHT);
+
+        VanillaRecipeHelper.addEquipmentFoundryRecipe(provider, "jump_boost",
+                Ingredient.of(Tags.Items.ARMORS_LEGGINGS),
+                CustomTags.ELECTRIC_PISTONS, GTItemModules.JUMP_BOOST);
+
+        VanillaRecipeHelper.addEquipmentFoundryRecipe(provider, "battery_modifier",
+                Ingredient.of(Tags.Items.ARMORS),
+                CustomTags.BATTERIES, GTItemModules.BATTERY);
+
+        VanillaRecipeHelper.addEquipmentFoundryRecipe(provider, "night_vision",
+                Ingredient.of(Tags.Items.ARMORS_HELMETS),
+                GTItems.NIGHTVISION_GOGGLES, GTItemModules.NIGHT_VISION);
+
+        VanillaRecipeHelper.addEquipmentFoundryRecipe(provider, "ppe_helmet",
+                Ingredient.of(Tags.Items.ARMORS_HELMETS),
+                GTItems.MASK_FILTER,
+                GTItemModules.PPE);
+
+        VanillaRecipeHelper.addEquipmentFoundryRecipe(provider, "ppe_chestplate",
+                Ingredient.of(Tags.Items.ARMORS_CHESTPLATES),
+                ChemicalHelper.get(plate, PolyvinylChloride),
+                GTItemModules.PPE);
+
+        VanillaRecipeHelper.addEquipmentFoundryRecipe(provider, "ppe_leggings",
+                Ingredient.of(Tags.Items.ARMORS_LEGGINGS),
+                ChemicalHelper.get(plate, PolyvinylChloride),
+                GTItemModules.PPE);
+
+        VanillaRecipeHelper.addEquipmentFoundryRecipe(provider, "ppe_boots",
+                Ingredient.of(Tags.Items.ARMORS_BOOTS),
+                ChemicalHelper.get(plate, PolyvinylChloride),
+                GTItemModules.PPE);
+
+        VanillaRecipeHelper.addEquipmentFoundryRecipe(provider, "sensor",
+                Ingredient.of(Tags.Items.ARMORS_HELMETS),
+                CustomTags.SENSORS, GTItemModules.SENSOR);
+
+        VanillaRecipeHelper.addEquipmentFoundryRecipe(provider, "wireless_charger",
+                Ingredient.of(Tags.Items.ARMORS_CHESTPLATES),
+                CustomTags.SENSORS, GTItemModules.WIRELESS_CHARGER);
+
+        VanillaRecipeHelper.addEquipmentFoundryRecipe(provider, "jetpack",
+                Ingredient.of(Tags.Items.ARMORS_CHESTPLATES),
+                GTItems.ELECTRIC_JETPACK, GTItemModules.JETPACK);
+
+        VanillaRecipeHelper.addEquipmentFoundryRecipe(provider, "advanced_jetpack",
+                Ingredient.of(Tags.Items.ARMORS_CHESTPLATES),
+                GTItems.ELECTRIC_JETPACK_ADVANCED, GTItemModules.ADVANCED_JETPACK);
+
+        VanillaRecipeHelper.addEquipmentFoundryRecipe(provider, "liquid_fuel_jetpack",
+                Ingredient.of(Tags.Items.ARMORS_CHESTPLATES),
+                GTItems.LIQUID_FUEL_JETPACK, GTItemModules.LIQUID_FUEL_JETPACK);
+
+        VanillaRecipeHelper.addEquipmentFoundryRecipe(provider, "creative_flight",
+                Ingredient.of(Tags.Items.ARMORS_CHESTPLATES),
+                GTItems.CREATIVE_FLIGHT_MODULE, GTItemModules.CREATIVE_FLIGHT);
+
+        VanillaRecipeHelper.addEquipmentFoundryRecipe(provider, "fluid_storage",
+                Ingredient.of(Tags.Items.ARMORS_CHESTPLATES),
+                Ingredient.of(CustomTags.FLUID_CONTAINERS), GTItemModules.FLUID_STORAGE);
+    }
+}
diff --git a/src/main/java/com/gregtechceu/gtceu/data/recipe/misc/MetaTileEntityLoader.java b/src/main/java/com/gregtechceu/gtceu/data/recipe/misc/MetaTileEntityLoader.java
index 2825e6ddee7..79fc1e321b1 100644
--- a/src/main/java/com/gregtechceu/gtceu/data/recipe/misc/MetaTileEntityLoader.java
+++ b/src/main/java/com/gregtechceu/gtceu/data/recipe/misc/MetaTileEntityLoader.java
@@ -1194,6 +1194,15 @@ public static void init(Consumer<FinishedRecipe> provider) {
                 new MaterialEntry(TagPrefix.rotor, GTMaterials.StainlessSteel), 'H', HULL.get(HV), 'M',
                 GTItems.ELECTRIC_MOTOR_HV.asStack(), 'C', CustomTags.HV_CIRCUITS);
 
+        VanillaRecipeHelper.addShapedRecipe(provider, true, "equipment_foundry", GTBlocks.EQUIPMENT_FOUNDRY.asStack(),
+                "APA",
+                "AHA",
+                "PCP",
+                'A', GTItems.ROBOT_ARM_LV,
+                'P', new MaterialEntry(TagPrefix.plate, GTMaterials.Steel),
+                'H', GTMachines.HULL[LV].asStack(),
+                'C', GTMachines.STEEL_CRATE.asStack());
+
         if (ConfigHolder.INSTANCE.compat.energy.enableFEConverters) {
             registerMachineRecipe(provider, true, GTMachines.ENERGY_CONVERTER_1A, " WW", "RMC", " WW", 'C', CIRCUIT,
                     'M', HULL, 'W', CABLE, 'R', new MaterialEntry(TagPrefix.cableGtSingle, GTMaterials.RedAlloy));
diff --git a/src/main/java/com/gregtechceu/gtceu/integration/ae2/gui/AEConfigSyncHandler.java b/src/main/java/com/gregtechceu/gtceu/integration/ae2/gui/AEConfigSyncHandler.java
new file mode 100644
index 00000000000..141d777c113
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/integration/ae2/gui/AEConfigSyncHandler.java
@@ -0,0 +1,115 @@
+package com.gregtechceu.gtceu.integration.ae2.gui;
+
+import com.gregtechceu.gtceu.integration.ae2.slot.IConfigurableSlot;
+import com.gregtechceu.gtceu.integration.ae2.slot.IConfigurableSlotList;
+
+import net.minecraft.network.FriendlyByteBuf;
+import net.minecraftforge.api.distmarker.Dist;
+import net.minecraftforge.api.distmarker.OnlyIn;
+
+import appeng.api.stacks.GenericStack;
+import brachy.modularui.value.sync.SyncHandler;
+
+public class AEConfigSyncHandler extends SyncHandler {
+
+    private static final int SYNC_SLOTS = 1;
+
+    private final IConfigurableSlotList slotList;
+    private final int slotCount;
+    private final GenericStack[] cachedConfig;
+    private final GenericStack[] cachedStock;
+
+    @OnlyIn(Dist.CLIENT)
+    private GenericStack[] clientConfig;
+    @OnlyIn(Dist.CLIENT)
+    private GenericStack[] clientStock;
+
+    public AEConfigSyncHandler(IConfigurableSlotList slotList, int slotCount) {
+        this.slotList = slotList;
+        this.slotCount = slotCount;
+        this.cachedConfig = new GenericStack[slotCount];
+        this.cachedStock = new GenericStack[slotCount];
+    }
+
+    @OnlyIn(Dist.CLIENT)
+    public void initClient() {
+        this.clientConfig = new GenericStack[slotCount];
+        this.clientStock = new GenericStack[slotCount];
+    }
+
+    @OnlyIn(Dist.CLIENT)
+    public GenericStack getClientConfig(int index) {
+        return clientConfig != null ? clientConfig[index] : null;
+    }
+
+    @OnlyIn(Dist.CLIENT)
+    public GenericStack getClientStock(int index) {
+        return clientStock != null ? clientStock[index] : null;
+    }
+
+    @Override
+    public void detectAndSendChanges(boolean init) {
+        int changedCount = 0;
+        for (int i = 0; i < slotCount; i++) {
+            IConfigurableSlot slot = slotList.getConfigurableSlot(i);
+            if (!areEqual(slot.getConfig(), cachedConfig[i]) || !areEqual(slot.getStock(), cachedStock[i])) {
+                changedCount++;
+            }
+        }
+
+        if (!init && changedCount == 0) return;
+
+        syncToClient(SYNC_SLOTS, buf -> {
+            for (int i = 0; i < slotCount; i++) {
+                IConfigurableSlot slot = slotList.getConfigurableSlot(i);
+                GenericStack newConfig = slot.getConfig();
+                GenericStack newStock = slot.getStock();
+                boolean changed = init || !areEqual(newConfig, cachedConfig[i]) ||
+                        !areEqual(newStock, cachedStock[i]);
+                buf.writeBoolean(changed);
+                if (changed) {
+                    writeStack(buf, newConfig);
+                    writeStack(buf, newStock);
+                    cachedConfig[i] = copy(newConfig);
+                    cachedStock[i] = copy(newStock);
+                }
+            }
+        });
+    }
+
+    @OnlyIn(Dist.CLIENT)
+    @Override
+    public void readOnClient(int id, FriendlyByteBuf buf) {
+        if (id == SYNC_SLOTS) {
+            if (clientConfig == null) initClient();
+            for (int i = 0; i < slotCount; i++) {
+                if (buf.readBoolean()) {
+                    clientConfig[i] = readStack(buf);
+                    clientStock[i] = readStack(buf);
+                }
+            }
+        }
+    }
+
+    @Override
+    public void readOnServer(int id, FriendlyByteBuf buf) {}
+
+    private static GenericStack copy(GenericStack stack) {
+        return stack != null ? new GenericStack(stack.what(), stack.amount()) : null;
+    }
+
+    private static void writeStack(FriendlyByteBuf buf, GenericStack stack) {
+        buf.writeBoolean(stack != null);
+        if (stack != null) GenericStack.writeBuffer(stack, buf);
+    }
+
+    private static GenericStack readStack(FriendlyByteBuf buf) {
+        return buf.readBoolean() ? GenericStack.readBuffer(buf) : null;
+    }
+
+    private static boolean areEqual(GenericStack a, GenericStack b) {
+        if (a == b) return true;
+        if (a == null || b == null) return false;
+        return a.amount() == b.amount() && a.what().equals(b.what());
+    }
+}
diff --git a/src/main/java/com/gregtechceu/gtceu/integration/ae2/gui/AEConfigWidget.java b/src/main/java/com/gregtechceu/gtceu/integration/ae2/gui/AEConfigWidget.java
new file mode 100644
index 00000000000..23c91b9fb1b
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/integration/ae2/gui/AEConfigWidget.java
@@ -0,0 +1,421 @@
+package com.gregtechceu.gtceu.integration.ae2.gui;
+
+import com.gregtechceu.gtceu.api.gui.GuiTextures;
+import com.gregtechceu.gtceu.common.mui.GTGuiTextures;
+import com.gregtechceu.gtceu.integration.ae2.slot.ExportOnlyAEFluidList;
+import com.gregtechceu.gtceu.integration.ae2.slot.ExportOnlyAEItemList;
+import com.gregtechceu.gtceu.integration.ae2.slot.IConfigurableSlotList;
+
+import net.minecraft.client.Minecraft;
+import net.minecraft.client.gui.GuiGraphics;
+import net.minecraft.world.item.ItemStack;
+import net.minecraftforge.api.distmarker.Dist;
+import net.minecraftforge.api.distmarker.OnlyIn;
+import net.minecraftforge.fluids.FluidStack;
+import net.minecraftforge.fluids.FluidUtil;
+
+import appeng.api.stacks.AEItemKey;
+import appeng.api.stacks.GenericStack;
+import brachy.modularui.api.drawable.IKey;
+import brachy.modularui.api.widget.Interactable;
+import brachy.modularui.integration.emi.EmiStackConverter;
+import brachy.modularui.integration.recipeviewer.handlers.GhostIngredientSlot;
+import brachy.modularui.screen.ModularPanel;
+import brachy.modularui.screen.SecondaryPanel;
+import brachy.modularui.screen.viewport.ModularGuiContext;
+import brachy.modularui.theme.WidgetThemeEntry;
+import brachy.modularui.value.StringValue;
+import brachy.modularui.value.sync.PanelSyncManager;
+import brachy.modularui.widget.Widget;
+import brachy.modularui.widgets.ButtonWidget;
+import brachy.modularui.widgets.layout.Flow;
+import brachy.modularui.widgets.textfield.TextFieldWidget;
+import com.mojang.blaze3d.platform.InputConstants;
+import dev.emi.emi.api.stack.EmiStack;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+
+public class AEConfigWidget extends Widget<AEConfigWidget>
+                            implements Interactable, GhostIngredientSlot<ItemStack> {
+
+    private static final int CELL_SIZE = 18;
+    private static final int PAIR_HEIGHT = CELL_SIZE * 2 + 2;
+
+    private final IConfigurableSlotList slotList;
+    private final int slotCount;
+    private final boolean isFluid;
+    private final int columns;
+    private PanelSyncManager syncManager;
+    private AEConfigSyncHandler configSyncHandler;
+
+    @OnlyIn(Dist.CLIENT)
+    private float lastMouseX;
+    @OnlyIn(Dist.CLIENT)
+    private float lastMouseY;
+    @OnlyIn(Dist.CLIENT)
+    private int editingSlotIndex;
+    @OnlyIn(Dist.CLIENT)
+    private String pendingAmount;
+    @OnlyIn(Dist.CLIENT)
+    private SecondaryPanel amountEditorPanel;
+    @OnlyIn(Dist.CLIENT)
+    private TextFieldWidget amountField;
+
+    public AEConfigWidget(IConfigurableSlotList slotList, int slotCount, boolean isFluid) {
+        this.slotList = slotList;
+        this.slotCount = slotCount;
+        this.isFluid = isFluid;
+        this.columns = 8;
+    }
+
+    public AEConfigWidget syncManager(PanelSyncManager syncManager) {
+        this.syncManager = syncManager;
+        this.configSyncHandler = new AEConfigSyncHandler(slotList, slotCount);
+        syncManager.syncValue("ae_config_display", configSyncHandler);
+        return this;
+    }
+
+    @Override
+    public void onInit() {
+        super.onInit();
+        getContext().getRecipeViewerSettings().addGhostIngredientSlot(this);
+        editingSlotIndex = -1;
+        pendingAmount = "0";
+        amountEditorPanel = new SecondaryPanel(getPanel(), this::buildAmountEditor, true);
+    }
+
+    @OnlyIn(Dist.CLIENT)
+    private ModularPanel<?> buildAmountEditor(ModularPanel<?> parent, net.minecraft.world.entity.player.Player player) {
+        amountField = new TextFieldWidget() {
+
+            @Override
+            public @NotNull Interactable.Result onKeyPressed(int keyCode, int scanCode, int modifiers) {
+                if (isFocused() && (keyCode == InputConstants.KEY_RETURN ||
+                        keyCode == InputConstants.KEY_NUMPADENTER)) {
+                    confirmAmountEdit();
+                    return Interactable.Result.SUCCESS;
+                }
+                return super.onKeyPressed(keyCode, scanCode, modifiers);
+            }
+        };
+        amountField.expanded().heightRel(1f)
+                .value(new StringValue.Dynamic(() -> pendingAmount, val -> pendingAmount = val));
+
+        return new ModularPanel<>("ae_amount_editor")
+                .size(120, 36)
+                .posRel(0.5f, 0.35f)
+                .background(GTGuiTextures.BACKGROUND)
+                .child(ButtonWidget.panelCloseButton())
+                .child(IKey.str("Amount").asWidget().pos(4, 4))
+                .child(Flow.row()
+                        .left(4).right(4).bottom(4).height(18)
+                        .child(amountField)
+                        .child(new ButtonWidget<>()
+                                .size(18, 18)
+                                .overlay(IKey.str("✓"))
+                                .onMousePressed((mouseX, mouseY, button) -> {
+                                    if (button == 0) {
+                                        confirmAmountEdit();
+                                        return true;
+                                    }
+                                    return false;
+                                })));
+    }
+
+    @OnlyIn(Dist.CLIENT)
+    private void confirmAmountEdit() {
+        if (editingSlotIndex < 0 || syncManager == null) return;
+        String text = amountField != null ? amountField.getText() : pendingAmount;
+        long amount = AEGuiHelper.parseAmount(text);
+        if (amount > 0) {
+            String resolved = String.valueOf(amount);
+            pendingAmount = resolved;
+            if (amountField != null) {
+                amountField.setText(resolved);
+            }
+            int slot = editingSlotIndex;
+            syncManager.callSyncedAction("ae_config_amount", buf -> {
+                buf.writeVarInt(slot);
+                buf.writeVarLong(amount);
+            });
+        }
+        editingSlotIndex = -1;
+        amountEditorPanel.closePanel();
+    }
+
+    @OnlyIn(Dist.CLIENT)
+    private void openAmountEditor(int slotIndex) {
+        GenericStack config = configSyncHandler != null ? configSyncHandler.getClientConfig(slotIndex) : null;
+        if (config == null) return;
+        editingSlotIndex = slotIndex;
+        pendingAmount = String.valueOf(config.amount());
+        if (amountEditorPanel.isPanelOpen()) {
+            if (amountField != null) {
+                amountField.setText(pendingAmount);
+            }
+            return;
+        }
+        amountEditorPanel.deleteCachedPanel();
+        amountEditorPanel.openPanel();
+    }
+
+    private boolean isAutoPull() {
+        return slotList instanceof ExportOnlyAEItemList itemList && itemList.isAutoPull() ||
+                slotList instanceof ExportOnlyAEFluidList fluidList && fluidList.isAutoPull();
+    }
+
+    private boolean isStocking() {
+        return slotList instanceof ExportOnlyAEItemList itemList && itemList.isStocking() ||
+                slotList instanceof ExportOnlyAEFluidList fluidList && fluidList.isStocking();
+    }
+
+    private int slotX(int index) {
+        return (index % columns) * CELL_SIZE;
+    }
+
+    private int slotY(int index) {
+        return (index / columns) * PAIR_HEIGHT;
+    }
+
+    @OnlyIn(Dist.CLIENT)
+    @Override
+    public void draw(ModularGuiContext context, WidgetThemeEntry<?> widgetTheme) {
+        GuiGraphics graphics = context.getGraphics();
+        boolean autoPull = isAutoPull();
+        boolean stocking = isStocking();
+        lastMouseX = context.getMouseX();
+        lastMouseY = context.getMouseY();
+
+        for (int i = 0; i < slotCount; i++) {
+            int x = slotX(i);
+            int y = slotY(i);
+            drawSlotBackground(graphics, x, y, autoPull);
+
+            GenericStack config = configSyncHandler != null ? configSyncHandler.getClientConfig(i) : null;
+            GenericStack stock = configSyncHandler != null ? configSyncHandler.getClientStock(i) : null;
+
+            if (config != null) {
+                drawStack(graphics, config, x + 1, y + 1);
+                if (!stocking) AEGuiHelper.drawAmountOverlay(graphics, config.amount(), x + 1, y + 1);
+            }
+
+            if (stock != null) {
+                drawStack(graphics, stock, x + 1, y + 19);
+                AEGuiHelper.drawAmountOverlay(graphics, stock.amount(), x + 1, y + 19);
+            }
+
+            float mouseX = context.getMouseX();
+            float mouseY = context.getMouseY();
+            if (mouseX >= x && mouseX < x + CELL_SIZE && mouseY >= y && mouseY < y + CELL_SIZE) {
+                AEGuiHelper.drawSelectionOverlay(graphics, x + 1, y + 1, 16, 16);
+            } else if (mouseX >= x && mouseX < x + CELL_SIZE && mouseY >= y + CELL_SIZE && mouseY < y + CELL_SIZE * 2) {
+                AEGuiHelper.drawSelectionOverlay(graphics, x + 1, y + 19, 16, 16);
+            }
+        }
+    }
+
+    @OnlyIn(Dist.CLIENT)
+    @Override
+    public void drawForeground(ModularGuiContext context) {
+        float mouseX = context.getMouseX();
+        float mouseY = context.getMouseY();
+        GuiGraphics graphics = context.getGraphics();
+
+        for (int i = 0; i < slotCount; i++) {
+            int x = slotX(i);
+            int y = slotY(i);
+
+            if (mouseX >= x && mouseX < x + CELL_SIZE && mouseY >= y && mouseY < y + CELL_SIZE * 2) {
+                GenericStack tooltipStack = mouseY < y + CELL_SIZE ?
+                        (configSyncHandler != null ? configSyncHandler.getClientConfig(i) : null) :
+                        (configSyncHandler != null ? configSyncHandler.getClientStock(i) : null);
+                if (tooltipStack != null) {
+                    ItemStack wrapped = GenericStack.wrapInItemStack(tooltipStack);
+                    graphics.renderTooltip(Minecraft.getInstance().font, wrapped,
+                            (int) context.getAbsMouseX(), (int) context.getAbsMouseY());
+                }
+            }
+        }
+    }
+
+    @Override
+    public Result onMousePressed(double mouseX, double mouseY, int button) {
+        double localX = mouseX - getArea().x;
+        double localY = mouseY - getArea().y;
+
+        int slotIndex = getSlotAtLocal(localX, localY);
+        if (slotIndex < 0) return Result.IGNORE;
+
+        int y = slotY(slotIndex);
+        boolean overConfig = localY < y + CELL_SIZE;
+        boolean overStock = localY >= y + CELL_SIZE && localY < y + CELL_SIZE * 2;
+
+        if (overConfig && !isAutoPull() && syncManager != null) {
+            if (button == 1) {
+                syncManager.callSyncedAction("ae_config_clear", buf -> buf.writeVarInt(slotIndex));
+                return Result.SUCCESS;
+            } else if (button == 0) {
+                GenericStack config = configSyncHandler != null ? configSyncHandler.getClientConfig(slotIndex) : null;
+                boolean holdingItem = !Minecraft.getInstance().player.containerMenu.getCarried().isEmpty();
+                if (config != null && !holdingItem) {
+                    openAmountEditor(slotIndex);
+                } else {
+                    syncManager.callSyncedAction("ae_config_set", buf -> buf.writeVarInt(slotIndex));
+                }
+                return Result.SUCCESS;
+            }
+        }
+
+        if (overStock && !isStocking() && !isFluid && button == 0 && syncManager != null) {
+            syncManager.callSyncedAction("ae_stock_pickup", buf -> buf.writeVarInt(slotIndex));
+            return Result.SUCCESS;
+        }
+
+        return Result.IGNORE;
+    }
+
+    @Override
+    public boolean onMouseScrolled(double mouseX, double mouseY, double delta) {
+        if (isStocking()) return false;
+
+        double localX = mouseX - getArea().x;
+        double localY = mouseY - getArea().y;
+        int slotIndex = getSlotAtLocal(localX, localY);
+        if (slotIndex < 0) return false;
+
+        if (localY >= slotY(slotIndex) + CELL_SIZE) return false;
+
+        GenericStack config = configSyncHandler != null ? configSyncHandler.getClientConfig(slotIndex) : null;
+        if (config == null || delta == 0) return false;
+
+        long current = config.amount();
+        long next = Interactable.hasControlDown() ?
+                (delta > 0 ? current * 2L : current / 2L) :
+                (delta > 0 ? current + 1L : current - 1L);
+
+        if (next > 0 && next < Integer.MAX_VALUE + 1L && syncManager != null) {
+            syncManager.callSyncedAction("ae_config_amount", buf -> {
+                buf.writeVarInt(slotIndex);
+                buf.writeVarLong(next);
+            });
+            return true;
+        }
+        return false;
+    }
+
+    // --- GhostIngredientSlot ---
+
+    @Override
+    public void setGhostIngredient(@NotNull ItemStack ingredient) {
+        if (isAutoPull() || syncManager == null) return;
+        int slot = findTargetSlot();
+        if (slot < 0) return;
+
+        if (isFluid) {
+            FluidUtil.getFluidContained(ingredient).ifPresent(fluid -> {
+                if (!fluid.isEmpty()) {
+                    syncManager.callSyncedAction("ae_config_set_ghost", buf -> {
+                        buf.writeVarInt(findTargetSlot());
+                        buf.writeBoolean(true);
+                        fluid.writeToPacket(buf);
+                    });
+                }
+            });
+        } else {
+            syncManager.callSyncedAction("ae_config_set_ghost", buf -> {
+                buf.writeVarInt(slot);
+                buf.writeBoolean(false);
+                buf.writeItem(ingredient);
+            });
+        }
+    }
+
+    @Override
+    public boolean ingredientHandlingOverride(Object ingredient) {
+        if (isAutoPull() || syncManager == null) return false;
+        if (!(ingredient instanceof EmiStack emiStack)) return false;
+
+        if (isFluid) {
+            FluidStack fluidStack = EmiStackConverter.FLUID.convertFrom(emiStack);
+            if (fluidStack == null) return false;
+            if (fluidStack.getAmount() <= 0) fluidStack.setAmount(1000);
+            int slot = findTargetSlot();
+            if (slot < 0) return false;
+            FluidStack toSend = fluidStack;
+            syncManager.callSyncedAction("ae_config_set_ghost", buf -> {
+                buf.writeVarInt(slot);
+                buf.writeBoolean(true);
+                toSend.writeToPacket(buf);
+            });
+            return true;
+        } else {
+            ItemStack itemStack = EmiStackConverter.ITEM.convertFrom(emiStack);
+            if (itemStack == null) return false;
+            if (itemStack.getCount() <= 0) itemStack.setCount(1);
+            int slot = findTargetSlot();
+            if (slot < 0) return false;
+            syncManager.callSyncedAction("ae_config_set_ghost", buf -> {
+                buf.writeVarInt(slot);
+                buf.writeBoolean(false);
+                buf.writeItem(itemStack);
+            });
+            return true;
+        }
+    }
+
+    @Override
+    public @Nullable ItemStack castGhostIngredientIfValid(@NotNull Object ingredient) {
+        if (isAutoPull() || !areAncestorsEnabled()) return null;
+        return !isFluid && ingredient instanceof ItemStack itemStack ? itemStack : null;
+    }
+
+    @Override
+    public @NotNull Class<ItemStack> ingredientClass() {
+        return ItemStack.class;
+    }
+
+    // --- Internals ---
+
+    private int findTargetSlot() {
+        int hovered = getSlotAtLocal(lastMouseX, lastMouseY);
+        if (hovered >= 0) return hovered;
+        for (int i = 0; i < slotCount; i++) {
+            if (configSyncHandler == null || configSyncHandler.getClientConfig(i) == null) return i;
+        }
+        return 0;
+    }
+
+    private int getSlotAtLocal(double localX, double localY) {
+        for (int i = 0; i < slotCount; i++) {
+            int x = slotX(i);
+            int y = slotY(i);
+            if (localX >= x && localX < x + CELL_SIZE && localY >= y && localY < y + CELL_SIZE * 2) {
+                return i;
+            }
+        }
+        return -1;
+    }
+
+    @OnlyIn(Dist.CLIENT)
+    private void drawStack(GuiGraphics graphics, GenericStack stack, int x, int y) {
+        if (isFluid) {
+            AEGuiHelper.drawFluid(graphics, stack, x, y);
+        } else if (stack.what() instanceof AEItemKey key) {
+            ItemStack displayStack = new ItemStack(key.getItem());
+            if (key.hasTag()) displayStack.setTag(key.getTag().copy());
+            graphics.renderItem(displayStack, x, y);
+        }
+    }
+
+    @OnlyIn(Dist.CLIENT)
+    private void drawSlotBackground(GuiGraphics graphics, int x, int y, boolean autoPull) {
+        if (autoPull) {
+            GuiTextures.SLOT_DARK.draw(graphics, 0, 0, x, y, 18, 18);
+            GuiTextures.CONFIG_ARROW.draw(graphics, 0, 0, x, y, 18, 18);
+        } else {
+            (isFluid ? GuiTextures.FLUID_SLOT : GuiTextures.SLOT).draw(graphics, 0, 0, x, y, 18, 18);
+            GuiTextures.CONFIG_ARROW_DARK.draw(graphics, 0, 0, x, y, 18, 18);
+        }
+        GuiTextures.SLOT_DARK.draw(graphics, 0, 0, x, y + 18, 18, 18);
+    }
+}
diff --git a/src/main/java/com/gregtechceu/gtceu/integration/ae2/gui/AEGuiHelper.java b/src/main/java/com/gregtechceu/gtceu/integration/ae2/gui/AEGuiHelper.java
new file mode 100644
index 00000000000..8368a0f0432
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/integration/ae2/gui/AEGuiHelper.java
@@ -0,0 +1,158 @@
+package com.gregtechceu.gtceu.integration.ae2.gui;
+
+import com.gregtechceu.gtceu.integration.ae2.utils.AEUtil;
+
+import net.minecraft.client.Minecraft;
+import net.minecraft.client.gui.GuiGraphics;
+import net.minecraft.client.renderer.texture.TextureAtlasSprite;
+import net.minecraft.world.inventory.InventoryMenu;
+import net.minecraftforge.api.distmarker.Dist;
+import net.minecraftforge.api.distmarker.OnlyIn;
+import net.minecraftforge.client.extensions.common.IClientFluidTypeExtensions;
+import net.minecraftforge.fluids.FluidStack;
+
+import appeng.api.stacks.AEFluidKey;
+import appeng.api.stacks.GenericStack;
+import com.mojang.blaze3d.systems.RenderSystem;
+
+import java.util.List;
+
+@OnlyIn(Dist.CLIENT)
+public final class AEGuiHelper {
+
+    private AEGuiHelper() {}
+
+    public static void drawFluid(GuiGraphics graphics, FluidStack fluid, int x, int y, int width, int height) {
+        if (fluid.isEmpty()) return;
+        var renderProps = IClientFluidTypeExtensions.of(fluid.getFluid());
+        var stillTexture = renderProps.getStillTexture(fluid);
+        if (stillTexture == null) return;
+        int color = renderProps.getTintColor(fluid);
+        TextureAtlasSprite sprite = Minecraft.getInstance()
+                .getTextureAtlas(InventoryMenu.BLOCK_ATLAS)
+                .apply(stillTexture);
+        float r = ((color >> 16) & 0xFF) / 255f;
+        float g = ((color >> 8) & 0xFF) / 255f;
+        float b = (color & 0xFF) / 255f;
+        float a = ((color >> 24) & 0xFF) / 255f;
+        if (a == 0) a = 1f;
+        graphics.setColor(r, g, b, a);
+        graphics.blit(x, y, 0, width, height, sprite);
+        graphics.setColor(1f, 1f, 1f, 1f);
+    }
+
+    public static void drawFluid(GuiGraphics graphics, GenericStack stack, int x, int y) {
+        if (stack.what() instanceof AEFluidKey fluidKey) {
+            drawFluid(graphics, AEUtil.toFluidStack(fluidKey, 1), x, y, 16, 16);
+        }
+    }
+
+    public static void drawAmountOverlay(GuiGraphics graphics, long amount, int x, int y) {
+        String text = formatAmount(amount);
+        var font = Minecraft.getInstance().font;
+        graphics.pose().pushPose();
+        graphics.pose().translate(0, 0, 200);
+        graphics.pose().scale(0.5f, 0.5f, 1f);
+        int textX = (x + 16) * 2 - font.width(text);
+        int textY = (y + 16) * 2 - font.lineHeight;
+        graphics.drawString(font, text, textX, textY, 0xFFFFFF, true);
+        graphics.pose().popPose();
+    }
+
+    public static void drawSelectionOverlay(GuiGraphics graphics, int x, int y, int width, int height) {
+        RenderSystem.disableDepthTest();
+        RenderSystem.colorMask(true, true, true, false);
+        graphics.fill(x, y, x + width, y + height, 0x80FFFFFF);
+        RenderSystem.colorMask(true, true, true, true);
+        RenderSystem.enableDepthTest();
+    }
+
+    public static String formatAmountFull(long amount) {
+        return String.format("%,d", amount);
+    }
+
+    public static String formatAmount(long amount) {
+        if (amount >= 1_000_000_000) {
+            return String.format("%.1fG", amount / 1_000_000_000.0);
+        } else if (amount >= 1_000_000) {
+            return String.format("%.1fM", amount / 1_000_000.0);
+        } else if (amount >= 10_000) {
+            return String.format("%.1fK", amount / 1_000.0);
+        }
+        return String.valueOf(amount);
+    }
+
+    public static long parseAmount(String text) {
+        if (text == null || text.isBlank()) return -1;
+        try {
+            long result = Math.max(1, (long) evaluateExpression(text.trim().toLowerCase()));
+            return Math.min(result, Integer.MAX_VALUE);
+        } catch (Exception e) {
+            return -1;
+        }
+    }
+
+    private static double evaluateExpression(String expr) {
+        expr = expr.replaceAll("\\s+", "");
+        List<Double> terms = new java.util.ArrayList<>();
+        List<Character> ops = new java.util.ArrayList<>();
+        int start = 0;
+        for (int i = 0; i <= expr.length(); i++) {
+            if (i == expr.length() || ((expr.charAt(i) == '+' || expr.charAt(i) == '-') && i > start)) {
+                String token = expr.substring(start, i);
+                if (!token.isEmpty()) {
+                    terms.add(evaluateTerm(token));
+                    if (i < expr.length()) {
+                        ops.add(expr.charAt(i));
+                        start = i + 1;
+                    }
+                } else {
+                    start = i;
+                }
+            }
+        }
+        double result = terms.isEmpty() ? 0 : terms.get(0);
+        for (int i = 0; i < ops.size(); i++) {
+            result = ops.get(i) == '+' ? result + terms.get(i + 1) : result - terms.get(i + 1);
+        }
+        return result;
+    }
+
+    private static double evaluateTerm(String term) {
+        List<Double> factors = new java.util.ArrayList<>();
+        List<Character> ops = new java.util.ArrayList<>();
+        int start = 0;
+        for (int i = 0; i <= term.length(); i++) {
+            if (i == term.length() || term.charAt(i) == '*' || term.charAt(i) == '/') {
+                if (i > start) {
+                    factors.add(parseToken(term.substring(start, i)));
+                }
+                if (i < term.length()) {
+                    ops.add(term.charAt(i));
+                }
+                start = i + 1;
+            }
+        }
+        double result = factors.isEmpty() ? 0 : factors.get(0);
+        for (int i = 0; i < ops.size(); i++) {
+            result = ops.get(i) == '*' ? result * factors.get(i + 1) : result / factors.get(i + 1);
+        }
+        return result;
+    }
+
+    private static double parseToken(String token) {
+        token = token.trim();
+        long multiplier = 1;
+        if (token.endsWith("k")) {
+            multiplier = 1_000;
+            token = token.substring(0, token.length() - 1);
+        } else if (token.endsWith("m")) {
+            multiplier = 1_000_000;
+            token = token.substring(0, token.length() - 1);
+        } else if (token.endsWith("g") || token.endsWith("b")) {
+            multiplier = 1_000_000_000;
+            token = token.substring(0, token.length() - 1);
+        }
+        return Double.parseDouble(token) * multiplier;
+    }
+}
diff --git a/src/main/java/com/gregtechceu/gtceu/integration/ae2/gui/AEKeyStorageSyncHandler.java b/src/main/java/com/gregtechceu/gtceu/integration/ae2/gui/AEKeyStorageSyncHandler.java
new file mode 100644
index 00000000000..be435a1d936
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/integration/ae2/gui/AEKeyStorageSyncHandler.java
@@ -0,0 +1,156 @@
+package com.gregtechceu.gtceu.integration.ae2.gui;
+
+import com.gregtechceu.gtceu.integration.ae2.utils.KeyStorage;
+
+import net.minecraft.network.FriendlyByteBuf;
+
+import appeng.api.stacks.AEKey;
+import appeng.api.stacks.GenericStack;
+import brachy.modularui.value.sync.ValueSyncHandler;
+import it.unimi.dsi.fastutil.objects.Object2LongMap;
+import it.unimi.dsi.fastutil.objects.Object2LongOpenHashMap;
+
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.Comparator;
+import java.util.List;
+import java.util.Set;
+import java.util.stream.Collectors;
+
+/**
+ * Syncs AE2 KeyStorage contents as a sorted List of GenericStack.
+ * <p>
+ * The list is maintained in descending amount order. When only amounts change (no keys
+ * added/removed), the list is mutated in place without triggering onValueChanged() —
+ * this avoids DynamicLinkedSyncHandler rebuilding the widget tree. Widgets read from
+ * the list by index each frame, so they pick up the new amounts automatically.
+ * <p>
+ * onValueChanged() only fires on structural changes (keys added or removed), which
+ * triggers DynamicLinkedSyncHandler to rebuild the Grid with the correct widget count.
+ */
+@SuppressWarnings("unchecked")
+public class AEKeyStorageSyncHandler extends ValueSyncHandler<List<GenericStack>> {
+
+    private static final Comparator<GenericStack> BY_AMOUNT_DESC = (a, b) -> Long.compare(b.amount(), a.amount());
+
+    private final KeyStorage serverStorage;
+    private final Object2LongMap<AEKey> cached = new Object2LongOpenHashMap<>();
+    private List<GenericStack> value = Collections.emptyList();
+
+    public AEKeyStorageSyncHandler(KeyStorage storage) {
+        this.serverStorage = storage;
+    }
+
+    @Override
+    public List<GenericStack> getValue() {
+        return value;
+    }
+
+    @Override
+    public void setValue(List<GenericStack> value, boolean setSource, boolean sync) {
+        this.value = value;
+        onValueChanged();
+        if (sync) sync();
+    }
+
+    @Override
+    public boolean updateCacheFromSource(boolean isFirstSync) {
+        if (!isFirstSync && !hasChanged()) return false;
+
+        boolean keysChanged = isFirstSync || keysChanged();
+
+        cached.clear();
+        cached.putAll(serverStorage.storage);
+
+        if (keysChanged) {
+            rebuildList();
+            onValueChanged();
+        } else {
+            updateAmountsInPlace();
+        }
+        sync();
+        return true;
+    }
+
+    private boolean hasChanged() {
+        if (cached.size() != serverStorage.storage.size()) return true;
+        for (var entry : serverStorage.storage.object2LongEntrySet()) {
+            if (cached.getOrDefault(entry.getKey(), 0) != entry.getLongValue()) return true;
+        }
+        return false;
+    }
+
+    private boolean keysChanged() {
+        if (cached.size() != serverStorage.storage.size()) return true;
+        Set<AEKey> currentKeys = serverStorage.storage.keySet();
+        for (AEKey key : cached.keySet()) {
+            if (!currentKeys.contains(key)) return true;
+        }
+        return false;
+    }
+
+    private void rebuildList() {
+        List<GenericStack> list = new ArrayList<>();
+        for (var entry : serverStorage.storage.object2LongEntrySet()) {
+            list.add(new GenericStack(entry.getKey(), entry.getLongValue()));
+        }
+        list.sort(BY_AMOUNT_DESC);
+        this.value = list;
+    }
+
+    private void updateAmountsInPlace() {
+        // Replace entries with updated amounts, re-sort
+        for (int i = 0; i < value.size(); i++) {
+            GenericStack old = value.get(i);
+            long newAmount = serverStorage.storage.getOrDefault(old.what(), 0);
+            if (old.amount() != newAmount) {
+                value.set(i, new GenericStack(old.what(), newAmount));
+            }
+        }
+        value.sort(BY_AMOUNT_DESC);
+    }
+
+    @Override
+    public void write(FriendlyByteBuf buffer) {
+        buffer.writeVarInt(value.size());
+        for (GenericStack stack : value) {
+            GenericStack.writeBuffer(stack, buffer);
+        }
+    }
+
+    @Override
+    public void read(FriendlyByteBuf buffer) {
+        int size = buffer.readVarInt();
+
+        List<GenericStack> incoming = new ArrayList<>(size);
+        for (int i = 0; i < size; i++) {
+            GenericStack stack = GenericStack.readBuffer(buffer);
+            if (stack != null) incoming.add(stack);
+        }
+        incoming.sort(BY_AMOUNT_DESC);
+
+        boolean structural = structurallyDifferent(incoming);
+        this.value = incoming;
+
+        if (structural) {
+            onValueChanged();
+        }
+    }
+
+    private boolean structurallyDifferent(List<GenericStack> incoming) {
+        if (value.size() != incoming.size()) return true;
+        Set<AEKey> oldKeys = value.stream().map(GenericStack::what).collect(Collectors.toSet());
+        Set<AEKey> newKeys = incoming.stream().map(GenericStack::what).collect(Collectors.toSet());
+        return !oldKeys.equals(newKeys);
+    }
+
+    @Override
+    public void notifyUpdate() {
+        updateCacheFromSource(true);
+    }
+
+    @Override
+    public Class<List<GenericStack>> getValueType() {
+        return (Class<List<GenericStack>>) (Object) List.class;
+    }
+}
diff --git a/src/main/java/com/gregtechceu/gtceu/integration/ae2/gui/AEStackDisplayWidget.java b/src/main/java/com/gregtechceu/gtceu/integration/ae2/gui/AEStackDisplayWidget.java
new file mode 100644
index 00000000000..47ddeb52333
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/integration/ae2/gui/AEStackDisplayWidget.java
@@ -0,0 +1,78 @@
+package com.gregtechceu.gtceu.integration.ae2.gui;
+
+import com.gregtechceu.gtceu.api.gui.GuiTextures;
+
+import net.minecraft.ChatFormatting;
+import net.minecraft.client.Minecraft;
+import net.minecraft.network.chat.Component;
+import net.minecraftforge.api.distmarker.Dist;
+import net.minecraftforge.api.distmarker.OnlyIn;
+
+import appeng.api.stacks.AEFluidKey;
+import appeng.api.stacks.AEItemKey;
+import appeng.api.stacks.GenericStack;
+import brachy.modularui.api.ITheme;
+import brachy.modularui.screen.viewport.ModularGuiContext;
+import brachy.modularui.theme.WidgetThemeEntry;
+import brachy.modularui.widget.Widget;
+
+import java.util.List;
+
+/**
+ * 18x18 display widget for a single AE2 GenericStack. Reads from a shared mutable list
+ * by index so that amount updates don't require widget rebuilds.
+ */
+public class AEStackDisplayWidget extends Widget<AEStackDisplayWidget> {
+
+    private final List<GenericStack> source;
+    private final int index;
+
+    public AEStackDisplayWidget(List<GenericStack> source, int index) {
+        this.source = source;
+        this.index = index;
+        size(18);
+    }
+
+    private GenericStack getStack() {
+        return index < source.size() ? source.get(index) : null;
+    }
+
+    @Override
+    protected WidgetThemeEntry<?> getWidgetThemeInternal(ITheme theme) {
+        return theme.getItemSlotTheme();
+    }
+
+    @OnlyIn(Dist.CLIENT)
+    @Override
+    public void draw(ModularGuiContext context, WidgetThemeEntry<?> widgetTheme) {
+        var graphics = context.getGraphics();
+        GuiTextures.SLOT_DARK.draw(graphics, 0, 0, 0, 0, 18, 18);
+
+        GenericStack stack = getStack();
+        if (stack == null) return;
+
+        if (stack.what() instanceof AEItemKey itemKey) {
+            graphics.renderItem(itemKey.toStack(1), 1, 1);
+        } else if (stack.what() instanceof AEFluidKey) {
+            AEGuiHelper.drawFluid(graphics, stack, 1, 1);
+        }
+        AEGuiHelper.drawAmountOverlay(graphics, stack.amount(), 1, 1);
+    }
+
+    @OnlyIn(Dist.CLIENT)
+    @Override
+    public void drawForeground(ModularGuiContext context) {
+        if (isHovering()) {
+            GenericStack stack = getStack();
+            if (stack == null) return;
+
+            AEGuiHelper.drawSelectionOverlay(context.getGraphics(), 1, 1, 16, 16);
+            context.getGraphics().renderComponentTooltip(
+                    Minecraft.getInstance().font,
+                    List.of(stack.what().getDisplayName(),
+                            Component.literal("x" + AEGuiHelper.formatAmountFull(stack.amount()))
+                                    .withStyle(ChatFormatting.GRAY)),
+                    (int) context.getAbsMouseX(), (int) context.getAbsMouseY());
+        }
+    }
+}
diff --git a/src/main/java/com/gregtechceu/gtceu/integration/ae2/gui/ScrollPreservingGrid.java b/src/main/java/com/gregtechceu/gtceu/integration/ae2/gui/ScrollPreservingGrid.java
new file mode 100644
index 00000000000..17a0f985adf
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/integration/ae2/gui/ScrollPreservingGrid.java
@@ -0,0 +1,41 @@
+package com.gregtechceu.gtceu.integration.ae2.gui;
+
+import brachy.modularui.widget.scroll.ScrollData;
+import brachy.modularui.widgets.layout.Grid;
+
+/**
+ * Grid subclass that preserves scroll position across rebuilds.
+ * When used inside a DynamicSyncedWidget, the old Grid is disposed and a new one created
+ * each time the data changes. This class saves the scroll offset on dispose and restores
+ * it after the new instance finishes layout.
+ */
+public class ScrollPreservingGrid extends Grid {
+
+    private final int[] scrollHolder;
+    private boolean shouldRestore = true;
+
+    public ScrollPreservingGrid(int[] scrollHolder) {
+        this.scrollHolder = scrollHolder;
+    }
+
+    @Override
+    public void postResize() {
+        super.postResize();
+        if (shouldRestore) {
+            ScrollData data = getScrollArea().getScrollY();
+            if (data != null) {
+                data.scrollTo(getScrollArea(), scrollHolder[0]);
+            }
+            shouldRestore = false;
+        }
+    }
+
+    @Override
+    public void dispose() {
+        ScrollData data = getScrollArea().getScrollY();
+        if (data != null) {
+            scrollHolder[0] = data.getScroll();
+        }
+        super.dispose();
+    }
+}
diff --git a/src/main/java/com/gregtechceu/gtceu/integration/ae2/gui/widget/AEFluidConfigWidget.java b/src/main/java/com/gregtechceu/gtceu/integration/ae2/gui/widget/AEFluidConfigWidget.java
deleted file mode 100644
index 2ebe1b3164e..00000000000
--- a/src/main/java/com/gregtechceu/gtceu/integration/ae2/gui/widget/AEFluidConfigWidget.java
+++ /dev/null
@@ -1,39 +0,0 @@
-package com.gregtechceu.gtceu.integration.ae2.gui.widget;
-
-import com.gregtechceu.gtceu.integration.ae2.gui.widget.slot.AEFluidConfigSlotWidget;
-import com.gregtechceu.gtceu.integration.ae2.slot.ExportOnlyAEFluidList;
-import com.gregtechceu.gtceu.integration.ae2.slot.ExportOnlyAEFluidSlot;
-import com.gregtechceu.gtceu.integration.ae2.slot.IConfigurableSlot;
-
-import appeng.api.stacks.GenericStack;
-
-public class AEFluidConfigWidget extends ConfigWidget {
-
-    private final ExportOnlyAEFluidList fluidList;
-
-    public AEFluidConfigWidget(int x, int y, ExportOnlyAEFluidList list) {
-        super(x, y, list.getInventory(), list.isStocking());
-        this.fluidList = list;
-    }
-
-    @Override
-    void init() {
-        int line;
-        this.displayList = new IConfigurableSlot[this.config.length];
-        this.cached = new IConfigurableSlot[this.config.length];
-        for (int index = 0; index < this.config.length; index++) {
-            this.displayList[index] = new ExportOnlyAEFluidSlot();
-            this.cached[index] = new ExportOnlyAEFluidSlot();
-            line = index / 8;
-            this.addWidget(new AEFluidConfigSlotWidget((index - line * 8) * 18, line * (18 * 2 + 2), this, index));
-        }
-    }
-
-    public boolean hasStackInConfig(GenericStack stack) {
-        return fluidList.hasStackInConfig(stack, true);
-    }
-
-    public boolean isAutoPull() {
-        return fluidList.isAutoPull();
-    }
-}
diff --git a/src/main/java/com/gregtechceu/gtceu/integration/ae2/gui/widget/AEItemConfigWidget.java b/src/main/java/com/gregtechceu/gtceu/integration/ae2/gui/widget/AEItemConfigWidget.java
deleted file mode 100644
index 167afbb34a5..00000000000
--- a/src/main/java/com/gregtechceu/gtceu/integration/ae2/gui/widget/AEItemConfigWidget.java
+++ /dev/null
@@ -1,39 +0,0 @@
-package com.gregtechceu.gtceu.integration.ae2.gui.widget;
-
-import com.gregtechceu.gtceu.integration.ae2.gui.widget.slot.AEItemConfigSlotWidget;
-import com.gregtechceu.gtceu.integration.ae2.slot.ExportOnlyAEItemList;
-import com.gregtechceu.gtceu.integration.ae2.slot.ExportOnlyAEItemSlot;
-import com.gregtechceu.gtceu.integration.ae2.slot.IConfigurableSlot;
-
-import appeng.api.stacks.GenericStack;
-
-public class AEItemConfigWidget extends ConfigWidget {
-
-    private final ExportOnlyAEItemList itemList;
-
-    public AEItemConfigWidget(int x, int y, ExportOnlyAEItemList list) {
-        super(x, y, list.getInventory(), list.isStocking());
-        this.itemList = list;
-    }
-
-    @Override
-    void init() {
-        int line;
-        this.displayList = new IConfigurableSlot[this.config.length];
-        this.cached = new IConfigurableSlot[this.config.length];
-        for (int index = 0; index < this.config.length; index++) {
-            this.displayList[index] = new ExportOnlyAEItemSlot();
-            this.cached[index] = new ExportOnlyAEItemSlot();
-            line = index / 8;
-            this.addWidget(new AEItemConfigSlotWidget((index - line * 8) * 18, line * (18 * 2 + 2), this, index));
-        }
-    }
-
-    public boolean hasStackInConfig(GenericStack stack) {
-        return itemList.hasStackInConfig(stack, true);
-    }
-
-    public boolean isAutoPull() {
-        return itemList.isAutoPull();
-    }
-}
diff --git a/src/main/java/com/gregtechceu/gtceu/integration/ae2/gui/widget/AETextInputButtonWidget.java b/src/main/java/com/gregtechceu/gtceu/integration/ae2/gui/widget/AETextInputButtonWidget.java
deleted file mode 100644
index 2baeffb5d8b..00000000000
--- a/src/main/java/com/gregtechceu/gtceu/integration/ae2/gui/widget/AETextInputButtonWidget.java
+++ /dev/null
@@ -1,91 +0,0 @@
-package com.gregtechceu.gtceu.integration.ae2.gui.widget;
-
-import com.gregtechceu.gtceu.api.gui.GuiTextures;
-import com.gregtechceu.gtceu.api.gui.widget.ToggleButtonWidget;
-
-import com.lowdragmc.lowdraglib.gui.texture.GuiTextureGroup;
-import com.lowdragmc.lowdraglib.gui.texture.TextTexture;
-import com.lowdragmc.lowdraglib.gui.widget.TextFieldWidget;
-import com.lowdragmc.lowdraglib.gui.widget.Widget;
-import com.lowdragmc.lowdraglib.gui.widget.WidgetGroup;
-import com.lowdragmc.lowdraglib.utils.Position;
-import com.lowdragmc.lowdraglib.utils.Size;
-
-import net.minecraft.network.chat.Component;
-
-import lombok.Getter;
-import lombok.Setter;
-import lombok.experimental.Accessors;
-
-import java.util.function.Consumer;
-
-@Accessors(chain = true)
-public class AETextInputButtonWidget extends WidgetGroup {
-
-    @Setter
-    private Consumer<String> onConfirm;
-
-    @Getter
-    @Setter
-    private String text = "";
-
-    private Component[] hoverTexts = new Component[0];
-
-    @Getter
-    private boolean isInputting;
-
-    private Widget textField;
-
-    public AETextInputButtonWidget() {}
-
-    public AETextInputButtonWidget(int x, int y, int width, int height) {
-        super(x, y, width, height);
-    }
-
-    public AETextInputButtonWidget(Position position) {
-        super(position);
-    }
-
-    public AETextInputButtonWidget(Position position, Size size) {
-        super(position, size);
-    }
-
-    public AETextInputButtonWidget setButtonTooltips(Component... tooltipTexts) {
-        this.hoverTexts = tooltipTexts;
-        return this;
-    }
-
-    @Override
-    public void initWidget() {
-        super.initWidget();
-        this.textField = new TextFieldWidget(
-                0,
-                0,
-                getSizeWidth() - getSizeHeight() - 2,
-                getSizeHeight(),
-                this::getText,
-                this::setText).setActive(false).setVisible(false);
-        this.addWidget(new ToggleButtonWidget(
-                getSizeWidth() - getSizeHeight(),
-                0,
-                getSizeHeight(),
-                getSizeHeight(),
-                this::isInputting,
-                pressed -> {
-                    isInputting = pressed;
-                    if (pressed) {
-                        textField.setActive(true);
-                        textField.setVisible(true);
-                    } else {
-                        onConfirm.accept(text);
-                        textField.setActive(false);
-                        textField.setVisible(false);
-                    }
-                })
-                .setTexture(
-                        new GuiTextureGroup(GuiTextures.VANILLA_BUTTON, new TextTexture("✎")),
-                        new GuiTextureGroup(GuiTextures.VANILLA_BUTTON, new TextTexture("✔")))
-                .setHoverTooltips(hoverTexts));
-        this.addWidget(textField);
-    }
-}
diff --git a/src/main/java/com/gregtechceu/gtceu/integration/ae2/gui/widget/AmountSetWidget.java b/src/main/java/com/gregtechceu/gtceu/integration/ae2/gui/widget/AmountSetWidget.java
deleted file mode 100644
index 1139bd36c2f..00000000000
--- a/src/main/java/com/gregtechceu/gtceu/integration/ae2/gui/widget/AmountSetWidget.java
+++ /dev/null
@@ -1,87 +0,0 @@
-package com.gregtechceu.gtceu.integration.ae2.gui.widget;
-
-import com.gregtechceu.gtceu.api.gui.GuiTextures;
-import com.gregtechceu.gtceu.integration.ae2.slot.IConfigurableSlot;
-
-import com.lowdragmc.lowdraglib.gui.widget.TextFieldWidget;
-import com.lowdragmc.lowdraglib.gui.widget.Widget;
-import com.lowdragmc.lowdraglib.utils.Position;
-
-import net.minecraft.client.gui.GuiGraphics;
-import net.minecraft.network.FriendlyByteBuf;
-import net.minecraftforge.api.distmarker.Dist;
-import net.minecraftforge.api.distmarker.OnlyIn;
-
-import appeng.api.stacks.GenericStack;
-import lombok.Getter;
-import org.jetbrains.annotations.NotNull;
-
-import static com.lowdragmc.lowdraglib.gui.util.DrawerHelper.drawStringSized;
-
-public class AmountSetWidget extends Widget {
-
-    private int index = -1;
-    @Getter
-    private final TextFieldWidget amountText;
-    private final ConfigWidget parentWidget;
-
-    public AmountSetWidget(int x, int y, ConfigWidget widget) {
-        super(x, y, 80, 30);
-        this.parentWidget = widget;
-        this.amountText = new TextFieldWidget(x + 3, y + 12, 65, 13, this::getAmountStr, this::setNewAmount)
-                .setNumbersOnly(0, Integer.MAX_VALUE)
-                .setMaxStringLength(10);
-    }
-
-    @OnlyIn(Dist.CLIENT)
-    public void setSlotIndexClient(int slotIndex) {
-        this.index = slotIndex;
-        writeClientAction(0, buf -> buf.writeVarInt(this.index));
-    }
-
-    public void setSlotIndex(int slotIndex) {
-        this.index = slotIndex;
-    }
-
-    public String getAmountStr() {
-        if (this.index < 0) {
-            return "0";
-        }
-        IConfigurableSlot slot = this.parentWidget.getConfig(this.index);
-        if (slot.getConfig() != null) {
-            return String.valueOf(slot.getConfig().amount());
-        }
-        return "0";
-    }
-
-    public void setNewAmount(String amount) {
-        try {
-            long newAmount = Long.parseLong(amount);
-            if (this.index < 0) {
-                return;
-            }
-            IConfigurableSlot slot = this.parentWidget.getConfig(this.index);
-            if (newAmount > 0 && slot.getConfig() != null) {
-                slot.setConfig(new GenericStack(slot.getConfig().what(), newAmount));
-            }
-        } catch (NumberFormatException ignore) {}
-    }
-
-    @Override
-    public void handleClientAction(int id, FriendlyByteBuf buffer) {
-        super.handleClientAction(id, buffer);
-        if (id == 0) {
-            this.index = buffer.readVarInt();
-        }
-    }
-
-    @OnlyIn(Dist.CLIENT)
-    @Override
-    public void drawInBackground(@NotNull GuiGraphics graphics, int mouseX, int mouseY, float partialTicks) {
-        super.drawInBackground(graphics, mouseX, mouseY, partialTicks);
-        Position position = getPosition();
-        GuiTextures.BACKGROUND.draw(graphics, mouseX, mouseY, position.x, position.y, 80, 30);
-        drawStringSized(graphics, "Amount", position.x + 3, position.y + 3, 0x404040, false, 1f, false);
-        GuiTextures.DISPLAY.draw(graphics, mouseX, mouseY, position.x + 3, position.y + 11, 65, 14);
-    }
-}
diff --git a/src/main/java/com/gregtechceu/gtceu/integration/ae2/gui/widget/ConfigWidget.java b/src/main/java/com/gregtechceu/gtceu/integration/ae2/gui/widget/ConfigWidget.java
deleted file mode 100644
index 69198688a73..00000000000
--- a/src/main/java/com/gregtechceu/gtceu/integration/ae2/gui/widget/ConfigWidget.java
+++ /dev/null
@@ -1,174 +0,0 @@
-package com.gregtechceu.gtceu.integration.ae2.gui.widget;
-
-import com.gregtechceu.gtceu.integration.ae2.gui.widget.slot.AEConfigSlotWidget;
-import com.gregtechceu.gtceu.integration.ae2.slot.IConfigurableSlot;
-
-import com.lowdragmc.lowdraglib.gui.widget.Widget;
-import com.lowdragmc.lowdraglib.gui.widget.WidgetGroup;
-import com.lowdragmc.lowdraglib.utils.Position;
-import com.lowdragmc.lowdraglib.utils.Size;
-
-import net.minecraft.network.FriendlyByteBuf;
-import net.minecraftforge.api.distmarker.Dist;
-import net.minecraftforge.api.distmarker.OnlyIn;
-
-import appeng.api.stacks.GenericStack;
-import it.unimi.dsi.fastutil.ints.Int2ObjectMap;
-import it.unimi.dsi.fastutil.ints.Int2ObjectOpenHashMap;
-import lombok.Getter;
-
-public abstract class ConfigWidget extends WidgetGroup {
-
-    protected final IConfigurableSlot[] config;
-    protected IConfigurableSlot[] cached;
-    protected Int2ObjectMap<IConfigurableSlot> changeMap = new Int2ObjectOpenHashMap<>();
-    protected IConfigurableSlot[] displayList;
-    protected AmountSetWidget amountSetWidget;
-    protected final static int UPDATE_ID = 1000;
-
-    @Getter
-    protected final boolean isStocking;
-
-    public ConfigWidget(int x, int y, IConfigurableSlot[] config, boolean isStocking) {
-        super(new Position(x, y), new Size(config.length / 2 * 18, 18 * 4 + 2));
-        this.isStocking = isStocking;
-        this.config = config;
-        this.init();
-        this.amountSetWidget = new AmountSetWidget(31, -50, this);
-        this.addWidget(this.amountSetWidget);
-        this.addWidget(this.amountSetWidget.getAmountText());
-        this.amountSetWidget.setVisible(false);
-        this.amountSetWidget.getAmountText().setVisible(false);
-    }
-
-    @OnlyIn(Dist.CLIENT)
-    public void enableAmountClient(int slotIndex) {
-        this.amountSetWidget.setSlotIndexClient(slotIndex);
-        this.amountSetWidget.setVisible(true);
-        this.amountSetWidget.getAmountText().setVisible(true);
-    }
-
-    @OnlyIn(Dist.CLIENT)
-    public void disableAmountClient() {
-        this.amountSetWidget.setSlotIndexClient(-1);
-        this.amountSetWidget.setVisible(false);
-        this.amountSetWidget.getAmountText().setVisible(false);
-    }
-
-    public void enableAmount(int slotIndex) {
-        this.amountSetWidget.setSlotIndex(slotIndex);
-        this.amountSetWidget.setVisible(true);
-        this.amountSetWidget.getAmountText().setVisible(true);
-    }
-
-    public void disableAmount() {
-        this.amountSetWidget.setSlotIndex(-1);
-        this.amountSetWidget.setVisible(false);
-        this.amountSetWidget.getAmountText().setVisible(false);
-    }
-
-    @OnlyIn(Dist.CLIENT)
-    @Override
-    public boolean mouseClicked(double mouseX, double mouseY, int button) {
-        if (this.amountSetWidget.isVisible()) {
-            if (this.amountSetWidget.getAmountText().mouseClicked(mouseX, mouseY, button)) {
-                return true;
-            }
-        }
-        for (Widget w : this.widgets) {
-            if (w instanceof AEConfigSlotWidget slot) {
-                slot.setSelect(false);
-            }
-        }
-        this.disableAmountClient();
-        return super.mouseClicked(mouseX, mouseY, button);
-    }
-
-    abstract void init();
-
-    public abstract boolean hasStackInConfig(GenericStack stack);
-
-    public abstract boolean isAutoPull();
-
-    @Override
-    public void detectAndSendChanges() {
-        super.detectAndSendChanges();
-        this.changeMap.clear();
-        for (int index = 0; index < this.config.length; index++) {
-            IConfigurableSlot newSlot = this.config[index];
-            IConfigurableSlot oldSlot = this.cached[index];
-            GenericStack nConfig = newSlot.getConfig();
-            GenericStack nStock = newSlot.getStock();
-            GenericStack oConfig = oldSlot.getConfig();
-            GenericStack oStock = oldSlot.getStock();
-            if (!areAEStackCountsEqual(nConfig, oConfig) || !areAEStackCountsEqual(nStock, oStock)) {
-                this.changeMap.put(index, newSlot.copy());
-                this.cached[index] = this.config[index].copy();
-                this.gui.holder.markAsDirty();
-            }
-        }
-        if (!this.changeMap.isEmpty()) {
-            this.writeUpdateInfo(UPDATE_ID, buf -> {
-                buf.writeVarInt(this.changeMap.size());
-                for (int index : this.changeMap.keySet()) {
-                    GenericStack sConfig = this.changeMap.get(index).getConfig();
-                    GenericStack sStock = this.changeMap.get(index).getStock();
-                    buf.writeVarInt(index);
-                    if (sConfig != null) {
-                        buf.writeBoolean(true);
-                        GenericStack.writeBuffer(sConfig, buf);
-                    } else {
-                        buf.writeBoolean(false);
-                    }
-                    if (sStock != null) {
-                        buf.writeBoolean(true);
-                        GenericStack.writeBuffer(sStock, buf);
-                    } else {
-                        buf.writeBoolean(false);
-                    }
-                }
-            });
-        }
-    }
-
-    @OnlyIn(Dist.CLIENT)
-    @Override
-    public void readUpdateInfo(int id, FriendlyByteBuf buffer) {
-        super.readUpdateInfo(id, buffer);
-        if (id == UPDATE_ID) {
-            int size = buffer.readVarInt();
-            for (int i = 0; i < size; i++) {
-                int index = buffer.readVarInt();
-                IConfigurableSlot slot = this.displayList[index];
-                if (buffer.readBoolean()) {
-                    slot.setConfig(GenericStack.readBuffer(buffer));
-                } else {
-                    slot.setConfig(null);
-                }
-                if (buffer.readBoolean()) {
-                    slot.setStock(GenericStack.readBuffer(buffer));
-                } else {
-                    slot.setStock(null);
-                }
-            }
-        }
-    }
-
-    public final IConfigurableSlot getConfig(int index) {
-        return this.config[index];
-    }
-
-    public final IConfigurableSlot getDisplay(int index) {
-        return this.displayList[index];
-    }
-
-    protected final boolean areAEStackCountsEqual(GenericStack s1, GenericStack s2) {
-        if (s2 == s1) {
-            return true;
-        }
-        if (s1 != null && s2 != null) {
-            return s1.amount() == s2.amount() && s1.what().matches(s2);
-        }
-        return false;
-    }
-}
diff --git a/src/main/java/com/gregtechceu/gtceu/integration/ae2/gui/widget/list/AEFluidDisplayWidget.java b/src/main/java/com/gregtechceu/gtceu/integration/ae2/gui/widget/list/AEFluidDisplayWidget.java
deleted file mode 100644
index 08dd66ce998..00000000000
--- a/src/main/java/com/gregtechceu/gtceu/integration/ae2/gui/widget/list/AEFluidDisplayWidget.java
+++ /dev/null
@@ -1,83 +0,0 @@
-package com.gregtechceu.gtceu.integration.ae2.gui.widget.list;
-
-import com.gregtechceu.gtceu.api.gui.GuiTextures;
-import com.gregtechceu.gtceu.client.TooltipsHandler;
-import com.gregtechceu.gtceu.utils.GTMath;
-
-import com.lowdragmc.lowdraglib.gui.util.DrawerHelper;
-import com.lowdragmc.lowdraglib.gui.widget.Widget;
-import com.lowdragmc.lowdraglib.side.fluid.forge.FluidHelperImpl;
-import com.lowdragmc.lowdraglib.utils.Position;
-import com.lowdragmc.lowdraglib.utils.Size;
-
-import net.minecraft.client.Minecraft;
-import net.minecraft.client.gui.GuiGraphics;
-import net.minecraft.network.chat.Component;
-import net.minecraft.world.item.TooltipFlag;
-import net.minecraftforge.fluids.FluidStack;
-
-import appeng.api.stacks.AEFluidKey;
-import appeng.api.stacks.GenericStack;
-import org.jetbrains.annotations.NotNull;
-
-import java.util.ArrayList;
-import java.util.List;
-import java.util.Optional;
-
-import static com.gregtechceu.gtceu.integration.ae2.gui.widget.slot.AEConfigSlotWidget.drawSelectionOverlay;
-import static com.lowdragmc.lowdraglib.gui.util.DrawerHelper.drawText;
-
-/**
- * Display a certain {@link FluidStack} element.
- */
-public class AEFluidDisplayWidget extends Widget {
-
-    private final AEListGridWidget gridWidget;
-    private final int index;
-
-    public AEFluidDisplayWidget(int x, int y, AEListGridWidget gridWidget, int index) {
-        super(new Position(x, y), new Size(18, 18));
-        this.gridWidget = gridWidget;
-        this.index = index;
-    }
-
-    @Override
-    public void drawInBackground(@NotNull GuiGraphics graphics, int mouseX, int mouseY, float partialTicks) {
-        super.drawInBackground(graphics, mouseX, mouseY, partialTicks);
-        Position position = getPosition();
-        GenericStack fluid = this.gridWidget.getAt(this.index);
-        GuiTextures.FLUID_SLOT.draw(graphics, mouseX, mouseY, position.x, position.y, 18, 18);
-        GuiTextures.NUMBER_BACKGROUND.draw(graphics, mouseX, mouseY, position.x + 18, position.y, 140, 18);
-        int stackX = position.x + 1;
-        int stackY = position.y + 1;
-        if (fluid != null) {
-            FluidStack fluidStack = fluid.what() instanceof AEFluidKey key ?
-                    new FluidStack(key.getFluid(), GTMath.saturatedCast(fluid.amount()), key.getTag()) :
-                    FluidStack.EMPTY;
-            DrawerHelper.drawFluidForGui(graphics, FluidHelperImpl.toFluidStack(fluidStack), fluid.amount(), stackX,
-                    stackY, 16, 16);
-            String amountStr = String.format("x%,d", fluid.amount());
-            drawText(graphics, amountStr, stackX + 20, stackY + 5, 1, 0xFFFFFFFF);
-        }
-        if (isMouseOverElement(mouseX, mouseY)) {
-            drawSelectionOverlay(graphics, stackX, stackY, 16, 16);
-        }
-    }
-
-    @Override
-    public void drawInForeground(@NotNull GuiGraphics graphics, int mouseX, int mouseY, float partialTicks) {
-        if (isMouseOverElement(mouseX, mouseY)) {
-            GenericStack fluid = this.gridWidget.getAt(this.index);
-            if (fluid != null) {
-                FluidStack fluidStack = fluid.what() instanceof AEFluidKey key ?
-                        new FluidStack(key.getFluid(), GTMath.saturatedCast(fluid.amount()), key.getTag()) :
-                        FluidStack.EMPTY;
-                List<Component> tooltips = new ArrayList<>();
-                tooltips.add(fluidStack.getDisplayName());
-                tooltips.add(Component.literal(String.format("%,d mB", fluid.amount())));
-                TooltipsHandler.appendFluidTooltips(fluidStack, tooltips::add, TooltipFlag.NORMAL);
-                graphics.renderTooltip(Minecraft.getInstance().font, tooltips, Optional.empty(), mouseX, mouseY);
-            }
-        }
-    }
-}
diff --git a/src/main/java/com/gregtechceu/gtceu/integration/ae2/gui/widget/list/AEItemDisplayWidget.java b/src/main/java/com/gregtechceu/gtceu/integration/ae2/gui/widget/list/AEItemDisplayWidget.java
deleted file mode 100644
index 3c28a821248..00000000000
--- a/src/main/java/com/gregtechceu/gtceu/integration/ae2/gui/widget/list/AEItemDisplayWidget.java
+++ /dev/null
@@ -1,65 +0,0 @@
-package com.gregtechceu.gtceu.integration.ae2.gui.widget.list;
-
-import com.gregtechceu.gtceu.api.gui.GuiTextures;
-
-import com.lowdragmc.lowdraglib.gui.widget.Widget;
-import com.lowdragmc.lowdraglib.utils.Position;
-import com.lowdragmc.lowdraglib.utils.Size;
-
-import net.minecraft.client.Minecraft;
-import net.minecraft.client.gui.GuiGraphics;
-import net.minecraft.world.item.ItemStack;
-
-import appeng.api.stacks.AEItemKey;
-import appeng.api.stacks.GenericStack;
-import org.jetbrains.annotations.NotNull;
-
-import static com.gregtechceu.gtceu.integration.ae2.gui.widget.slot.AEConfigSlotWidget.drawSelectionOverlay;
-import static com.lowdragmc.lowdraglib.gui.util.DrawerHelper.drawItemStack;
-import static com.lowdragmc.lowdraglib.gui.util.DrawerHelper.drawText;
-
-/**
- * Display a certain {@link appeng.api.stacks.GenericStack} element.
- */
-public class AEItemDisplayWidget extends Widget {
-
-    private final AEListGridWidget gridWidget;
-    private final int index;
-
-    public AEItemDisplayWidget(int x, int y, AEListGridWidget gridWidget, int index) {
-        super(new Position(x, y), new Size(18, 18));
-        this.gridWidget = gridWidget;
-        this.index = index;
-    }
-
-    @Override
-    public void drawInBackground(@NotNull GuiGraphics graphics, int mouseX, int mouseY, float partialTicks) {
-        super.drawInBackground(graphics, mouseX, mouseY, partialTicks);
-        Position position = getPosition();
-        GenericStack item = this.gridWidget.getAt(this.index);
-        GuiTextures.SLOT.draw(graphics, mouseX, mouseY, position.x, position.y, 18, 18);
-        GuiTextures.NUMBER_BACKGROUND.draw(graphics, mouseX, mouseY, position.x + 18, position.y, 140, 18);
-        int stackX = position.x + 1;
-        int stackY = position.y + 1;
-        if (item != null) {
-            ItemStack realStack = item.what() instanceof AEItemKey key ? new ItemStack(key.getItem()) : ItemStack.EMPTY;
-            drawItemStack(graphics, realStack, stackX, stackY, -1, null);
-            String amountStr = String.format("x%,d", item.amount());
-            drawText(graphics, amountStr, stackX + 20, stackY + 5, 1, 0xFFFFFFFF);
-        }
-        if (isMouseOverElement(mouseX, mouseY)) {
-            drawSelectionOverlay(graphics, stackX, stackY, 16, 16);
-        }
-    }
-
-    @Override
-    public void drawInForeground(@NotNull GuiGraphics graphics, int mouseX, int mouseY, float partialTicks) {
-        if (isMouseOverElement(mouseX, mouseY)) {
-            GenericStack item = this.gridWidget.getAt(this.index);
-            if (item != null) {
-                graphics.renderTooltip(Minecraft.getInstance().font, GenericStack.wrapInItemStack(item), mouseX,
-                        mouseY);
-            }
-        }
-    }
-}
diff --git a/src/main/java/com/gregtechceu/gtceu/integration/ae2/gui/widget/list/AEListGridWidget.java b/src/main/java/com/gregtechceu/gtceu/integration/ae2/gui/widget/list/AEListGridWidget.java
deleted file mode 100644
index fe52076fd63..00000000000
--- a/src/main/java/com/gregtechceu/gtceu/integration/ae2/gui/widget/list/AEListGridWidget.java
+++ /dev/null
@@ -1,233 +0,0 @@
-package com.gregtechceu.gtceu.integration.ae2.gui.widget.list;
-
-import com.gregtechceu.gtceu.integration.ae2.utils.KeyStorage;
-
-import com.lowdragmc.lowdraglib.gui.widget.DraggableScrollableWidgetGroup;
-import com.lowdragmc.lowdraglib.gui.widget.Widget;
-
-import net.minecraft.network.FriendlyByteBuf;
-import net.minecraftforge.api.distmarker.Dist;
-import net.minecraftforge.api.distmarker.OnlyIn;
-
-import appeng.api.stacks.AEFluidKey;
-import appeng.api.stacks.AEItemKey;
-import appeng.api.stacks.AEKey;
-import appeng.api.stacks.GenericStack;
-import it.unimi.dsi.fastutil.objects.Object2LongMap;
-import it.unimi.dsi.fastutil.objects.Object2LongOpenHashMap;
-
-import java.util.ArrayList;
-import java.util.List;
-
-/**
- * A display only widget for {@link KeyStorage}
- */
-public abstract class AEListGridWidget extends DraggableScrollableWidgetGroup {
-
-    protected final KeyStorage list;
-    private final int slotAmountY;
-    private int slotRowsAmount;
-    protected final static int ROW_CHANGE_ID = 2;
-    protected final static int CONTENT_CHANGE_ID = 3;
-
-    protected final Object2LongMap<AEKey> changeMap = new Object2LongOpenHashMap<>();
-    protected final KeyStorage cached = new KeyStorage();
-    protected final List<GenericStack> displayList = new ArrayList<>();
-
-    public AEListGridWidget(int x, int y, int slotsY, KeyStorage internalList) {
-        super(x, y, 18 + 140, slotsY * 18);
-        this.list = internalList;
-        this.slotAmountY = slotsY;
-    }
-
-    public GenericStack getAt(int index) {
-        return index >= 0 && index < displayList.size() ? displayList.get(index) : null;
-    }
-
-    private void addSlotRows(int amount) {
-        for (int i = 0; i < amount; i++) {
-            int widgetAmount = this.widgets.size();
-            Widget widget = createDisplayWidget(0, i * 18, widgetAmount);
-            this.addWidget(widget);
-        }
-    }
-
-    private void removeSlotRows(int amount) {
-        for (int i = 0; i < amount; i++) {
-            Widget slotWidget = this.widgets.remove(this.widgets.size() - 1);
-            removeWidget(slotWidget);
-        }
-    }
-
-    private void modifySlotRows(int delta) {
-        if (delta > 0) {
-            addSlotRows(delta);
-        } else {
-            removeSlotRows(delta);
-        }
-    }
-
-    protected void writeListChange(FriendlyByteBuf buffer) {
-        this.changeMap.clear();
-
-        // Remove
-        var cachedIt = cached.storage.object2LongEntrySet().iterator();
-        while (cachedIt.hasNext()) {
-            var entry = cachedIt.next();
-            var cachedKey = entry.getKey();
-            if (!list.storage.containsKey(cachedKey)) {
-                this.changeMap.put(cachedKey, -entry.getLongValue());
-                cachedIt.remove();
-            }
-        }
-
-        // Change/Add
-        for (var entry : list.storage.object2LongEntrySet()) {
-            var key = entry.getKey();
-            long value = entry.getLongValue();
-            long cacheValue = cached.storage.getOrDefault(key, 0);
-            if (cacheValue == 0) {
-                // Add
-                this.changeMap.put(key, value);
-                this.cached.storage.put(key, value);
-            } else {
-                // Change
-                if (cacheValue != value) {
-                    this.changeMap.put(key, value - cacheValue);
-                    this.cached.storage.put(key, value);
-                }
-            }
-        }
-
-        buffer.writeVarInt(this.changeMap.size());
-        for (var entry : this.changeMap.object2LongEntrySet()) {
-            entry.getKey().writeToPacket(buffer);
-            buffer.writeVarLong(entry.getLongValue());
-        }
-    }
-
-    protected void readListChange(FriendlyByteBuf buffer) {
-        int size = buffer.readVarInt();
-        for (int i = 0; i < size; i++) {
-            var key = fromPacket(buffer);
-            long delta = buffer.readVarLong();
-
-            boolean found = false;
-            var li = displayList.listIterator();
-            while (li.hasNext()) {
-                var stack = li.next();
-                if (stack.what().equals(key)) {
-                    long newAmount = stack.amount() + delta;
-                    if (newAmount > 0) {
-                        li.set(new GenericStack(key, newAmount));
-                    } else {
-                        li.remove();
-                    }
-                    found = true;
-                    break;
-                }
-            }
-            if (!found) {
-                displayList.add(new GenericStack(key, delta));
-            }
-        }
-    }
-
-    protected abstract void toPacket(FriendlyByteBuf buffer, AEKey key);
-
-    protected abstract AEKey fromPacket(FriendlyByteBuf buffer);
-
-    protected abstract Widget createDisplayWidget(int x, int y, int index);
-
-    @Override
-    public void detectAndSendChanges() {
-        super.detectAndSendChanges();
-        if (this.list == null) return;
-        int slotRowsRequired = Math.max(this.slotAmountY, list.storage.size());
-        if (this.slotRowsAmount != slotRowsRequired) {
-            int slotsToAdd = slotRowsRequired - this.slotRowsAmount;
-            this.slotRowsAmount = slotRowsRequired;
-            this.writeUpdateInfo(ROW_CHANGE_ID, buf -> buf.writeVarInt(slotsToAdd));
-            this.modifySlotRows(slotsToAdd);
-        }
-        this.writeUpdateInfo(CONTENT_CHANGE_ID, this::writeListChange);
-    }
-
-    @Override
-    @OnlyIn(Dist.CLIENT)
-    public void readUpdateInfo(int id, FriendlyByteBuf buffer) {
-        super.readUpdateInfo(id, buffer);
-        if (id == ROW_CHANGE_ID) {
-            int slotsToAdd = buffer.readVarInt();
-            this.modifySlotRows(slotsToAdd);
-        }
-        if (id == CONTENT_CHANGE_ID) {
-            this.readListChange(buffer);
-        }
-    }
-
-    @Override
-    public void writeInitialData(FriendlyByteBuf buffer) {
-        super.writeInitialData(buffer);
-        if (this.list == null) return;
-        int slotRowsRequired = Math.max(this.slotAmountY, list.storage.size());
-        int slotsToAdd = slotRowsRequired - this.slotRowsAmount;
-        this.slotRowsAmount = slotRowsRequired;
-        this.modifySlotRows(slotsToAdd);
-        buffer.writeVarInt(slotsToAdd);
-        this.writeListChange(buffer);
-    }
-
-    @Override
-    @OnlyIn(Dist.CLIENT)
-    public void readInitialData(FriendlyByteBuf buffer) {
-        super.readInitialData(buffer);
-        if (this.list == null) return;
-        this.modifySlotRows(buffer.readVarInt());
-        this.readListChange(buffer);
-    }
-
-    public static class Item extends AEListGridWidget {
-
-        public Item(int x, int y, int slotsY, KeyStorage internalList) {
-            super(x, y, slotsY, internalList);
-        }
-
-        @Override
-        protected void toPacket(FriendlyByteBuf buffer, AEKey key) {
-            key.writeToPacket(buffer);
-        }
-
-        @Override
-        protected AEKey fromPacket(FriendlyByteBuf buffer) {
-            return AEItemKey.fromPacket(buffer);
-        }
-
-        @Override
-        protected Widget createDisplayWidget(int x, int y, int index) {
-            return new AEItemDisplayWidget(x, y, this, index);
-        }
-    }
-
-    public static class Fluid extends AEListGridWidget {
-
-        public Fluid(int x, int y, int slotsY, KeyStorage internalList) {
-            super(x, y, slotsY, internalList);
-        }
-
-        @Override
-        protected void toPacket(FriendlyByteBuf buffer, AEKey key) {
-            key.writeToPacket(buffer);
-        }
-
-        @Override
-        protected AEKey fromPacket(FriendlyByteBuf buffer) {
-            return AEFluidKey.fromPacket(buffer);
-        }
-
-        @Override
-        protected Widget createDisplayWidget(int x, int y, int index) {
-            return new AEFluidDisplayWidget(x, y, this, index);
-        }
-    }
-}
diff --git a/src/main/java/com/gregtechceu/gtceu/integration/ae2/gui/widget/slot/AEConfigSlotWidget.java b/src/main/java/com/gregtechceu/gtceu/integration/ae2/gui/widget/slot/AEConfigSlotWidget.java
deleted file mode 100644
index b6d04d492ce..00000000000
--- a/src/main/java/com/gregtechceu/gtceu/integration/ae2/gui/widget/slot/AEConfigSlotWidget.java
+++ /dev/null
@@ -1,108 +0,0 @@
-package com.gregtechceu.gtceu.integration.ae2.gui.widget.slot;
-
-import com.gregtechceu.gtceu.integration.ae2.gui.widget.ConfigWidget;
-import com.gregtechceu.gtceu.integration.ae2.slot.IConfigurableSlot;
-
-import com.lowdragmc.lowdraglib.gui.widget.Widget;
-import com.lowdragmc.lowdraglib.utils.Position;
-import com.lowdragmc.lowdraglib.utils.Size;
-
-import net.minecraft.client.Minecraft;
-import net.minecraft.client.gui.GuiGraphics;
-import net.minecraft.network.chat.Component;
-import net.minecraftforge.api.distmarker.Dist;
-import net.minecraftforge.api.distmarker.OnlyIn;
-
-import appeng.api.stacks.GenericStack;
-import com.mojang.blaze3d.systems.RenderSystem;
-import org.jetbrains.annotations.NotNull;
-
-import java.util.ArrayList;
-import java.util.List;
-import java.util.Optional;
-
-import static com.lowdragmc.lowdraglib.gui.util.DrawerHelper.drawGradientRect;
-
-public class AEConfigSlotWidget extends Widget {
-
-    protected ConfigWidget parentWidget;
-    protected int index;
-    protected final static int REMOVE_ID = 1000;
-    protected final static int UPDATE_ID = 1001;
-    protected final static int AMOUNT_CHANGE_ID = 1002;
-    protected final static int PICK_UP_ID = 1003;
-    protected boolean select = false;
-
-    public AEConfigSlotWidget(Position pos, Size size, ConfigWidget widget, int index) {
-        super(pos, size);
-        this.parentWidget = widget;
-        this.index = index;
-    }
-
-    @OnlyIn(Dist.CLIENT)
-    @Override
-    public void drawInForeground(@NotNull GuiGraphics graphics, int mouseX, int mouseY, float partialTicks) {
-        super.drawInForeground(graphics, mouseX, mouseY, partialTicks);
-        IConfigurableSlot slot = this.parentWidget.getDisplay(this.index);
-        if (slot.getConfig() == null) {
-            if (mouseOverConfig(mouseX, mouseY)) {
-                List<Component> hoverStringList = new ArrayList<>();
-                hoverStringList.add(Component.translatable("gtceu.gui.config_slot"));
-                if (parentWidget.isAutoPull()) {
-                    hoverStringList.add(Component.translatable("gtceu.gui.config_slot.auto_pull_managed"));
-                } else {
-                    if (!parentWidget.isStocking()) {
-                        hoverStringList.add(Component.translatable("gtceu.gui.config_slot.set"));
-                        hoverStringList.add(Component.translatable("gtceu.gui.config_slot.scroll"));
-                    } else {
-                        hoverStringList.add(Component.translatable("gtceu.gui.config_slot.set_only"));
-                    }
-                    hoverStringList.add(Component.translatable("gtceu.gui.config_slot.remove"));
-                }
-                graphics.renderTooltip(Minecraft.getInstance().font, hoverStringList, Optional.empty(), mouseX, mouseY);
-            }
-        } else {
-            GenericStack item = null;
-            if (mouseOverConfig(mouseX, mouseY)) {
-                item = slot.getConfig();
-            } else if (mouseOverStock(mouseX, mouseY)) {
-                item = slot.getStock();
-            }
-            if (item != null) {
-                graphics.renderTooltip(Minecraft.getInstance().font, GenericStack.wrapInItemStack(item), mouseX,
-                        mouseY);
-            }
-        }
-    }
-
-    public void setSelect(boolean val) {
-        this.select = val;
-    }
-
-    protected boolean mouseOverConfig(double mouseX, double mouseY) {
-        Position position = getPosition();
-        return isMouseOver(position.x, position.y, 18, 18, mouseX, mouseY);
-    }
-
-    protected boolean mouseOverStock(double mouseX, double mouseY) {
-        Position position = getPosition();
-        return isMouseOver(position.x, position.y + 18, 18, 18, mouseX, mouseY);
-    }
-
-    @OnlyIn(Dist.CLIENT)
-    public static void drawSelectionOverlay(GuiGraphics graphics, int x, int y, int width, int height) {
-        RenderSystem.disableDepthTest();
-        RenderSystem.colorMask(true, true, true, false);
-        drawGradientRect(graphics, x, y, width, height, -2130706433, -2130706433);
-        RenderSystem.colorMask(true, true, true, true);
-        RenderSystem.enableDepthTest();
-        RenderSystem.enableBlend();
-    }
-
-    // Method for server-side validation of an attempted new configured item
-    protected boolean isStackValidForSlot(GenericStack stack) {
-        if (stack == null || stack.amount() < 0) return true;
-        if (!parentWidget.isStocking()) return true;
-        return !parentWidget.hasStackInConfig(stack);
-    }
-}
diff --git a/src/main/java/com/gregtechceu/gtceu/integration/ae2/gui/widget/slot/AEFluidConfigSlotWidget.java b/src/main/java/com/gregtechceu/gtceu/integration/ae2/gui/widget/slot/AEFluidConfigSlotWidget.java
deleted file mode 100644
index bbf171ffbe9..00000000000
--- a/src/main/java/com/gregtechceu/gtceu/integration/ae2/gui/widget/slot/AEFluidConfigSlotWidget.java
+++ /dev/null
@@ -1,312 +0,0 @@
-package com.gregtechceu.gtceu.integration.ae2.gui.widget.slot;
-
-import com.gregtechceu.gtceu.api.gui.GuiTextures;
-import com.gregtechceu.gtceu.api.gui.misc.IGhostFluidTarget;
-import com.gregtechceu.gtceu.integration.ae2.gui.widget.ConfigWidget;
-import com.gregtechceu.gtceu.integration.ae2.slot.ExportOnlyAEFluidSlot;
-import com.gregtechceu.gtceu.integration.ae2.slot.ExportOnlyAESlot;
-import com.gregtechceu.gtceu.integration.ae2.slot.IConfigurableSlot;
-import com.gregtechceu.gtceu.integration.ae2.utils.AEUtil;
-import com.gregtechceu.gtceu.utils.FormattingUtil;
-import com.gregtechceu.gtceu.utils.GTMath;
-
-import com.lowdragmc.lowdraglib.gui.util.DrawerHelper;
-import com.lowdragmc.lowdraglib.side.fluid.forge.FluidHelperImpl;
-import com.lowdragmc.lowdraglib.utils.Position;
-import com.lowdragmc.lowdraglib.utils.Size;
-
-import net.minecraft.client.gui.GuiGraphics;
-import net.minecraft.client.renderer.Rect2i;
-import net.minecraft.core.registries.BuiltInRegistries;
-import net.minecraft.network.FriendlyByteBuf;
-import net.minecraft.sounds.SoundEvent;
-import net.minecraft.sounds.SoundSource;
-import net.minecraft.world.entity.player.Player;
-import net.minecraft.world.item.ItemStack;
-import net.minecraft.world.level.block.Block;
-import net.minecraft.world.level.material.Fluids;
-import net.minecraftforge.api.distmarker.Dist;
-import net.minecraftforge.api.distmarker.OnlyIn;
-import net.minecraftforge.common.SoundActions;
-import net.minecraftforge.fluids.FluidActionResult;
-import net.minecraftforge.fluids.FluidStack;
-import net.minecraftforge.fluids.FluidUtil;
-
-import appeng.api.stacks.AEFluidKey;
-import appeng.api.stacks.GenericStack;
-import org.jetbrains.annotations.NotNull;
-
-import static com.lowdragmc.lowdraglib.gui.util.DrawerHelper.drawStringFixedCorner;
-
-public class AEFluidConfigSlotWidget extends AEConfigSlotWidget implements IGhostFluidTarget {
-
-    public AEFluidConfigSlotWidget(int x, int y, ConfigWidget widget, int index) {
-        super(new Position(x, y), new Size(18, 18 * 2), widget, index);
-    }
-
-    @OnlyIn(Dist.CLIENT)
-    @Override
-    public void drawInBackground(@NotNull GuiGraphics graphics, int mouseX, int mouseY, float partialTicks) {
-        super.drawInBackground(graphics, mouseX, mouseY, partialTicks);
-        Position position = getPosition();
-        IConfigurableSlot slot = this.parentWidget.getDisplay(this.index);
-        GenericStack config = slot.getConfig();
-        GenericStack stock = slot.getStock();
-        drawSlots(graphics, mouseX, mouseY, position.x, position.y, parentWidget.isAutoPull());
-        if (this.select) {
-            GuiTextures.SELECT_BOX.draw(graphics, mouseX, mouseY, position.x, position.y, 18, 18);
-        }
-
-        int stackX = position.x + 1;
-        int stackY = position.y + 1;
-        if (config != null) {
-            var stack = AEUtil.toFluidStack(config);
-            if (!stack.isEmpty()) {
-                DrawerHelper.drawFluidForGui(graphics, FluidHelperImpl.toFluidStack(stack), config.amount(), stackX,
-                        stackY, 16, 16);
-                if (!parentWidget.isStocking()) {
-                    String amountStr = FormattingUtil.formatNumberReadable(config.amount(), true,
-                            FormattingUtil.DECIMAL_FORMAT_0F, "B");
-                    drawStringFixedCorner(graphics, amountStr, stackX + 17, stackY + 17, 16777215, true, 0.5f);
-                }
-            }
-        }
-        if (stock != null) {
-            var stack = AEUtil.toFluidStack(stock);
-            if (!stack.isEmpty()) {
-                DrawerHelper.drawFluidForGui(graphics, FluidHelperImpl.toFluidStack(stack), stock.amount(), stackX,
-                        stackY + 18, 16,
-                        16);
-                String amountStr = FormattingUtil.formatNumberReadable(stock.amount(), true,
-                        FormattingUtil.DECIMAL_FORMAT_0F, "B");
-                drawStringFixedCorner(graphics, amountStr, stackX + 17, stackY + 18 + 17, 16777215, true, 0.5f);
-            }
-        }
-
-        if (mouseOverConfig(mouseX, mouseY)) {
-            drawSelectionOverlay(graphics, stackX, stackY, 16, 16);
-        } else if (mouseOverStock(mouseX, mouseY)) {
-            drawSelectionOverlay(graphics, stackX, stackY + 18, 16, 16);
-        }
-    }
-
-    @OnlyIn(Dist.CLIENT)
-    private void drawSlots(GuiGraphics graphics, int mouseX, int mouseY, int x, int y, boolean autoPull) {
-        if (autoPull) {
-            GuiTextures.SLOT_DARK.draw(graphics, mouseX, mouseY, x, y, 18, 18);
-            GuiTextures.CONFIG_ARROW_DARK.draw(graphics, mouseX, mouseY, x, y, 18, 18);
-        } else {
-            GuiTextures.FLUID_SLOT.draw(graphics, mouseX, mouseY, x, y, 18, 18);
-            GuiTextures.CONFIG_ARROW.draw(graphics, mouseX, mouseY, x, y, 18, 18);
-        }
-        GuiTextures.SLOT_DARK.draw(graphics, mouseX, mouseY, x, y + 18, 18, 18);
-    }
-
-    @OnlyIn(Dist.CLIENT)
-    @Override
-    public boolean mouseClicked(double mouseX, double mouseY, int button) {
-        if (mouseOverConfig(mouseX, mouseY)) {
-            // don't allow manual interaction with config slots when auto pull is enabled
-            if (parentWidget.isAutoPull()) {
-                return false;
-            }
-
-            if (button == 1) {
-                // Right click to clear
-                writeClientAction(REMOVE_ID, buf -> {});
-
-                if (!parentWidget.isStocking()) {
-                    this.parentWidget.disableAmountClient();
-                }
-            } else if (button == 0) {
-                // Left click to set/select
-                ItemStack hold = this.gui.getModularUIContainer().getCarried();
-                FluidUtil.getFluidContained(hold).ifPresent(f -> writeClientAction(UPDATE_ID, f::writeToPacket));
-
-                if (!parentWidget.isStocking()) {
-                    this.parentWidget.enableAmountClient(this.index);
-                    this.select = true;
-                }
-            }
-            return true;
-        } else if (mouseOverStock(mouseX, mouseY)) {
-            // Left click to pick up
-            if (button == 0) {
-                if (parentWidget.isStocking()) {
-                    return false;
-                }
-                GenericStack stack = this.parentWidget.getDisplay(this.index).getStock();
-                if (stack != null) {
-                    writeClientAction(PICK_UP_ID, buf -> buf.writeBoolean(isShiftDown()));
-                }
-                return true;
-            }
-        }
-        return false;
-    }
-
-    @Override
-    public void handleClientAction(int id, FriendlyByteBuf buffer) {
-        super.handleClientAction(id, buffer);
-        IConfigurableSlot slot = this.parentWidget.getConfig(this.index);
-        if (id == REMOVE_ID) {
-            slot.setConfig(null);
-            this.parentWidget.disableAmount();
-            writeUpdateInfo(REMOVE_ID, buf -> {});
-        }
-        if (id == UPDATE_ID) {
-            FluidStack fluid = FluidStack.readFromPacket(buffer);
-            var stack = AEUtil.fromFluidStack(fluid);
-            if (!isStackValidForSlot(stack)) return;
-            slot.setConfig(stack);
-            this.parentWidget.enableAmount(this.index);
-            if (fluid != FluidStack.EMPTY) {
-                writeUpdateInfo(UPDATE_ID, fluid::writeToPacket);
-            }
-        }
-        if (id == AMOUNT_CHANGE_ID) {
-            if (slot.getConfig() != null) {
-                int amt = buffer.readInt();
-                slot.setConfig(ExportOnlyAESlot.copy(slot.getConfig(), amt));
-                writeUpdateInfo(AMOUNT_CHANGE_ID, buf -> buf.writeInt(amt));
-            }
-        }
-        if (id == PICK_UP_ID) {
-            if (slot.getStock() != null) {
-                boolean isShiftKeyDown = buffer.readBoolean();
-                int clickResult = tryClickContainer(isShiftKeyDown);
-                if (clickResult >= 0) {
-                    writeUpdateInfo(PICK_UP_ID, buf -> buf.writeVarInt(clickResult));
-                }
-            }
-        }
-    }
-
-    @OnlyIn(Dist.CLIENT)
-    @Override
-    public void readUpdateInfo(int id, FriendlyByteBuf buffer) {
-        super.readUpdateInfo(id, buffer);
-        IConfigurableSlot slot = this.parentWidget.getDisplay(this.index);
-        if (id == REMOVE_ID) {
-            slot.setConfig(null);
-        }
-        if (id == UPDATE_ID) {
-            FluidStack fluid = new FluidStack(BuiltInRegistries.FLUID.get(buffer.readResourceLocation()),
-                    buffer.readVarInt());
-            slot.setConfig(new GenericStack(AEFluidKey.of(fluid.getFluid()), fluid.getAmount()));
-        }
-        if (id == AMOUNT_CHANGE_ID) {
-            if (slot.getConfig() != null) {
-                int amt = buffer.readInt();
-                slot.setConfig(ExportOnlyAESlot.copy(slot.getConfig(), amt));
-            }
-        }
-        if (id == PICK_UP_ID) {
-            if (slot.getStock() != null && slot.getStock().what() instanceof AEFluidKey key) {
-                ItemStack currentStack = gui.getModularUIContainer().getCarried();
-                int newStackSize = buffer.readVarInt();
-                currentStack.setCount(newStackSize);
-                gui.getModularUIContainer().setCarried(currentStack);
-
-                FluidStack stack = new FluidStack(key.getFluid(), GTMath.saturatedCast(slot.getStock().amount()));
-                if (key.hasTag()) {
-                    stack.setTag(key.getTag().copy());
-                }
-                GenericStack stack1 = ExportOnlyAESlot.copy(slot.getStock(),
-                        Math.max(0, (slot.getStock().amount() - stack.getAmount())));
-                slot.setStock(stack1.amount() == 0 ? null : stack1);
-            }
-        }
-    }
-
-    @OnlyIn(Dist.CLIENT)
-    @Override
-    public Rect2i getRectangleBox() {
-        Rect2i rectangle = toRectangleBox();
-        rectangle.setHeight(rectangle.getHeight() / 2);
-        return rectangle;
-    }
-
-    @OnlyIn(Dist.CLIENT)
-    @Override
-    public void acceptFluid(FluidStack fluidStack) {
-        if (fluidStack.getRawFluid() != Fluids.EMPTY && fluidStack.getAmount() <= 0L) {
-            fluidStack.setAmount(1000);
-        }
-
-        if (!fluidStack.isEmpty()) {
-            writeClientAction(UPDATE_ID, fluidStack::writeToPacket);
-        }
-    }
-
-    @OnlyIn(Dist.CLIENT)
-    @Override
-    public boolean mouseWheelMove(double mouseX, double mouseY, double wheelDelta) {
-        // Only allow the amount scrolling if not stocking, as amount is useless for stocking
-        if (parentWidget.isStocking()) return false;
-        IConfigurableSlot slot = this.parentWidget.getDisplay(this.index);
-        Rect2i rectangle = toRectangleBox();
-        rectangle.setHeight(rectangle.getHeight() / 2);
-        if (slot.getConfig() == null || wheelDelta == 0 || !rectangle.contains((int) mouseX, (int) mouseY)) {
-            return false;
-        }
-        FluidStack fluid = slot.getConfig().what() instanceof AEFluidKey fluidKey ?
-                new FluidStack(fluidKey.getFluid(), GTMath.saturatedCast(slot.getConfig().amount()),
-                        fluidKey.getTag()) :
-                FluidStack.EMPTY;
-        long amt;
-        if (isCtrlDown()) {
-            amt = wheelDelta > 0 ? fluid.getAmount() * 2L : fluid.getAmount() / 2L;
-        } else {
-            amt = wheelDelta > 0 ? fluid.getAmount() + 1L : fluid.getAmount() - 1L;
-        }
-
-        if (amt > 0 && amt < Integer.MAX_VALUE + 1L) {
-            int finalAmt = (int) amt;
-            writeClientAction(AMOUNT_CHANGE_ID, buf -> buf.writeInt(finalAmt));
-            return true;
-        }
-        return false;
-    }
-
-    private int tryClickContainer(boolean isShiftKeyDown) {
-        ExportOnlyAEFluidSlot fluidTank = this.parentWidget
-                .getConfig(this.index) instanceof ExportOnlyAEFluidSlot fluid ? fluid : null;
-        if (fluidTank == null) return -1;
-        Player player = gui.entityPlayer;
-        ItemStack currentStack = gui.getModularUIContainer().getCarried();
-        var handler = FluidUtil.getFluidHandler(currentStack).resolve().orElse(null);
-        if (handler == null) return -1;
-        int maxAttempts = isShiftKeyDown ? currentStack.getCount() : 1;
-
-        if (fluidTank.getFluidAmount() > 0) {
-            boolean performedFill = false;
-            FluidStack initialFluid = fluidTank.getFluid();
-            for (int i = 0; i < maxAttempts; i++) {
-                FluidActionResult result = FluidUtil.tryFillContainer(currentStack, fluidTank, Integer.MAX_VALUE, null,
-                        false);
-                if (!result.isSuccess()) break;
-                ItemStack remainingStack = FluidUtil
-                        .tryFillContainer(currentStack, fluidTank, Integer.MAX_VALUE, null, true).getResult();
-                currentStack.shrink(1);
-                performedFill = true;
-                if (!remainingStack.isEmpty() && !player.addItem(remainingStack)) {
-                    Block.popResource(player.level(), player.getOnPos(), remainingStack);
-                    break;
-                }
-            }
-            if (performedFill) {
-                SoundEvent soundevent = initialFluid.getFluid().getFluidType().getSound(initialFluid,
-                        SoundActions.BUCKET_FILL);
-                if (soundevent != null) {
-                    player.level().playSound(null, player.position().x, player.position().y + 0.5, player.position().z,
-                            soundevent, SoundSource.BLOCKS, 1.0F, 1.0F);
-                }
-                gui.getModularUIContainer().setCarried(currentStack);
-                return currentStack.getCount();
-            }
-        }
-
-        return -1;
-    }
-}
diff --git a/src/main/java/com/gregtechceu/gtceu/integration/ae2/gui/widget/slot/AEItemConfigSlotWidget.java b/src/main/java/com/gregtechceu/gtceu/integration/ae2/gui/widget/slot/AEItemConfigSlotWidget.java
deleted file mode 100644
index 574b4fdf276..00000000000
--- a/src/main/java/com/gregtechceu/gtceu/integration/ae2/gui/widget/slot/AEItemConfigSlotWidget.java
+++ /dev/null
@@ -1,241 +0,0 @@
-package com.gregtechceu.gtceu.integration.ae2.gui.widget.slot;
-
-import com.gregtechceu.gtceu.api.gui.GuiTextures;
-import com.gregtechceu.gtceu.api.gui.misc.IGhostItemTarget;
-import com.gregtechceu.gtceu.integration.ae2.gui.widget.ConfigWidget;
-import com.gregtechceu.gtceu.integration.ae2.slot.ExportOnlyAESlot;
-import com.gregtechceu.gtceu.integration.ae2.slot.IConfigurableSlot;
-
-import com.lowdragmc.lowdraglib.gui.util.TextFormattingUtil;
-import com.lowdragmc.lowdraglib.utils.Position;
-import com.lowdragmc.lowdraglib.utils.Size;
-
-import net.minecraft.client.gui.GuiGraphics;
-import net.minecraft.client.renderer.Rect2i;
-import net.minecraft.network.FriendlyByteBuf;
-import net.minecraft.world.item.ItemStack;
-import net.minecraftforge.api.distmarker.Dist;
-import net.minecraftforge.api.distmarker.OnlyIn;
-
-import appeng.api.stacks.AEItemKey;
-import appeng.api.stacks.GenericStack;
-import org.jetbrains.annotations.NotNull;
-
-import static com.lowdragmc.lowdraglib.gui.util.DrawerHelper.drawItemStack;
-import static com.lowdragmc.lowdraglib.gui.util.DrawerHelper.drawStringFixedCorner;
-
-public class AEItemConfigSlotWidget extends AEConfigSlotWidget implements IGhostItemTarget {
-
-    public AEItemConfigSlotWidget(int x, int y, ConfigWidget widget, int index) {
-        super(new Position(x, y), new Size(18, 18 * 2), widget, index);
-    }
-
-    @OnlyIn(Dist.CLIENT)
-    @Override
-    public void drawInBackground(@NotNull GuiGraphics graphics, int mouseX, int mouseY, float partialTicks) {
-        super.drawInBackground(graphics, mouseX, mouseY, partialTicks);
-        Position position = getPosition();
-        IConfigurableSlot slot = this.parentWidget.getDisplay(this.index);
-        GenericStack config = slot.getConfig();
-        GenericStack stock = slot.getStock();
-        drawSlots(graphics, mouseX, mouseY, position.x, position.y, parentWidget.isAutoPull());
-        if (this.select) {
-            GuiTextures.SELECT_BOX.draw(graphics, mouseX, mouseY, position.x, position.y, 18, 18);
-        }
-        int stackX = position.x + 1;
-        int stackY = position.y + 1;
-        if (config != null) {
-            ItemStack stack = config.what() instanceof AEItemKey key ? new ItemStack(key.getItem()) : ItemStack.EMPTY;
-            drawItemStack(graphics, stack, stackX, stackY, 0xFFFFFFFF, null);
-
-            if (!parentWidget.isStocking()) {
-                String amountStr = TextFormattingUtil.formatLongToCompactString(config.amount(), 4);
-                drawStringFixedCorner(graphics, amountStr, stackX + 17, stackY + 17, 16777215, true, 0.5f);
-            }
-        }
-        if (stock != null) {
-            ItemStack stack = stock.what() instanceof AEItemKey key ? new ItemStack(key.getItem()) : ItemStack.EMPTY;
-            drawItemStack(graphics, stack, stackX, stackY + 18, 0xFFFFFFFF, null);
-            String amountStr = TextFormattingUtil.formatLongToCompactString(stock.amount(), 4);
-            drawStringFixedCorner(graphics, amountStr, stackX + 17, stackY + 18 + 17, 16777215, true, 0.5f);
-        }
-        if (mouseOverConfig(mouseX, mouseY)) {
-            drawSelectionOverlay(graphics, stackX, stackY, 16, 16);
-        } else if (mouseOverStock(mouseX, mouseY)) {
-            drawSelectionOverlay(graphics, stackX, stackY + 18, 16, 16);
-        }
-    }
-
-    @OnlyIn(Dist.CLIENT)
-    private void drawSlots(GuiGraphics graphics, int mouseX, int mouseY, int x, int y, boolean autoPull) {
-        if (autoPull) {
-            GuiTextures.SLOT_DARK.draw(graphics, mouseX, mouseY, x, y, 18, 18);
-            GuiTextures.CONFIG_ARROW.draw(graphics, mouseX, mouseY, x, y, 18, 18);
-        } else {
-            GuiTextures.SLOT.draw(graphics, mouseX, mouseY, x, y, 18, 18);
-            GuiTextures.CONFIG_ARROW_DARK.draw(graphics, mouseX, mouseY, x, y, 18, 18);
-        }
-        GuiTextures.SLOT_DARK.draw(graphics, mouseX, mouseY, x, y + 18, 18, 18);
-    }
-
-    @OnlyIn(Dist.CLIENT)
-    @Override
-    public boolean mouseClicked(double mouseX, double mouseY, int button) {
-        if (mouseOverConfig(mouseX, mouseY)) {
-            // don't allow manual interaction with config slots when auto pull is enabled
-            if (parentWidget.isAutoPull()) {
-                return false;
-            }
-
-            if (button == 1) {
-                // Right click to clear
-                writeClientAction(REMOVE_ID, buf -> {});
-
-                if (!parentWidget.isStocking()) {
-                    this.parentWidget.disableAmountClient();
-                }
-            } else if (button == 0) {
-                // Left click to set/select
-                ItemStack item = this.gui.getModularUIContainer().getCarried();
-
-                if (!item.isEmpty()) {
-                    writeClientAction(UPDATE_ID, buf -> buf.writeItem(item));
-                }
-
-                if (!parentWidget.isStocking()) {
-                    this.parentWidget.enableAmountClient(this.index);
-                    this.select = true;
-                }
-            }
-            return true;
-        } else if (mouseOverStock(mouseX, mouseY)) {
-            // Left click to pick up
-            if (button == 0) {
-                if (parentWidget.isStocking()) {
-                    return false;
-                }
-                GenericStack stack = this.parentWidget.getDisplay(this.index).getStock();
-                if (stack != null) {
-                    writeClientAction(PICK_UP_ID, buf -> {});
-                }
-                return true;
-            }
-        }
-        return false;
-    }
-
-    @Override
-    public void handleClientAction(int id, FriendlyByteBuf buffer) {
-        super.handleClientAction(id, buffer);
-        IConfigurableSlot slot = this.parentWidget.getConfig(this.index);
-        if (id == REMOVE_ID) {
-            slot.setConfig(null);
-            this.parentWidget.disableAmount();
-            writeUpdateInfo(REMOVE_ID, buf -> {});
-        }
-        if (id == UPDATE_ID) {
-            ItemStack item = buffer.readItem();
-            var stack = GenericStack.fromItemStack(item);
-            if (!isStackValidForSlot(stack)) return;
-            slot.setConfig(stack);
-            this.parentWidget.enableAmount(this.index);
-            if (!item.isEmpty()) {
-                writeUpdateInfo(UPDATE_ID, buf -> buf.writeItem(item));
-            }
-        }
-        if (id == AMOUNT_CHANGE_ID) {
-            if (slot.getConfig() != null) {
-                long amt = buffer.readVarLong();
-                slot.setConfig(new GenericStack(slot.getConfig().what(), amt));
-                writeUpdateInfo(AMOUNT_CHANGE_ID, buf -> buf.writeVarLong(amt));
-            }
-        }
-        if (id == PICK_UP_ID) {
-            if (slot.getStock() != null && this.gui.getModularUIContainer().getCarried() == ItemStack.EMPTY &&
-                    slot.getStock().what() instanceof AEItemKey key) {
-                ItemStack stack = new ItemStack(key.getItem());
-                stack.setCount(Math.min((int) slot.getStock().amount(), stack.getMaxStackSize()));
-                if (key.hasTag()) {
-                    stack.setTag(key.getTag().copy());
-                }
-                this.gui.getModularUIContainer().setCarried(stack);
-                GenericStack stack1 = ExportOnlyAESlot.copy(slot.getStock(),
-                        Math.max(0, (slot.getStock().amount() - stack.getCount())));
-                slot.setStock(stack1.amount() == 0 ? null : stack1);
-                writeUpdateInfo(PICK_UP_ID, buf -> {});
-            }
-        }
-    }
-
-    @OnlyIn(Dist.CLIENT)
-    @Override
-    public void readUpdateInfo(int id, FriendlyByteBuf buffer) {
-        super.readUpdateInfo(id, buffer);
-        IConfigurableSlot slot = this.parentWidget.getDisplay(this.index);
-        if (id == REMOVE_ID) {
-            slot.setConfig(null);
-        }
-        if (id == UPDATE_ID) {
-            ItemStack item = buffer.readItem();
-            slot.setConfig(new GenericStack(AEItemKey.of(item.getItem(), item.getTag()), item.getCount()));
-        }
-        if (id == AMOUNT_CHANGE_ID) {
-            if (slot.getConfig() != null) {
-                long amt = buffer.readVarLong();
-                slot.setConfig(new GenericStack(slot.getConfig().what(), amt));
-            }
-        }
-        if (id == PICK_UP_ID) {
-            if (slot.getStock() != null && slot.getStock().what() instanceof AEItemKey key) {
-                ItemStack stack = new ItemStack(key.getItem());
-                stack.setCount(Math.min((int) slot.getStock().amount(), stack.getMaxStackSize()));
-                if (key.hasTag()) {
-                    stack.setTag(key.getTag().copy());
-                }
-                this.gui.getModularUIContainer().setCarried(stack);
-                GenericStack stack1 = ExportOnlyAESlot.copy(slot.getStock(),
-                        Math.max(0, (slot.getStock().amount() - stack.getCount())));
-                slot.setStock(stack1.amount() == 0 ? null : stack1);
-            }
-        }
-    }
-
-    @OnlyIn(Dist.CLIENT)
-    @Override
-    public Rect2i getRectangleBox() {
-        Rect2i rectangle = toRectangleBox();
-        rectangle.setHeight(rectangle.getHeight() / 2);
-        return rectangle;
-    }
-
-    @OnlyIn(Dist.CLIENT)
-    @Override
-    public void acceptItem(ItemStack itemStack) {
-        writeClientAction(UPDATE_ID, buf -> buf.writeItem(itemStack));
-    }
-
-    @OnlyIn(Dist.CLIENT)
-    @Override
-    public boolean mouseWheelMove(double mouseX, double mouseY, double wheelDelta) {
-        // Only allow the amount scrolling if not stocking, as amount is useless for stocking
-        if (parentWidget.isStocking()) return false;
-        IConfigurableSlot slot = this.parentWidget.getDisplay(this.index);
-        Rect2i rectangle = toRectangleBox();
-        rectangle.setHeight(rectangle.getHeight() / 2);
-        if (slot.getConfig() == null || wheelDelta == 0 || !rectangle.contains((int) mouseX, (int) mouseY)) {
-            return false;
-        }
-        GenericStack stack = slot.getConfig();
-        long amt;
-        if (isCtrlDown()) {
-            amt = wheelDelta > 0 ? stack.amount() * 2L : stack.amount() / 2L;
-        } else {
-            amt = wheelDelta > 0 ? stack.amount() + 1L : stack.amount() - 1L;
-        }
-        if (amt > 0 && amt < Integer.MAX_VALUE + 1L) {
-            writeClientAction(AMOUNT_CHANGE_ID, buf -> buf.writeVarLong(amt));
-            return true;
-        }
-        return false;
-    }
-}
diff --git a/src/main/java/com/gregtechceu/gtceu/integration/ae2/gui/widget/slot/AEPatternViewSlotWidget.java b/src/main/java/com/gregtechceu/gtceu/integration/ae2/gui/widget/slot/AEPatternViewSlotWidget.java
deleted file mode 100644
index a3d0f477b93..00000000000
--- a/src/main/java/com/gregtechceu/gtceu/integration/ae2/gui/widget/slot/AEPatternViewSlotWidget.java
+++ /dev/null
@@ -1,86 +0,0 @@
-package com.gregtechceu.gtceu.integration.ae2.gui.widget.slot;
-
-import com.gregtechceu.gtceu.api.gui.widget.SlotWidget;
-
-import com.lowdragmc.lowdraglib.gui.texture.GuiTextureGroup;
-import com.lowdragmc.lowdraglib.gui.texture.IGuiTexture;
-import com.lowdragmc.lowdraglib.utils.Position;
-import com.lowdragmc.lowdraglib.utils.Size;
-
-import net.minecraft.client.gui.GuiGraphics;
-import net.minecraft.world.Container;
-import net.minecraftforge.api.distmarker.Dist;
-import net.minecraftforge.api.distmarker.OnlyIn;
-import net.minecraftforge.items.IItemHandlerModifiable;
-
-import org.jetbrains.annotations.NotNull;
-
-public class AEPatternViewSlotWidget extends SlotWidget {
-
-    protected IGuiTexture occupiedTexture;
-
-    public AEPatternViewSlotWidget() {}
-
-    public AEPatternViewSlotWidget(
-                                   Container inventory,
-                                   int slotIndex,
-                                   int xPosition,
-                                   int yPosition,
-                                   boolean canTakeItems,
-                                   boolean canPutItems) {
-        super(inventory, slotIndex, xPosition, yPosition, canTakeItems, canPutItems);
-    }
-
-    public AEPatternViewSlotWidget(
-                                   IItemHandlerModifiable itemHandler,
-                                   int slotIndex,
-                                   int xPosition,
-                                   int yPosition,
-                                   boolean canTakeItems,
-                                   boolean canPutItems) {
-        super(itemHandler, slotIndex, xPosition, yPosition, canTakeItems, canPutItems);
-    }
-
-    public AEPatternViewSlotWidget(
-                                   IItemHandlerModifiable itemHandler, int slotIndex, int xPosition, int yPosition) {
-        super(itemHandler, slotIndex, xPosition, yPosition);
-    }
-
-    public AEPatternViewSlotWidget(Container inventory, int slotIndex, int xPosition, int yPosition) {
-        super(inventory, slotIndex, xPosition, yPosition);
-    }
-
-    public AEPatternViewSlotWidget setOccupiedTexture(IGuiTexture... occupiedTexture) {
-        this.occupiedTexture = occupiedTexture.length > 1 ? new GuiTextureGroup(occupiedTexture) : occupiedTexture[0];
-        return this;
-    }
-
-    @Override
-    @OnlyIn(Dist.CLIENT)
-    public void updateScreen() {
-        super.updateScreen();
-        if (occupiedTexture != null) {
-            occupiedTexture.updateTick();
-        }
-    }
-
-    @Override
-    @OnlyIn(Dist.CLIENT)
-    protected void drawBackgroundTexture(@NotNull GuiGraphics graphics, int mouseX, int mouseY) {
-        Position pos = getPosition();
-        Size size = getSize();
-        if (getHandler() != null && getHandler().hasItem()) {
-            if (occupiedTexture != null) {
-                occupiedTexture.draw(graphics, mouseX, mouseY, pos.x, pos.y, size.width, size.height);
-            }
-        } else {
-            if (backgroundTexture != null) {
-                backgroundTexture.draw(graphics, mouseX, mouseY, pos.x, pos.y, size.width, size.height);
-            }
-        }
-
-        if (hoverTexture != null && isMouseOverElement(mouseX, mouseY)) {
-            hoverTexture.draw(graphics, mouseX, mouseY, pos.x, pos.y, size.width, size.height);
-        }
-    }
-}
diff --git a/src/main/java/com/gregtechceu/gtceu/integration/ae2/machine/MEInputBusPartMachine.java b/src/main/java/com/gregtechceu/gtceu/integration/ae2/machine/MEInputBusPartMachine.java
index 2dda281c541..498ada049c8 100644
--- a/src/main/java/com/gregtechceu/gtceu/integration/ae2/machine/MEInputBusPartMachine.java
+++ b/src/main/java/com/gregtechceu/gtceu/integration/ae2/machine/MEInputBusPartMachine.java
@@ -6,16 +6,12 @@
 import com.gregtechceu.gtceu.api.machine.feature.IHasCircuitSlot;
 import com.gregtechceu.gtceu.api.machine.trait.NotifiableItemStackHandler;
 import com.gregtechceu.gtceu.common.item.behavior.IntCircuitBehaviour;
-import com.gregtechceu.gtceu.integration.ae2.gui.widget.AEItemConfigWidget;
+import com.gregtechceu.gtceu.integration.ae2.gui.AEConfigWidget;
 import com.gregtechceu.gtceu.integration.ae2.slot.ExportOnlyAEItemList;
 import com.gregtechceu.gtceu.integration.ae2.slot.ExportOnlyAEItemSlot;
+import com.gregtechceu.gtceu.integration.ae2.slot.ExportOnlyAESlot;
 import com.gregtechceu.gtceu.utils.GTMath;
 
-import com.lowdragmc.lowdraglib.gui.widget.LabelWidget;
-import com.lowdragmc.lowdraglib.gui.widget.Widget;
-import com.lowdragmc.lowdraglib.gui.widget.WidgetGroup;
-import com.lowdragmc.lowdraglib.utils.Position;
-
 import net.minecraft.MethodsReturnNonnullByDefault;
 import net.minecraft.nbt.CompoundTag;
 import net.minecraft.network.chat.Component;
@@ -24,8 +20,16 @@
 import net.minecraft.world.item.ItemStack;
 
 import appeng.api.config.Actionable;
+import appeng.api.stacks.AEItemKey;
 import appeng.api.stacks.GenericStack;
 import appeng.api.storage.MEStorage;
+import brachy.modularui.api.drawable.IKey;
+import brachy.modularui.factory.PosGuiData;
+import brachy.modularui.screen.UISettings;
+import brachy.modularui.value.sync.BooleanSyncValue;
+import brachy.modularui.value.sync.PanelSyncManager;
+import brachy.modularui.widget.ParentWidget;
+import brachy.modularui.widgets.layout.Flow;
 
 import javax.annotation.ParametersAreNonnullByDefault;
 
@@ -118,17 +122,83 @@ protected void flushInventory() {
     ///////////////////////////////
 
     @Override
-    public Widget createUIWidget() {
-        WidgetGroup group = new WidgetGroup(new Position(0, 0));
-        // ME Network status
-        group.addWidget(new LabelWidget(3, 0, () -> this.isOnline ?
-                "gtceu.gui.me_network.online" :
-                "gtceu.gui.me_network.offline"));
+    public void buildMainUI(ParentWidget<?> mainWidget, PosGuiData guiData, PanelSyncManager syncManager,
+                            UISettings settings) {
+        BooleanSyncValue isOnlineValue = new BooleanSyncValue(this::isOnline, this::setOnline);
+        syncManager.syncValue("is_online", isOnlineValue);
+
+        registerConfigActions(syncManager);
+
+        var flow = Flow.col().coverChildren();
+
+        flow.child(IKey.dynamic(() -> isOnlineValue.getBoolValue() ?
+                Component.translatable("gtceu.gui.me_network.online") :
+                Component.translatable("gtceu.gui.me_network.offline"))
+                .asWidget().marginTop(2).marginBottom(4));
+        flow.child(new AEConfigWidget(aeItemHandler, CONFIG_SIZE, false)
+                .syncManager(syncManager)
+                .size(8 * 18, 2 * (18 * 2 + 2)));
+
+        mainWidget.child(flow.center());
+    }
+
+    protected void registerConfigActions(PanelSyncManager syncManager) {
+        syncManager.registerServerSyncedAction("ae_config_set", packet -> {
+            int index = packet.readVarInt();
+            if (index < 0 || index >= CONFIG_SIZE) return;
+            var slot = aeItemHandler.getInventory()[index];
+            // Use the carried item from the player opening the UI
+            var player = syncManager.getPlayer();
+            ItemStack held = player.containerMenu.getCarried();
+            if (!held.isEmpty()) {
+                slot.setConfig(GenericStack.fromItemStack(held));
+            }
+        });
+
+        syncManager.registerServerSyncedAction("ae_config_clear", packet -> {
+            int index = packet.readVarInt();
+            if (index < 0 || index >= CONFIG_SIZE) return;
+            aeItemHandler.getInventory()[index].setConfig(null);
+        });
 
-        // Config slots
-        group.addWidget(new AEItemConfigWidget(3, 10, this.aeItemHandler));
+        syncManager.registerServerSyncedAction("ae_config_amount", packet -> {
+            int index = packet.readVarInt();
+            long amount = packet.readVarLong();
+            if (index < 0 || index >= CONFIG_SIZE) return;
+            var slot = aeItemHandler.getInventory()[index];
+            if (slot.getConfig() != null && amount > 0) {
+                slot.setConfig(new GenericStack(slot.getConfig().what(), amount));
+            }
+        });
 
-        return group;
+        syncManager.registerServerSyncedAction("ae_stock_pickup", packet -> {
+            int index = packet.readVarInt();
+            if (index < 0 || index >= CONFIG_SIZE) return;
+            var slot = aeItemHandler.getInventory()[index];
+            if (slot.getStock() != null && slot.getStock().what() instanceof AEItemKey key) {
+                var player = syncManager.getPlayer();
+                if (!player.containerMenu.getCarried().isEmpty()) return;
+                ItemStack stack = new ItemStack(key.getItem());
+                stack.setCount(Math.min((int) slot.getStock().amount(), stack.getMaxStackSize()));
+                if (key.hasTag()) stack.setTag(key.getTag().copy());
+                player.containerMenu.setCarried(stack);
+                GenericStack remaining = ExportOnlyAESlot.copy(slot.getStock(),
+                        Math.max(0, slot.getStock().amount() - stack.getCount()));
+                slot.setStock(remaining.amount() == 0 ? null : remaining);
+            }
+        });
+
+        syncManager.registerServerSyncedAction("ae_config_set_ghost", packet -> {
+            int index = packet.readVarInt();
+            if (index < 0 || index >= CONFIG_SIZE) return;
+            boolean isFluid = packet.readBoolean();
+            if (!isFluid) {
+                ItemStack item = packet.readItem();
+                if (!item.isEmpty()) {
+                    aeItemHandler.getInventory()[index].setConfig(GenericStack.fromItemStack(item));
+                }
+            }
+        });
     }
 
     ////////////////////////////////
diff --git a/src/main/java/com/gregtechceu/gtceu/integration/ae2/machine/MEInputHatchPartMachine.java b/src/main/java/com/gregtechceu/gtceu/integration/ae2/machine/MEInputHatchPartMachine.java
index 02b1410a017..820ac0b5f07 100644
--- a/src/main/java/com/gregtechceu/gtceu/integration/ae2/machine/MEInputHatchPartMachine.java
+++ b/src/main/java/com/gregtechceu/gtceu/integration/ae2/machine/MEInputHatchPartMachine.java
@@ -6,27 +6,33 @@
 import com.gregtechceu.gtceu.api.machine.feature.IHasCircuitSlot;
 import com.gregtechceu.gtceu.api.machine.trait.NotifiableFluidTank;
 import com.gregtechceu.gtceu.common.item.behavior.IntCircuitBehaviour;
-import com.gregtechceu.gtceu.integration.ae2.gui.widget.AEFluidConfigWidget;
+import com.gregtechceu.gtceu.integration.ae2.gui.AEConfigWidget;
 import com.gregtechceu.gtceu.integration.ae2.slot.ExportOnlyAEFluidList;
 import com.gregtechceu.gtceu.integration.ae2.slot.ExportOnlyAEFluidSlot;
+import com.gregtechceu.gtceu.integration.ae2.slot.ExportOnlyAESlot;
+import com.gregtechceu.gtceu.integration.ae2.utils.AEUtil;
 import com.gregtechceu.gtceu.utils.GTMath;
 
-import com.lowdragmc.lowdraglib.gui.widget.LabelWidget;
-import com.lowdragmc.lowdraglib.gui.widget.Widget;
-import com.lowdragmc.lowdraglib.gui.widget.WidgetGroup;
-import com.lowdragmc.lowdraglib.utils.Position;
-
 import net.minecraft.MethodsReturnNonnullByDefault;
 import net.minecraft.nbt.CompoundTag;
 import net.minecraft.network.chat.Component;
 import net.minecraft.world.InteractionResult;
 import net.minecraft.world.entity.player.Player;
 import net.minecraft.world.item.ItemStack;
+import net.minecraftforge.fluids.FluidStack;
+import net.minecraftforge.fluids.FluidUtil;
 import net.minecraftforge.fluids.capability.IFluidHandler;
 
 import appeng.api.config.Actionable;
 import appeng.api.stacks.GenericStack;
 import appeng.api.storage.MEStorage;
+import brachy.modularui.api.drawable.IKey;
+import brachy.modularui.factory.PosGuiData;
+import brachy.modularui.screen.UISettings;
+import brachy.modularui.value.sync.BooleanSyncValue;
+import brachy.modularui.value.sync.PanelSyncManager;
+import brachy.modularui.widget.ParentWidget;
+import brachy.modularui.widgets.layout.Flow;
 
 import javax.annotation.ParametersAreNonnullByDefault;
 
@@ -119,17 +125,65 @@ protected void flushInventory() {
     ///////////////////////////////
 
     @Override
-    public Widget createUIWidget() {
-        WidgetGroup group = new WidgetGroup(new Position(0, 0));
-        // ME Network status
-        group.addWidget(new LabelWidget(3, 0, () -> this.isOnline ?
-                "gtceu.gui.me_network.online" :
-                "gtceu.gui.me_network.offline"));
+    public void buildMainUI(ParentWidget<?> mainWidget, PosGuiData guiData, PanelSyncManager syncManager,
+                            UISettings settings) {
+        BooleanSyncValue isOnlineValue = new BooleanSyncValue(this::isOnline, this::setOnline);
+        syncManager.syncValue("is_online", isOnlineValue);
+
+        registerConfigActions(syncManager);
+
+        var flow = Flow.col().coverChildren();
+
+        flow.child(IKey.dynamic(() -> isOnlineValue.getBoolValue() ?
+                Component.translatable("gtceu.gui.me_network.online") :
+                Component.translatable("gtceu.gui.me_network.offline"))
+                .asWidget().marginTop(2).marginBottom(4));
+        flow.child(new AEConfigWidget(aeFluidHandler, CONFIG_SIZE, false)
+                .syncManager(syncManager)
+                .size(8 * 18, 2 * (18 * 2 + 2)));
+
+        mainWidget.child(flow.center());
+    }
 
-        // Config slots
-        group.addWidget(new AEFluidConfigWidget(3, 10, this.aeFluidHandler));
+    protected void registerConfigActions(PanelSyncManager syncManager) {
+        syncManager.registerServerSyncedAction("ae_config_set", packet -> {
+            int index = packet.readVarInt();
+            if (index < 0 || index >= CONFIG_SIZE) return;
+            var slot = aeFluidHandler.getInventory()[index];
+            var player = syncManager.getPlayer();
+            ItemStack held = player.containerMenu.getCarried();
+            FluidUtil.getFluidContained(held).ifPresent(fluid -> {
+                slot.setConfig(AEUtil.fromFluidStack(fluid));
+            });
+        });
 
-        return group;
+        syncManager.registerServerSyncedAction("ae_config_clear", packet -> {
+            int index = packet.readVarInt();
+            if (index < 0 || index >= CONFIG_SIZE) return;
+            aeFluidHandler.getInventory()[index].setConfig(null);
+        });
+
+        syncManager.registerServerSyncedAction("ae_config_amount", packet -> {
+            int index = packet.readVarInt();
+            long amount = packet.readVarLong();
+            if (index < 0 || index >= CONFIG_SIZE) return;
+            var slot = aeFluidHandler.getInventory()[index];
+            if (slot.getConfig() != null && amount > 0) {
+                slot.setConfig(ExportOnlyAESlot.copy(slot.getConfig(), amount));
+            }
+        });
+
+        syncManager.registerServerSyncedAction("ae_config_set_ghost", packet -> {
+            int index = packet.readVarInt();
+            if (index < 0 || index >= CONFIG_SIZE) return;
+            boolean isFluidGhost = packet.readBoolean();
+            if (isFluidGhost) {
+                FluidStack fluid = FluidStack.readFromPacket(packet);
+                if (!fluid.isEmpty()) {
+                    aeFluidHandler.getInventory()[index].setConfig(AEUtil.fromFluidStack(fluid));
+                }
+            }
+        });
     }
 
     ////////////////////////////////
diff --git a/src/main/java/com/gregtechceu/gtceu/integration/ae2/machine/MEOutputBusPartMachine.java b/src/main/java/com/gregtechceu/gtceu/integration/ae2/machine/MEOutputBusPartMachine.java
index 79c325f6a70..a9684550285 100644
--- a/src/main/java/com/gregtechceu/gtceu/integration/ae2/machine/MEOutputBusPartMachine.java
+++ b/src/main/java/com/gregtechceu/gtceu/integration/ae2/machine/MEOutputBusPartMachine.java
@@ -5,20 +5,29 @@
 import com.gregtechceu.gtceu.api.machine.trait.NotifiableItemStackHandler;
 import com.gregtechceu.gtceu.api.sync_system.annotations.SaveField;
 import com.gregtechceu.gtceu.api.transfer.item.CustomItemStackHandler;
-import com.gregtechceu.gtceu.integration.ae2.gui.widget.list.AEListGridWidget;
+import com.gregtechceu.gtceu.integration.ae2.gui.AEKeyStorageSyncHandler;
+import com.gregtechceu.gtceu.integration.ae2.gui.AEStackDisplayWidget;
+import com.gregtechceu.gtceu.integration.ae2.gui.ScrollPreservingGrid;
 import com.gregtechceu.gtceu.integration.ae2.utils.KeyStorage;
 
-import com.lowdragmc.lowdraglib.gui.widget.LabelWidget;
-import com.lowdragmc.lowdraglib.gui.widget.Widget;
-import com.lowdragmc.lowdraglib.gui.widget.WidgetGroup;
-
 import net.minecraft.MethodsReturnNonnullByDefault;
+import net.minecraft.network.chat.Component;
 import net.minecraft.world.item.ItemStack;
 
 import appeng.api.config.Actionable;
 import appeng.api.stacks.AEItemKey;
+import brachy.modularui.api.drawable.IKey;
+import brachy.modularui.factory.PosGuiData;
+import brachy.modularui.screen.UISettings;
+import brachy.modularui.value.sync.BooleanSyncValue;
+import brachy.modularui.value.sync.DynamicLinkedSyncHandler;
+import brachy.modularui.value.sync.PanelSyncManager;
+import brachy.modularui.widget.ParentWidget;
+import brachy.modularui.widget.scroll.VerticalScrollData;
+import brachy.modularui.widgets.DynamicSyncedWidget;
+import brachy.modularui.widgets.TextWidget;
+import brachy.modularui.widgets.layout.Flow;
 import lombok.NoArgsConstructor;
-import org.jetbrains.annotations.NotNull;
 
 import java.util.Collections;
 import java.util.List;
@@ -86,17 +95,40 @@ public void autoIO() {
     ///////////////////////////////
 
     @Override
-    public Widget createUIWidget() {
-        WidgetGroup group = new WidgetGroup(0, 0, 170, 65);
-        // ME Network status
-        group.addWidget(new LabelWidget(5, 0, () -> this.isOnline ?
-                "gtceu.gui.me_network.online" :
-                "gtceu.gui.me_network.offline"));
-        group.addWidget(new LabelWidget(5, 10, "gtceu.gui.waiting_list"));
-        // display list
-        group.addWidget(new AEListGridWidget.Item(5, 20, 3, this.internalBuffer));
-
-        return group;
+    public void buildMainUI(ParentWidget<?> mainWidget, PosGuiData guiData, PanelSyncManager syncManager,
+                            UISettings settings) {
+        BooleanSyncValue isOnlineValue = new BooleanSyncValue(this::isOnline, this::setOnline);
+        syncManager.syncValue("is_online", isOnlineValue);
+
+        var flow = Flow.col().coverChildren();
+
+        flow.child(IKey.dynamic(() -> isOnlineValue.getBoolValue() ?
+                Component.translatable("gtceu.gui.me_network.online") :
+                Component.translatable("gtceu.gui.me_network.offline"))
+                .asWidget().marginTop(2).marginBottom(4));
+
+        var storageSyncHandler = new AEKeyStorageSyncHandler(internalBuffer);
+        syncManager.syncValue("ae_output_display", storageSyncHandler);
+
+        int[] savedScroll = { 0 };
+        var dynamicHandler = new DynamicLinkedSyncHandler<>(storageSyncHandler)
+                .widgetProvider((sm, value) -> {
+                    var col = Flow.col().leftRel(0.5f).coverChildrenHeight();
+                    var list = value.getValue();
+                    if (list.isEmpty()) return col.child(new TextWidget<>(IKey.lang("gtceu.gui.waiting_list_empty")));
+                    col.child(new TextWidget<>(IKey.lang("gtceu.gui.waiting_list")).margin(0, 2));
+                    col.child(new ScrollPreservingGrid(savedScroll)
+                            .size(167, 80)
+                            .scrollable(new VerticalScrollData())
+                            .mapTo(9, list, (index, stack) -> new AEStackDisplayWidget(list, index)));
+                    return col;
+                });
+
+        flow.child(new DynamicSyncedWidget<>()
+                .syncHandler(dynamicHandler)
+                .size(167, 80));
+
+        mainWidget.child(flow);
     }
 
     private class InaccessibleInfiniteHandler extends NotifiableItemStackHandler {
@@ -107,7 +139,7 @@ public InaccessibleInfiniteHandler() {
         }
 
         @Override
-        public @NotNull List<Object> getContents() {
+        public List<Object> getContents() {
             return Collections.emptyList();
         }
 
diff --git a/src/main/java/com/gregtechceu/gtceu/integration/ae2/machine/MEOutputHatchPartMachine.java b/src/main/java/com/gregtechceu/gtceu/integration/ae2/machine/MEOutputHatchPartMachine.java
index 4dd7495ae37..f06e0059677 100644
--- a/src/main/java/com/gregtechceu/gtceu/integration/ae2/machine/MEOutputHatchPartMachine.java
+++ b/src/main/java/com/gregtechceu/gtceu/integration/ae2/machine/MEOutputHatchPartMachine.java
@@ -8,19 +8,29 @@
 import com.gregtechceu.gtceu.api.recipe.ingredient.FluidIngredient;
 import com.gregtechceu.gtceu.api.sync_system.annotations.SaveField;
 import com.gregtechceu.gtceu.api.transfer.fluid.CustomFluidTank;
-import com.gregtechceu.gtceu.integration.ae2.gui.widget.list.AEListGridWidget;
+import com.gregtechceu.gtceu.integration.ae2.gui.AEKeyStorageSyncHandler;
+import com.gregtechceu.gtceu.integration.ae2.gui.AEStackDisplayWidget;
+import com.gregtechceu.gtceu.integration.ae2.gui.ScrollPreservingGrid;
 import com.gregtechceu.gtceu.integration.ae2.utils.KeyStorage;
 import com.gregtechceu.gtceu.utils.GTMath;
 
-import com.lowdragmc.lowdraglib.gui.widget.LabelWidget;
-import com.lowdragmc.lowdraglib.gui.widget.Widget;
-import com.lowdragmc.lowdraglib.gui.widget.WidgetGroup;
-
 import net.minecraft.MethodsReturnNonnullByDefault;
+import net.minecraft.network.chat.Component;
 import net.minecraftforge.fluids.FluidStack;
 
 import appeng.api.config.Actionable;
 import appeng.api.stacks.AEFluidKey;
+import brachy.modularui.api.drawable.IKey;
+import brachy.modularui.factory.PosGuiData;
+import brachy.modularui.screen.UISettings;
+import brachy.modularui.value.sync.BooleanSyncValue;
+import brachy.modularui.value.sync.DynamicLinkedSyncHandler;
+import brachy.modularui.value.sync.PanelSyncManager;
+import brachy.modularui.widget.ParentWidget;
+import brachy.modularui.widget.scroll.VerticalScrollData;
+import brachy.modularui.widgets.DynamicSyncedWidget;
+import brachy.modularui.widgets.TextWidget;
+import brachy.modularui.widgets.layout.Flow;
 import org.jetbrains.annotations.Nullable;
 
 import java.util.Collections;
@@ -87,17 +97,40 @@ protected void autoIO() {
     ///////////////////////////////
 
     @Override
-    public Widget createUIWidget() {
-        WidgetGroup group = new WidgetGroup(0, 0, 170, 65);
-        // ME Network status
-        group.addWidget(new LabelWidget(5, 0, () -> this.isOnline ?
-                "gtceu.gui.me_network.online" :
-                "gtceu.gui.me_network.offline"));
-        group.addWidget(new LabelWidget(5, 10, "gtceu.gui.waiting_list"));
-        // display list
-        group.addWidget(new AEListGridWidget.Fluid(5, 20, 3, this.internalBuffer));
-
-        return group;
+    public void buildMainUI(ParentWidget<?> mainWidget, PosGuiData guiData, PanelSyncManager syncManager,
+                            UISettings settings) {
+        BooleanSyncValue isOnlineValue = new BooleanSyncValue(this::isOnline, this::setOnline);
+        syncManager.syncValue("is_online", isOnlineValue);
+
+        var flow = Flow.col().coverChildren();
+
+        flow.child(IKey.dynamic(() -> isOnlineValue.getBoolValue() ?
+                Component.translatable("gtceu.gui.me_network.online") :
+                Component.translatable("gtceu.gui.me_network.offline"))
+                .asWidget().marginTop(2).marginBottom(4));
+
+        var storageSyncHandler = new AEKeyStorageSyncHandler(internalBuffer);
+        syncManager.syncValue("ae_output_display", storageSyncHandler);
+
+        int[] savedScroll = { 0 };
+        var dynamicHandler = new DynamicLinkedSyncHandler<>(storageSyncHandler)
+                .widgetProvider((sm, value) -> {
+                    var col = Flow.col().leftRel(0.5f).coverChildrenHeight();
+                    var list = value.getValue();
+                    if (list.isEmpty()) return col.child(new TextWidget<>(IKey.lang("gtceu.gui.waiting_list_empty")));
+                    col.child(new TextWidget<>(IKey.lang("gtceu.gui.waiting_list")).margin(0, 2));
+                    col.child(new ScrollPreservingGrid(savedScroll)
+                            .size(167, 80)
+                            .scrollable(new VerticalScrollData())
+                            .mapTo(9, list, (index, stack) -> new AEStackDisplayWidget(list, index)));
+                    return col;
+                });
+
+        flow.child(new DynamicSyncedWidget<>()
+                .syncHandler(dynamicHandler)
+                .size(167, 80));
+
+        mainWidget.child(flow);
     }
 
     private class InaccessibleInfiniteTank extends NotifiableFluidTank {
diff --git a/src/main/java/com/gregtechceu/gtceu/integration/ae2/machine/MEPatternBufferPartMachine.java b/src/main/java/com/gregtechceu/gtceu/integration/ae2/machine/MEPatternBufferPartMachine.java
index 0d7ff36cbfa..4987b3349bb 100644
--- a/src/main/java/com/gregtechceu/gtceu/integration/ae2/machine/MEPatternBufferPartMachine.java
+++ b/src/main/java/com/gregtechceu/gtceu/integration/ae2/machine/MEPatternBufferPartMachine.java
@@ -2,16 +2,11 @@
 
 import com.gregtechceu.gtceu.api.blockentity.BlockEntityCreationInfo;
 import com.gregtechceu.gtceu.api.capability.recipe.IO;
-import com.gregtechceu.gtceu.api.gui.GuiTextures;
-import com.gregtechceu.gtceu.api.gui.fancy.ConfiguratorPanel;
 import com.gregtechceu.gtceu.api.machine.MetaMachine;
 import com.gregtechceu.gtceu.api.machine.MultiblockMachineDefinition;
 import com.gregtechceu.gtceu.api.machine.TickableSubscription;
-import com.gregtechceu.gtceu.api.machine.fancyconfigurator.ButtonConfigurator;
-import com.gregtechceu.gtceu.api.machine.fancyconfigurator.CircuitFancyConfigurator;
-import com.gregtechceu.gtceu.api.machine.fancyconfigurator.FancyInvConfigurator;
-import com.gregtechceu.gtceu.api.machine.fancyconfigurator.FancyTankConfigurator;
 import com.gregtechceu.gtceu.api.machine.feature.IDataStickInteractable;
+import com.gregtechceu.gtceu.api.machine.mui.MachineUIPanelBuilder;
 import com.gregtechceu.gtceu.api.machine.multiblock.MultiblockControllerMachine;
 import com.gregtechceu.gtceu.api.machine.trait.NotifiableFluidTank;
 import com.gregtechceu.gtceu.api.machine.trait.NotifiableItemStackHandler;
@@ -23,18 +18,13 @@
 import com.gregtechceu.gtceu.api.transfer.item.CustomItemStackHandler;
 import com.gregtechceu.gtceu.common.data.machines.GTAEMachines;
 import com.gregtechceu.gtceu.common.item.behavior.IntCircuitBehaviour;
-import com.gregtechceu.gtceu.integration.ae2.gui.widget.AETextInputButtonWidget;
-import com.gregtechceu.gtceu.integration.ae2.gui.widget.slot.AEPatternViewSlotWidget;
+import com.gregtechceu.gtceu.common.mui.GTGuiTextures;
+import com.gregtechceu.gtceu.common.mui.GTMuiMachineUtil;
+import com.gregtechceu.gtceu.common.mui.widgets.PopupPanel;
 import com.gregtechceu.gtceu.integration.ae2.machine.trait.InternalSlotRecipeHandler;
 import com.gregtechceu.gtceu.utils.GTMath;
 import com.gregtechceu.gtceu.utils.ItemStackHashStrategy;
 
-import com.lowdragmc.lowdraglib.gui.texture.GuiTextureGroup;
-import com.lowdragmc.lowdraglib.gui.util.ClickData;
-import com.lowdragmc.lowdraglib.gui.widget.LabelWidget;
-import com.lowdragmc.lowdraglib.gui.widget.Widget;
-import com.lowdragmc.lowdraglib.gui.widget.WidgetGroup;
-
 import net.minecraft.MethodsReturnNonnullByDefault;
 import net.minecraft.core.BlockPos;
 import net.minecraft.nbt.CompoundTag;
@@ -44,6 +34,7 @@
 import net.minecraft.world.InteractionResult;
 import net.minecraft.world.entity.player.Player;
 import net.minecraft.world.item.ItemStack;
+import net.minecraft.world.item.Items;
 import net.minecraft.world.item.crafting.Ingredient;
 import net.minecraftforge.common.util.INBTSerializable;
 import net.minecraftforge.fluids.FluidStack;
@@ -62,8 +53,27 @@
 import appeng.crafting.pattern.EncodedPatternItem;
 import appeng.crafting.pattern.ProcessingPatternItem;
 import appeng.helpers.patternprovider.PatternContainer;
+import brachy.modularui.api.IPanelHandler;
+import brachy.modularui.api.drawable.IKey;
+import brachy.modularui.drawable.DrawableStack;
+import brachy.modularui.drawable.DynamicDrawable;
+import brachy.modularui.drawable.ItemDrawable;
+import brachy.modularui.factory.PosGuiData;
+import brachy.modularui.screen.RichTooltip;
+import brachy.modularui.screen.UISettings;
+import brachy.modularui.value.sync.BooleanSyncValue;
+import brachy.modularui.value.sync.PanelSyncManager;
+import brachy.modularui.value.sync.SyncHandlers;
+import brachy.modularui.widget.ParentWidget;
+import brachy.modularui.widgets.ButtonWidget;
+import brachy.modularui.widgets.layout.Flow;
+import brachy.modularui.widgets.layout.Grid;
+import brachy.modularui.widgets.slot.ItemSlot;
+import brachy.modularui.widgets.slot.SlotGroup;
+import brachy.modularui.widgets.textfield.TextFieldWidget;
 import com.google.common.collect.BiMap;
 import com.google.common.collect.HashBiMap;
+import com.mojang.blaze3d.platform.InputConstants;
 import it.unimi.dsi.fastutil.objects.*;
 import lombok.Getter;
 import lombok.Setter;
@@ -71,10 +81,7 @@
 import org.jetbrains.annotations.UnmodifiableView;
 import org.jetbrains.annotations.VisibleForTesting;
 
-import java.util.ArrayList;
-import java.util.Collections;
-import java.util.List;
-import java.util.Set;
+import java.util.*;
 
 import javax.annotation.ParametersAreNonnullByDefault;
 
@@ -182,7 +189,7 @@ public boolean isWorkingEnabled() {
     public void setCustomName(String newName) {
         customName = newName;
         syncDataHolder.markClientSyncFieldDirty("customName");
-        markAsDirty();
+        markAsChanged();
     }
 
     @Override
@@ -241,11 +248,9 @@ public Set<MEPatternBufferProxyPartMachine> getProxies() {
         return Collections.unmodifiableSet(proxyMachines);
     }
 
-    private void refundAll(ClickData clickData) {
-        if (!clickData.isRemote) {
-            for (InternalSlot internalSlot : internalInventory) {
-                internalSlot.refund();
-            }
+    private void refundAll() {
+        for (InternalSlot internalSlot : internalInventory) {
+            internalSlot.refund();
         }
     }
 
@@ -269,63 +274,150 @@ public void onPatternChange(int index) {
     //////////////////////////////////////
     // ********** GUI ***********//
     //////////////////////////////////////
+
     @Override
-    public void attachConfigurators(ConfiguratorPanel configuratorPanel) {
-        configuratorPanel.attachConfigurators(new ButtonConfigurator(
-                new GuiTextureGroup(GuiTextures.BUTTON, GuiTextures.REFUND_OVERLAY), this::refundAll)
-                .setTooltips(List.of(Component.translatable("gui.gtceu.refund_all.desc"))));
-        if (isHasCircuitSlot() && isCircuitSlotEnabled()) {
-            configuratorPanel.attachConfigurators(new CircuitFancyConfigurator(circuitInventory.storage));
-        }
-        configuratorPanel.attachConfigurators(new FancyInvConfigurator(
-                shareInventory.storage, Component.translatable("gui.gtceu.share_inventory.title"))
-                .setTooltips(List.of(
-                        Component.translatable("gui.gtceu.share_inventory.desc.0"),
-                        Component.translatable("gui.gtceu.share_inventory.desc.1"))));
-        configuratorPanel.attachConfigurators(new FancyTankConfigurator(
-                shareTank.getStorages(), Component.translatable("gui.gtceu.share_tank.title"))
-                .setTooltips(List.of(
-                        Component.translatable("gui.gtceu.share_tank.desc.0"),
-                        Component.translatable("gui.gtceu.share_inventory.desc.1"))));
+    public MachineUIPanelBuilder getPanelBuilder(PosGuiData data, PanelSyncManager syncManager, UISettings settings) {
+        IPanelHandler renamingPanelHandler = syncManager.syncedPanel("renaming", true,
+                ((syncManager1, syncHandler) -> PopupPanel.createPopupPanel("renaming_panel", 110, 40)
+                        .child(Flow.col()
+                                .coverChildren()
+                                .child(IKey.lang("gtceu.gui.pattern_buffer.set_custom_name").asWidget())
+                                .child(new TextFieldWidget()
+                                        .size(90, 20)
+                                        .value(SyncHandlers.string(() -> this.customName, this::setCustomName)))
+                                .margin(5))));
+
+        IPanelHandler sharedItemsPanelHandler = syncManager.syncedPanel("shared_items", true,
+                (syncManager1, panelHandler) -> {
+                    SlotGroup sharedItemSlotGroup = new SlotGroup("shared_item_slots", 3, false);
+
+                    return PopupPanel.createPopupPanel("shared_items_panel", 80, 86)
+                            .child(IKey.lang("gui.gtceu.share_inventory.title").asWidget().margin(4))
+                            .child(new Grid()
+                                    .name("shared_item_grid")
+                                    .top(26)
+                                    .height(18 * 3)
+                                    .minElementMargin(0, 0)
+                                    .minColWidth(18).minRowHeight(18)
+                                    .leftRel(0.5f)
+                                    .mapTo(3, 9, index -> new ItemSlot()
+                                            .slot(SyncHandlers.itemSlot(shareInventory, index)
+                                                    .slotGroup(sharedItemSlotGroup)
+                                                    .accessibility(true, true))));
+                });
+
+        IPanelHandler sharedFluidsPanelHandler = syncManager.syncedPanel("shared_fluids", true,
+                (syncManager1, panelHandler) -> PopupPanel.createPopupPanel("shared_fluids_panel", 85, 86)
+                        .child(IKey.lang("gui.gtceu.share_tank.title").asWidget().margin(4))
+                        .child(GTMuiMachineUtil.createSlotGroupFromInventory(syncManager1, shareTank,
+                                "shared_fluid_slots", 9, 'F',
+                                GTMuiMachineUtil.createSquareMatrix(9, 'F'))
+                                .top(26)
+                                .leftRel(0.5f)));
+
+        BooleanSyncValue canRefundValue = SyncHandlers.bool(this::canRefund, b -> {});
+        syncManager.syncValue("can_refund", canRefundValue);
+
+        syncManager.registerServerSyncedAction("refundButtonPressed", packet -> refundAll());
+
+        return MachineUIPanelBuilder.defaultPanelBuilder(this).leftConfigurators(f -> {
+            f.child(new ButtonWidget<>() // Shared items subpanel
+                    .size(18)
+                    .onMousePressed((x, y, b) -> {
+                        if (b == InputConstants.MOUSE_BUTTON_LEFT) {
+                            sharedItemsPanelHandler.openPanel();
+                            return true;
+                        }
+                        return false;
+                    })
+                    .overlay(GTGuiTextures.BUTTON_ITEM_OUTPUT)
+                    .tooltip(new RichTooltip()
+                            .addLine(IKey.lang("gui.gtceu.share_inventory.desc.0"))
+                            .addLine(IKey.lang("gui.gtceu.share_inventory.desc.1"))))
+                    .child(new ButtonWidget<>() // Shared fluids subpanel
+                            .size(18)
+                            .onMousePressed((x, y, b) -> {
+                                if (b == InputConstants.MOUSE_BUTTON_LEFT) {
+                                    sharedFluidsPanelHandler.openPanel();
+                                    return true;
+                                }
+                                return false;
+                            })
+                            .overlay(GTGuiTextures.BUTTON_FLUID_OUTPUT)
+                            .tooltip(new RichTooltip()
+                                    .addLine(IKey.lang("gui.gtceu.share_tank.desc.0"))
+                                    .addLine(IKey.lang("gui.gtceu.share_inventory.desc.1"))))
+                    .child(new ButtonWidget<>() // Refund button
+                            .size(18)
+                            .onMousePressed((x, y, b) -> {
+                                if (canRefundValue.getBoolValue() && b == InputConstants.MOUSE_BUTTON_LEFT) {
+                                    syncManager.callSyncedAction("refundButtonPressed");
+                                    return true;
+                                }
+                                return false;
+                            })
+                            .overlay(new DynamicDrawable(() -> {
+                                if (canRefundValue.getBoolValue()) {
+                                    return GTGuiTextures.REFUND_OVERLAY
+                                            .asIcon().size(16);
+                                } else {
+                                    return new DrawableStack(GTGuiTextures.REFUND_OVERLAY,
+                                            new ItemDrawable(Items.BARRIER))
+                                            .asIcon().size(16);
+                                }
+                            }))
+                            .tooltip(new RichTooltip()
+                                    .addLine(IKey.lang("gui.gtceu.refund_all.desc"))))
+                    .child(new ButtonWidget<>() // Renaming button
+                            .size(18)
+                            .onMousePressed((x, y, b) -> {
+                                if (b == InputConstants.MOUSE_BUTTON_LEFT) {
+                                    renamingPanelHandler.openPanel();
+                                    return true;
+                                }
+                                return false;
+                            })
+                            .overlay(IKey.str("✎")
+                                    .asIcon()
+                                    .size(16))
+                            .tooltip(new RichTooltip()
+                                    .addLine(IKey.lang("gui.gtceu.rename.desc"))));
+        });
     }
 
     @Override
-    public Widget createUIWidget() {
-        int rowSize = 9;
-        int colSize = 3;
-        var group = new WidgetGroup(0, 0, 18 * rowSize + 16, 18 * colSize + 16);
-        int index = 0;
-        for (int y = 0; y < colSize; ++y) {
-            for (int x = 0; x < rowSize; ++x) {
-                int finalI = index;
-                var slot = new AEPatternViewSlotWidget(patternInventory, index++, 8 + x * 18, 14 + y * 18)
-                        .setOccupiedTexture(GuiTextures.SLOT)
-                        .setItemHook(stack -> {
-                            if (!stack.isEmpty() && stack.getItem() instanceof EncodedPatternItem iep) {
-                                final ItemStack out = iep.getOutput(stack);
-                                if (!out.isEmpty()) {
-                                    return out;
-                                }
-                            }
-                            return stack;
-                        })
-                        .setChangeListener(() -> onPatternChange(finalI))
-                        .setBackground(GuiTextures.SLOT, GuiTextures.PATTERN_OVERLAY);
-                group.addWidget(slot);
-            }
-        }
-        // ME Network status
-        group.addWidget(new LabelWidget(
-                8,
-                2,
-                () -> this.isOnline ? "gtceu.gui.me_network.online" : "gtceu.gui.me_network.offline"));
-
-        group.addWidget(new AETextInputButtonWidget(18 * rowSize + 8 - 70, 2, 70, 10)
-                .setText(customName)
-                .setOnConfirm(this::setCustomName)
-                .setButtonTooltips(Component.translatable("gui.gtceu.rename.desc")));
-
-        return group;
+    public void buildMainUI(ParentWidget<?> mainWidget, PosGuiData guiData, PanelSyncManager syncManager,
+                            UISettings settings) {
+        SlotGroup patternSlotGroup = new SlotGroup("pattern_slots", 9, 0, true);
+
+        BooleanSyncValue isOnlineValue = new BooleanSyncValue(this::isOnline, this::setOnline);
+        syncManager.syncValue("is_online", isOnlineValue);
+
+        var flow = Flow.col().coverChildren();
+
+        flow.child(IKey.dynamic(() -> isOnlineValue.getBoolValue() ?
+                Component.translatable("gtceu.gui.me_network.online") :
+                Component.translatable("gtceu.gui.me_network.offline"))
+                .asWidget().marginTop(2).marginBottom(4));
+
+        flow.child(new Grid()
+                .height(18 * (MAX_PATTERN_COUNT / 9))
+                .minElementMargin(0, 0)
+                .minColWidth(18).minRowHeight(18)
+                .leftRel(0.5f)
+                .mapTo(9, MAX_PATTERN_COUNT, index -> new ItemSlot()
+                        .slot(SyncHandlers.itemSlot(patternInventory, index)
+                                .slotGroup(patternSlotGroup)
+                                .accessibility(true, true)
+                                .filter(stack -> stack.getItem() instanceof EncodedPatternItem)
+                                .changeListener((i, o, c, init) -> onPatternChange(index)))
+                        .background(GTGuiTextures.SLOT, GTGuiTextures.PATTERN_OVERLAY)));
+
+        mainWidget.child(flow.center());
+    }
+
+    public boolean canRefund() {
+        return Arrays.stream(internalInventory).anyMatch(slot -> !slot.isEmpty());
     }
 
     @Override
@@ -462,6 +554,10 @@ public boolean isFluidEmpty() {
             return fluidInventory.isEmpty();
         }
 
+        public boolean isEmpty() {
+            return isItemEmpty() && isFluidEmpty();
+        }
+
         public void onContentsChanged() {
             itemStacks = null;
             fluidStacks = null;
diff --git a/src/main/java/com/gregtechceu/gtceu/integration/ae2/machine/MEPatternBufferProxyPartMachine.java b/src/main/java/com/gregtechceu/gtceu/integration/ae2/machine/MEPatternBufferProxyPartMachine.java
index aefb82537cd..e1a0151edc9 100644
--- a/src/main/java/com/gregtechceu/gtceu/integration/ae2/machine/MEPatternBufferProxyPartMachine.java
+++ b/src/main/java/com/gregtechceu/gtceu/integration/ae2/machine/MEPatternBufferProxyPartMachine.java
@@ -5,14 +5,13 @@
 import com.gregtechceu.gtceu.api.capability.recipe.IO;
 import com.gregtechceu.gtceu.api.machine.MetaMachine;
 import com.gregtechceu.gtceu.api.machine.feature.IDataStickInteractable;
+import com.gregtechceu.gtceu.api.machine.mui.MachineUIPanelBuilder;
 import com.gregtechceu.gtceu.api.machine.multiblock.part.TieredIOPartMachine;
 import com.gregtechceu.gtceu.api.machine.trait.RecipeHandlerList;
 import com.gregtechceu.gtceu.api.sync_system.annotations.SaveField;
 import com.gregtechceu.gtceu.api.sync_system.annotations.SyncToClient;
 import com.gregtechceu.gtceu.integration.ae2.machine.trait.ProxySlotRecipeHandler;
 
-import com.lowdragmc.lowdraglib.gui.modular.ModularUI;
-
 import net.minecraft.MethodsReturnNonnullByDefault;
 import net.minecraft.core.BlockPos;
 import net.minecraft.nbt.Tag;
@@ -22,6 +21,10 @@
 import net.minecraft.world.item.ItemStack;
 import net.minecraft.world.phys.BlockHitResult;
 
+import brachy.modularui.factory.PosGuiData;
+import brachy.modularui.screen.UISettings;
+import brachy.modularui.value.sync.PanelSyncManager;
+import brachy.modularui.widget.ParentWidget;
 import lombok.Getter;
 import org.jetbrains.annotations.Nullable;
 
@@ -88,9 +91,16 @@ public boolean shouldOpenUI(Player player, InteractionHand hand, BlockHitResult
     }
 
     @Override
-    public ModularUI createUI(Player entityPlayer) {
-        assert getBuffer() != null; // UI should never be able to be opened when buffer is null
-        return getBuffer().createUI(entityPlayer);
+    public MachineUIPanelBuilder getPanelBuilder(PosGuiData data, PanelSyncManager syncManager, UISettings settings) {
+        assert getBuffer() != null;
+        return getBuffer().getPanelBuilder(data, syncManager, settings);
+    }
+
+    @Override
+    public void buildMainUI(ParentWidget<?> mainWidget, PosGuiData guiData, PanelSyncManager syncManager,
+                            UISettings settings) {
+        assert getBuffer() != null;
+        getBuffer().buildMainUI(mainWidget, guiData, syncManager, settings);
     }
 
     @Override
diff --git a/src/main/java/com/gregtechceu/gtceu/integration/ae2/machine/MEStockingBusPartMachine.java b/src/main/java/com/gregtechceu/gtceu/integration/ae2/machine/MEStockingBusPartMachine.java
index 55b6bd90570..10f10aefa39 100644
--- a/src/main/java/com/gregtechceu/gtceu/integration/ae2/machine/MEStockingBusPartMachine.java
+++ b/src/main/java/com/gregtechceu/gtceu/integration/ae2/machine/MEStockingBusPartMachine.java
@@ -1,9 +1,6 @@
 package com.gregtechceu.gtceu.integration.ae2.machine;
 
 import com.gregtechceu.gtceu.api.blockentity.BlockEntityCreationInfo;
-import com.gregtechceu.gtceu.api.gui.fancy.ConfiguratorPanel;
-import com.gregtechceu.gtceu.api.gui.fancy.TabsWidget;
-import com.gregtechceu.gtceu.api.machine.fancyconfigurator.AutoStockingFancyConfigurator;
 import com.gregtechceu.gtceu.api.machine.feature.multiblock.IMultiPart;
 import com.gregtechceu.gtceu.api.machine.multiblock.MultiblockControllerMachine;
 import com.gregtechceu.gtceu.api.machine.trait.NotifiableItemStackHandler;
@@ -126,10 +123,12 @@ protected void syncME() {
         }
     }
 
-    @Override
-    public void attachSideTabs(TabsWidget sideTabs) {
-        sideTabs.setMainTab(this); // removes the cover configurator, it's pointless and clashes with layout.
-    }
+    /*
+     * @Override
+     * public void attachSideTabs(TabsWidget sideTabs) {
+     * sideTabs.setMainTab(this); // removes the cover configurator, it's pointless and clashes with layout.
+     * }
+     */
 
     @Override
     protected void flushInventory() {
@@ -251,17 +250,6 @@ private void refreshList() {
         aeItemHandler.clearInventory(index);
     }
 
-    ///////////////////////////////
-    // ********** GUI ***********//
-    ///////////////////////////////
-
-    @Override
-    public void attachConfigurators(ConfiguratorPanel configuratorPanel) {
-        IMEStockingPart.super.attachConfigurators(configuratorPanel);
-        super.attachConfigurators(configuratorPanel);
-        configuratorPanel.attachConfigurators(new AutoStockingFancyConfigurator(this));
-    }
-
     @Override
     protected InteractionResult onScrewdriverClick(ExtendedUseOnContext context) {
         if (!isRemote()) {
diff --git a/src/main/java/com/gregtechceu/gtceu/integration/ae2/machine/MEStockingHatchPartMachine.java b/src/main/java/com/gregtechceu/gtceu/integration/ae2/machine/MEStockingHatchPartMachine.java
index fdf58e578be..d82b46c2a68 100644
--- a/src/main/java/com/gregtechceu/gtceu/integration/ae2/machine/MEStockingHatchPartMachine.java
+++ b/src/main/java/com/gregtechceu/gtceu/integration/ae2/machine/MEStockingHatchPartMachine.java
@@ -1,10 +1,7 @@
 package com.gregtechceu.gtceu.integration.ae2.machine;
 
 import com.gregtechceu.gtceu.api.blockentity.BlockEntityCreationInfo;
-import com.gregtechceu.gtceu.api.gui.fancy.ConfiguratorPanel;
-import com.gregtechceu.gtceu.api.gui.fancy.TabsWidget;
 import com.gregtechceu.gtceu.api.machine.MetaMachine;
-import com.gregtechceu.gtceu.api.machine.fancyconfigurator.AutoStockingFancyConfigurator;
 import com.gregtechceu.gtceu.api.machine.feature.multiblock.IMultiPart;
 import com.gregtechceu.gtceu.api.machine.multiblock.MultiblockControllerMachine;
 import com.gregtechceu.gtceu.api.machine.trait.NotifiableFluidTank;
@@ -129,10 +126,12 @@ protected void syncME() {
         }
     }
 
-    @Override
-    public void attachSideTabs(TabsWidget sideTabs) {
-        sideTabs.setMainTab(this); // removes the cover configurator, it's pointless and clashes with layout.
-    }
+    /*
+     * @Override
+     * public void attachSideTabs(TabsWidget sideTabs) {
+     * sideTabs.setMainTab(this); // removes the cover configurator, it's pointless and clashes with layout.
+     * }
+     */
 
     @Override
     protected void flushInventory() {
@@ -235,17 +234,6 @@ private void refreshList() {
         aeFluidHandler.clearInventory(index);
     }
 
-    ///////////////////////////////
-    // ********** GUI ***********//
-    ///////////////////////////////
-
-    @Override
-    public void attachConfigurators(ConfiguratorPanel configuratorPanel) {
-        IMEStockingPart.super.attachConfigurators(configuratorPanel);
-        super.attachConfigurators(configuratorPanel);
-        configuratorPanel.attachConfigurators(new AutoStockingFancyConfigurator(this));
-    }
-
     ////////////////////////////////
     // ******* Interaction *******//
     ////////////////////////////////
diff --git a/src/main/java/com/gregtechceu/gtceu/integration/ae2/machine/feature/multiblock/IAutoPullPart.java b/src/main/java/com/gregtechceu/gtceu/integration/ae2/machine/feature/multiblock/IAutoPullPart.java
index cc6db1d8336..9b95de5957e 100644
--- a/src/main/java/com/gregtechceu/gtceu/integration/ae2/machine/feature/multiblock/IAutoPullPart.java
+++ b/src/main/java/com/gregtechceu/gtceu/integration/ae2/machine/feature/multiblock/IAutoPullPart.java
@@ -1,15 +1,9 @@
 package com.gregtechceu.gtceu.integration.ae2.machine.feature.multiblock;
 
-import com.gregtechceu.gtceu.api.gui.GuiTextures;
-import com.gregtechceu.gtceu.api.gui.fancy.ConfiguratorPanel;
-import com.gregtechceu.gtceu.api.gui.fancy.IFancyConfiguratorButton;
 import com.gregtechceu.gtceu.api.machine.feature.multiblock.IMultiPart;
 
-import net.minecraft.network.chat.Component;
-
 import appeng.api.stacks.GenericStack;
 
-import java.util.List;
 import java.util.function.Predicate;
 
 public interface IAutoPullPart extends IMultiPart {
@@ -20,13 +14,15 @@ public interface IAutoPullPart extends IMultiPart {
 
     void setAutoPullTest(Predicate<GenericStack> test);
 
-    @Override
-    default void attachConfigurators(ConfiguratorPanel configuratorPanel) {
-        configuratorPanel.attachConfigurators(new IFancyConfiguratorButton.Toggle(
-                GuiTextures.BUTTON_AUTO_PULL.getSubTexture(0, 0, 1, 0.5),
-                GuiTextures.BUTTON_AUTO_PULL.getSubTexture(0, 0.5, 1, 0.5),
-                this::isAutoPull,
-                (clickData, pressed) -> setAutoPull(pressed))
-                .setTooltipsSupplier(pressed -> List.of(Component.translatable("gtceu.gui.me_bus.auto_pull_button"))));
-    }
+    /*
+     * @Override
+     * default void attachConfigurators(ConfiguratorPanel configuratorPanel) {
+     * configuratorPanel.attachConfigurators(new IFancyConfiguratorButton.Toggle(
+     * GuiTextures.BUTTON_AUTO_PULL.getSubTexture(0, 0, 1, 0.5),
+     * GuiTextures.BUTTON_AUTO_PULL.getSubTexture(0, 0.5, 1, 0.5),
+     * this::isAutoPull,
+     * (clickData, pressed) -> setAutoPull(pressed))
+     * .setTooltipsSupplier(pressed -> List.of(Component.translatable("gtceu.gui.me_bus.auto_pull_button"))));
+     * }
+     */
 }
diff --git a/src/main/java/com/gregtechceu/gtceu/integration/ae2/machine/feature/multiblock/IMEStockingPart.java b/src/main/java/com/gregtechceu/gtceu/integration/ae2/machine/feature/multiblock/IMEStockingPart.java
index b24d6f036d1..e4f72dce81e 100644
--- a/src/main/java/com/gregtechceu/gtceu/integration/ae2/machine/feature/multiblock/IMEStockingPart.java
+++ b/src/main/java/com/gregtechceu/gtceu/integration/ae2/machine/feature/multiblock/IMEStockingPart.java
@@ -1,12 +1,29 @@
 package com.gregtechceu.gtceu.integration.ae2.machine.feature.multiblock;
 
+import com.gregtechceu.gtceu.api.machine.mui.MachineUIPanelBuilder;
 import com.gregtechceu.gtceu.api.machine.multiblock.MultiblockControllerMachine;
+import com.gregtechceu.gtceu.common.data.GTItems;
+import com.gregtechceu.gtceu.common.mui.GTGuiTextures;
+import com.gregtechceu.gtceu.common.mui.widgets.PopupPanel;
 import com.gregtechceu.gtceu.integration.ae2.slot.IConfigurableSlotList;
 
 import net.minecraft.server.TickTask;
 import net.minecraft.server.level.ServerLevel;
 
 import appeng.api.stacks.GenericStack;
+import brachy.modularui.api.IPanelHandler;
+import brachy.modularui.api.drawable.IKey;
+import brachy.modularui.drawable.ItemDrawable;
+import brachy.modularui.factory.PosGuiData;
+import brachy.modularui.screen.RichTooltip;
+import brachy.modularui.screen.UISettings;
+import brachy.modularui.value.BoolValue;
+import brachy.modularui.value.sync.PanelSyncManager;
+import brachy.modularui.value.sync.SyncHandlers;
+import brachy.modularui.widgets.ButtonWidget;
+import brachy.modularui.widgets.ToggleButton;
+import brachy.modularui.widgets.layout.Flow;
+import brachy.modularui.widgets.textfield.TextFieldWidget;
 import org.jetbrains.annotations.Nullable;
 
 public interface IMEStockingPart extends IAutoPullPart {
@@ -64,4 +81,43 @@ default void validateConfig() {
     int getTicksPerCycle();
 
     void setTicksPerCycle(int newSize);
+
+    @Override
+    default MachineUIPanelBuilder getPanelBuilder(PosGuiData data, PanelSyncManager syncManager, UISettings settings) {
+        IPanelHandler settingsPanelHandler = syncManager.syncedPanel("stocking_settings", true,
+                (sm, sh) -> PopupPanel.createPopupPanel("stocking_settings_panel", 140, 70)
+                        .child(Flow.col()
+                                .coverChildren()
+                                .child(IKey.lang("gtceu.gui.me_network.min_stack_size").asWidget())
+                                .child(new TextFieldWidget()
+                                        .size(120, 18)
+                                        .value(SyncHandlers.intNumber(this::getMinStackSize, this::setMinStackSize))
+                                        .setNumbers(1, Integer.MAX_VALUE))
+                                .child(IKey.lang("gtceu.gui.me_network.ticks_per_cycle").asWidget())
+                                .child(new TextFieldWidget()
+                                        .size(120, 18)
+                                        .value(SyncHandlers.intNumber(this::getTicksPerCycle, this::setTicksPerCycle))
+                                        .setNumbers(1, 200))
+                                .margin(5)));
+
+        return MachineUIPanelBuilder.defaultPanelBuilder(this.self())
+                .rightConfigurators(f -> {
+                    f.child(new ToggleButton()
+                            .value(new BoolValue.Dynamic(this::isAutoPull, this::setAutoPull))
+                            .stateOverlay(GTGuiTextures.BUTTON_AUTO_PULL)
+                            .tooltipAutoUpdate(true)
+                            .tooltipBuilder(r -> r
+                                    .addLine(IKey.lang("gtceu.gui.me_network.auto_pull_toggle"))))
+                            .child(new ButtonWidget<>()
+                                    .size(18)
+                                    .onMousePressed((x, y, b) -> {
+                                        settingsPanelHandler.openPanel();
+                                        return true;
+                                    })
+                                    .overlay(new ItemDrawable(GTItems.TOOL_DATA_STICK.asItem()).asIcon().size(16))
+                                    .tooltip(new RichTooltip()
+                                            .addLine(IKey.lang("gtceu.gui.me_network.stocking_settings"))));
+
+                });
+    }
 }
diff --git a/src/main/java/com/gregtechceu/gtceu/integration/embeddium/GTEmbeddiumCompat.java b/src/main/java/com/gregtechceu/gtceu/integration/embeddium/GTEmbeddiumCompat.java
new file mode 100644
index 00000000000..0e9f4db4137
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/integration/embeddium/GTEmbeddiumCompat.java
@@ -0,0 +1,16 @@
+package com.gregtechceu.gtceu.integration.embeddium;
+
+import net.minecraft.client.renderer.texture.TextureAtlasSprite;
+
+import me.jellysquid.mods.sodium.client.render.texture.SpriteUtil;
+
+import java.util.Collection;
+
+public class GTEmbeddiumCompat {
+
+    public static void markSpritesAsActive(Collection<TextureAtlasSprite> sprites) {
+        for (TextureAtlasSprite sprite : sprites) {
+            SpriteUtil.markSpriteActive(sprite);
+        }
+    }
+}
diff --git a/src/main/java/com/gregtechceu/gtceu/integration/emi/GTEMIPlugin.java b/src/main/java/com/gregtechceu/gtceu/integration/emi/GTEMIPlugin.java
index ad042816170..8a34c217da5 100644
--- a/src/main/java/com/gregtechceu/gtceu/integration/emi/GTEMIPlugin.java
+++ b/src/main/java/com/gregtechceu/gtceu/integration/emi/GTEMIPlugin.java
@@ -4,6 +4,7 @@
 import com.gregtechceu.gtceu.api.GTValues;
 import com.gregtechceu.gtceu.api.recipe.category.GTRecipeCategory;
 import com.gregtechceu.gtceu.api.registry.GTRegistries;
+import com.gregtechceu.gtceu.common.data.GTBlocks;
 import com.gregtechceu.gtceu.common.data.GTFluids;
 import com.gregtechceu.gtceu.common.data.GTItems;
 import com.gregtechceu.gtceu.common.data.GTRecipeTypes;
@@ -20,6 +21,7 @@
 import com.gregtechceu.gtceu.integration.emi.orevein.GTOreVeinEmiCategory;
 import com.gregtechceu.gtceu.integration.emi.recipe.Ae2PatternTerminalHandler;
 import com.gregtechceu.gtceu.integration.emi.recipe.GTEmiRecipeHandler;
+import com.gregtechceu.gtceu.integration.emi.recipe.GTModuleEMIRecipe;
 import com.gregtechceu.gtceu.integration.emi.recipe.GTRecipeEMICategory;
 
 import com.lowdragmc.lowdraglib.gui.modular.ModularUIContainer;
@@ -27,6 +29,7 @@
 import net.minecraft.core.registries.BuiltInRegistries;
 import net.minecraft.world.item.alchemy.Potion;
 import net.minecraft.world.item.alchemy.PotionUtils;
+import net.minecraft.world.item.crafting.Ingredient;
 import net.minecraftforge.fluids.FluidStack;
 
 import appeng.menu.me.items.PatternEncodingTermMenu;
@@ -35,6 +38,7 @@
 import dev.emi.emi.api.EmiPlugin;
 import dev.emi.emi.api.EmiRegistry;
 import dev.emi.emi.api.stack.Comparison;
+import dev.emi.emi.api.stack.EmiIngredient;
 import dev.emi.emi.api.stack.EmiStack;
 
 @EmiEntrypoint
@@ -44,6 +48,7 @@ public class GTEMIPlugin implements EmiPlugin {
     public void register(EmiRegistry registry) {
         // Categories
         registry.addCategory(MultiblockInfoEmiCategory.CATEGORY);
+        registry.addCategory(GTModuleEMIRecipe.CATEGORY);
         if (!ConfigHolder.INSTANCE.compat.hideOreProcessingDiagrams)
             registry.addCategory(GTOreProcessingEmiCategory.CATEGORY);
         registry.addCategory(GTOreVeinEmiCategory.CATEGORY);
@@ -74,6 +79,7 @@ public void register(EmiRegistry registry) {
         if (ConfigHolder.INSTANCE.machines.doBedrockOres)
             GTBedrockOreEmiCategory.registerDisplays(registry);
         GTProgrammedCircuitCategory.registerDisplays(registry);
+        GTModuleEMIRecipe.addRecipes(registry);
 
         // workstations
         GTRecipeEMICategory.registerWorkStations(registry);
@@ -85,6 +91,8 @@ public void register(EmiRegistry registry) {
             GTBedrockOreEmiCategory.registerWorkStations(registry);
         registry.addWorkstation(GTRecipeEMICategory.CATEGORIES.apply(GTRecipeTypes.CHEMICAL_RECIPES.getCategory()),
                 EmiStack.of(GTMultiMachines.LARGE_CHEMICAL_REACTOR.asStack()));
+        registry.addWorkstation(GTModuleEMIRecipe.CATEGORY,
+                EmiIngredient.of(Ingredient.of(GTBlocks.EQUIPMENT_FOUNDRY)));
 
         // Comparators
         registry.setDefaultComparison(GTItems.TURBINE_ROTOR.asItem(), Comparison.compareNbt());
diff --git a/src/main/java/com/gregtechceu/gtceu/integration/emi/circuit/GTProgrammedCircuitCategory.java b/src/main/java/com/gregtechceu/gtceu/integration/emi/circuit/GTProgrammedCircuitCategory.java
index 90cb88abf4b..f222d3c03a3 100644
--- a/src/main/java/com/gregtechceu/gtceu/integration/emi/circuit/GTProgrammedCircuitCategory.java
+++ b/src/main/java/com/gregtechceu/gtceu/integration/emi/circuit/GTProgrammedCircuitCategory.java
@@ -3,7 +3,7 @@
 import com.gregtechceu.gtceu.GTCEu;
 import com.gregtechceu.gtceu.common.data.GTItems;
 import com.gregtechceu.gtceu.common.item.behavior.IntCircuitBehaviour;
-import com.gregtechceu.gtceu.integration.xei.widgets.GTProgrammedCircuitWidget;
+import com.gregtechceu.gtceu.integration.recipeviewer.widgets.GTProgrammedCircuitWidget;
 
 import com.lowdragmc.lowdraglib.emi.ModularEmiRecipe;
 
diff --git a/src/main/java/com/gregtechceu/gtceu/integration/emi/oreprocessing/GTEmiOreProcessing.java b/src/main/java/com/gregtechceu/gtceu/integration/emi/oreprocessing/GTEmiOreProcessing.java
index debdbe15819..9b86a7e6d65 100644
--- a/src/main/java/com/gregtechceu/gtceu/integration/emi/oreprocessing/GTEmiOreProcessing.java
+++ b/src/main/java/com/gregtechceu/gtceu/integration/emi/oreprocessing/GTEmiOreProcessing.java
@@ -1,7 +1,7 @@
 package com.gregtechceu.gtceu.integration.emi.oreprocessing;
 
 import com.gregtechceu.gtceu.api.data.chemical.material.Material;
-import com.gregtechceu.gtceu.integration.xei.widgets.GTOreByProductWidget;
+import com.gregtechceu.gtceu.integration.recipeviewer.widgets.GTOreByProductWidget;
 
 import com.lowdragmc.lowdraglib.emi.ModularEmiRecipe;
 
diff --git a/src/main/java/com/gregtechceu/gtceu/integration/emi/orevein/GTBedrockFluid.java b/src/main/java/com/gregtechceu/gtceu/integration/emi/orevein/GTBedrockFluid.java
index 5af61528004..8500635056f 100644
--- a/src/main/java/com/gregtechceu/gtceu/integration/emi/orevein/GTBedrockFluid.java
+++ b/src/main/java/com/gregtechceu/gtceu/integration/emi/orevein/GTBedrockFluid.java
@@ -2,7 +2,7 @@
 
 import com.gregtechceu.gtceu.api.data.worldgen.bedrockfluid.BedrockFluidDefinition;
 import com.gregtechceu.gtceu.client.ClientProxy;
-import com.gregtechceu.gtceu.integration.xei.widgets.GTOreVeinWidget;
+import com.gregtechceu.gtceu.integration.recipeviewer.widgets.GTOreVeinWidget;
 
 import com.lowdragmc.lowdraglib.emi.ModularEmiRecipe;
 import com.lowdragmc.lowdraglib.gui.widget.WidgetGroup;
diff --git a/src/main/java/com/gregtechceu/gtceu/integration/emi/orevein/GTBedrockOre.java b/src/main/java/com/gregtechceu/gtceu/integration/emi/orevein/GTBedrockOre.java
index 4f2e701bd3c..40b5034d035 100644
--- a/src/main/java/com/gregtechceu/gtceu/integration/emi/orevein/GTBedrockOre.java
+++ b/src/main/java/com/gregtechceu/gtceu/integration/emi/orevein/GTBedrockOre.java
@@ -2,7 +2,7 @@
 
 import com.gregtechceu.gtceu.api.data.worldgen.bedrockore.BedrockOreDefinition;
 import com.gregtechceu.gtceu.client.ClientProxy;
-import com.gregtechceu.gtceu.integration.xei.widgets.GTOreVeinWidget;
+import com.gregtechceu.gtceu.integration.recipeviewer.widgets.GTOreVeinWidget;
 
 import com.lowdragmc.lowdraglib.emi.ModularEmiRecipe;
 import com.lowdragmc.lowdraglib.gui.widget.WidgetGroup;
diff --git a/src/main/java/com/gregtechceu/gtceu/integration/emi/orevein/GTEmiOreVein.java b/src/main/java/com/gregtechceu/gtceu/integration/emi/orevein/GTEmiOreVein.java
index 250103a54cc..fa48694355b 100644
--- a/src/main/java/com/gregtechceu/gtceu/integration/emi/orevein/GTEmiOreVein.java
+++ b/src/main/java/com/gregtechceu/gtceu/integration/emi/orevein/GTEmiOreVein.java
@@ -2,7 +2,7 @@
 
 import com.gregtechceu.gtceu.api.data.worldgen.GTOreDefinition;
 import com.gregtechceu.gtceu.client.ClientProxy;
-import com.gregtechceu.gtceu.integration.xei.widgets.GTOreVeinWidget;
+import com.gregtechceu.gtceu.integration.recipeviewer.widgets.GTOreVeinWidget;
 
 import com.lowdragmc.lowdraglib.emi.ModularEmiRecipe;
 import com.lowdragmc.lowdraglib.gui.widget.WidgetGroup;
diff --git a/src/main/java/com/gregtechceu/gtceu/integration/emi/recipe/GTEmiRecipe.java b/src/main/java/com/gregtechceu/gtceu/integration/emi/recipe/GTEmiRecipe.java
index 125dac7b7cd..b1f8593b29c 100644
--- a/src/main/java/com/gregtechceu/gtceu/integration/emi/recipe/GTEmiRecipe.java
+++ b/src/main/java/com/gregtechceu/gtceu/integration/emi/recipe/GTEmiRecipe.java
@@ -1,7 +1,7 @@
 package com.gregtechceu.gtceu.integration.emi.recipe;
 
 import com.gregtechceu.gtceu.api.recipe.GTRecipe;
-import com.gregtechceu.gtceu.integration.xei.widgets.GTRecipeWidget;
+import com.gregtechceu.gtceu.integration.recipeviewer.widgets.GTRecipeWidget;
 
 import com.lowdragmc.lowdraglib.emi.ModularEmiRecipe;
 import com.lowdragmc.lowdraglib.emi.ModularForegroundRenderWidget;
diff --git a/src/main/java/com/gregtechceu/gtceu/integration/emi/recipe/GTEmiRecipe2.java b/src/main/java/com/gregtechceu/gtceu/integration/emi/recipe/GTEmiRecipe2.java
new file mode 100644
index 00000000000..8d3f526bb61
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/integration/emi/recipe/GTEmiRecipe2.java
@@ -0,0 +1,232 @@
+package com.gregtechceu.gtceu.integration.emi.recipe;
+
+import com.gregtechceu.gtceu.utils.memoization.GTMemoizer;
+import com.gregtechceu.gtceu.utils.memoization.MemoizedSupplier;
+
+import net.minecraft.client.gui.GuiGraphics;
+import net.minecraft.client.gui.screens.inventory.tooltip.ClientTooltipComponent;
+import net.minecraft.locale.Language;
+import net.minecraft.network.chat.FormattedText;
+import net.minecraft.resources.ResourceLocation;
+import net.minecraft.world.item.crafting.Recipe;
+
+import brachy.modularui.api.widget.ITooltip;
+import brachy.modularui.api.widget.IWidget;
+import brachy.modularui.drawable.text.RichText;
+import brachy.modularui.integration.emi.EmiStackConverter;
+import brachy.modularui.integration.recipeviewer.RecipeSlotRole;
+import brachy.modularui.integration.recipeviewer.RecipeViewerScreenWrapper;
+import brachy.modularui.integration.recipeviewer.handlers.IngredientProvider;
+import brachy.modularui.integration.recipeviewer.handlers.fluid.EmptyFluidTank;
+import brachy.modularui.integration.recipeviewer.util.RecipeScreenRenderingUtil;
+import brachy.modularui.screen.ModularPanel;
+import brachy.modularui.screen.ModularScreen;
+import brachy.modularui.widget.WidgetTree;
+import brachy.modularui.widget.sizer.Area;
+import brachy.modularui.widgets.slot.FluidSlot;
+import brachy.modularui.widgets.slot.ItemSlot;
+import dev.emi.emi.api.recipe.EmiRecipe;
+import dev.emi.emi.api.recipe.EmiRecipeCategory;
+import dev.emi.emi.api.stack.EmiIngredient;
+import dev.emi.emi.api.stack.EmiStack;
+import dev.emi.emi.api.widget.*;
+import lombok.Getter;
+import org.jetbrains.annotations.Nullable;
+
+import java.time.Duration;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.function.Supplier;
+
+public abstract class GTEmiRecipe2<T extends Recipe<?>, W extends IWidget> implements EmiRecipe {
+
+    @Getter
+    protected final T recipe;
+    protected final EmiRecipeCategory category;
+    protected final MemoizedSupplier<ModularScreen> screen;
+
+    @Getter
+    public final List<EmiIngredient> inputs;
+    @Getter
+    public final List<EmiStack> outputs;
+    @Getter
+    public final List<EmiIngredient> catalysts;
+
+    @Getter
+    private final Bounds bounds;
+    @Getter
+    private final int displayWidth, displayHeight;
+
+    public boolean allowRecipeTree = true;
+
+    public GTEmiRecipe2(T recipe, EmiRecipeCategory category, Supplier<W> widgetSupplier) {
+        this.recipe = recipe;
+        this.category = category;
+
+        this.inputs = new ArrayList<>();
+        this.outputs = new ArrayList<>();
+        this.catalysts = new ArrayList<>();
+
+        W recipeWidget = widgetSupplier.get();
+        this.displayWidth = recipeWidget.getArea().width;
+        this.displayHeight = recipeWidget.getArea().height;
+        this.bounds = new Bounds(0, 0, this.displayWidth, this.displayHeight);
+
+        this.screen = GTMemoizer.memoize(() -> {
+            W widget = widgetSupplier.get();
+            ModularPanel<?> panel = ModularPanel.defaultPanel(recipe.getId().toString(), widget.getArea().w(),
+                    widget.getArea().h());
+            panel.child(widget);
+            return new ModularScreen(recipe.getId().getNamespace(), panel);
+        }, Duration.ofSeconds(10));
+
+        WidgetTree.foreachChildBFS(recipeWidget, widget -> {
+            if (!(widget instanceof IngredientProvider<?> provider)) {
+                return true;
+            }
+            RecipeSlotRole role = provider.recipeRole();
+            if (role == RecipeSlotRole.RENDER_ONLY) {
+                return true;
+            }
+
+            EmiStackConverter.Converter<?> converter = EmiStackConverter.getForNullable(provider.ingredientClass());
+            if (converter == null) {
+                return true;
+            }
+            @SuppressWarnings({ "rawtypes", "unchecked" })
+            EmiIngredient ingredient = ((EmiStackConverter.Converter) converter).convertTo(provider);
+
+            switch (role) {
+                case INPUT -> inputs.add(ingredient);
+                case OUTPUT -> {
+                    if (ingredient.getEmiStacks().size() > 1) {
+                        allowRecipeTree = false;
+                    }
+                    outputs.addAll(ingredient.getEmiStacks());
+                }
+                case CATALYST -> catalysts.add(ingredient);
+            }
+            return true;
+        }, true);
+    }
+
+    @Override
+    public EmiRecipeCategory getCategory() {
+        return category;
+    }
+
+    @Override
+    public void addWidgets(WidgetHolder widgets) {
+        widgets.add(new UIWrapperWidget());
+
+        WidgetTree.foreachChildBFS(this.screen.get().getMainPanel(), widget -> {
+            if (!(widget instanceof IngredientProvider<?> provider)) return true;
+
+            RecipeSlotRole role = provider.recipeRole();
+            if (role == RecipeSlotRole.RENDER_ONLY) {
+                return true;
+            }
+            EmiStackConverter.Converter<?> converter = EmiStackConverter.getForNullable(provider.ingredientClass());
+            if (converter == null) {
+                return true;
+            }
+            @SuppressWarnings({ "rawtypes", "unchecked" })
+            EmiIngredient ingredient = ((EmiStackConverter.Converter) converter).convertTo(provider);
+            Area widgetArea = widget.getArea();
+
+            SlotWidget slotWidget = null;
+            // Clear the MUI slots and add EMI slots based on them.
+            if (provider instanceof ItemSlot itemSlot) {
+                itemSlot.slot(RecipeScreenRenderingUtil.EMPTY_ITEM_HANDLER, 0)
+                        .invisible();
+            } else if (provider instanceof FluidSlot fluidSlot) {
+                fluidSlot.syncHandler(EmptyFluidTank.INSTANCE)
+                        .invisible();
+
+                long capacity = Math.max(1, ingredient.getAmount());
+                slotWidget = new TankWidget(ingredient, widgetArea.x, widgetArea.y, widgetArea.width, widgetArea.height,
+                        capacity);
+            }
+            if (slotWidget == null) {
+                slotWidget = new SlotWidget(ingredient, widgetArea.x, widgetArea.y);
+            }
+
+            slotWidget.customBackground(null, widgetArea.x, widgetArea.y, widgetArea.width, widgetArea.height)
+                    .drawBack(false);
+
+            if (role == RecipeSlotRole.CATALYST) {
+                slotWidget.catalyst(true);
+            } else if (role == RecipeSlotRole.OUTPUT) {
+                slotWidget.recipeContext(this);
+            }
+            if (widget instanceof ITooltip<?> tooltip && tooltip.hasTooltip()) {
+                if (tooltip.tooltip().getRichText() instanceof RichText richText) {
+                    var textList = richText.getAsText();
+                    for (FormattedText line : textList) {
+                        slotWidget
+                                .appendTooltip(() -> ClientTooltipComponent
+                                        .create(Language.getInstance().getVisualOrder(line)));
+                    }
+                }
+            }
+            widgets.add(slotWidget);
+            return true;
+        }, true);
+        widgets.add(new UIForegroundRenderWidget());
+    }
+
+    @Override
+    public @Nullable ResourceLocation getId() {
+        return this.recipe.getId();
+    }
+
+    @Override
+    public boolean supportsRecipeTree() {
+        return this.allowRecipeTree && EmiRecipe.super.supportsRecipeTree();
+    }
+
+    public class UIWrapperWidget extends Widget {
+
+        public UIWrapperWidget() {
+            ModularScreen screen = GTEmiRecipe2.this.screen.get();
+            screen.construct(new RecipeViewerScreenWrapper(screen));
+        }
+
+        @Override
+        public Bounds getBounds() {
+            return GTEmiRecipe2.this.bounds;
+        }
+
+        @Override
+        public void render(GuiGraphics guiGraphics, int mouseX, int mouseY, float partialTick) {
+            ModularScreen screen = GTEmiRecipe2.this.screen.get();
+            RecipeScreenRenderingUtil.drawScreenBackground(guiGraphics, screen, mouseX, mouseY, partialTick);
+        }
+
+        @Override
+        public boolean mouseClicked(int mouseX, int mouseY, int button) {
+            return screen.get().onMousePressed(mouseX, mouseY, button);
+        }
+
+        @Override
+        public boolean keyPressed(int keyCode, int scanCode, int modifiers) {
+            return screen.get().keyPressed(keyCode, scanCode, modifiers);
+        }
+    }
+
+    public class UIForegroundRenderWidget extends Widget {
+
+        public UIForegroundRenderWidget() {}
+
+        @Override
+        public Bounds getBounds() {
+            return GTEmiRecipe2.this.bounds;
+        }
+
+        @Override
+        public void render(GuiGraphics guiGraphics, int mouseX, int mouseY, float partialTick) {
+            ModularScreen screen = GTEmiRecipe2.this.screen.get();
+            RecipeScreenRenderingUtil.drawScreenForeground(guiGraphics, screen, mouseX, mouseY, partialTick);
+        }
+    }
+}
diff --git a/src/main/java/com/gregtechceu/gtceu/integration/emi/recipe/GTModuleEMIRecipe.java b/src/main/java/com/gregtechceu/gtceu/integration/emi/recipe/GTModuleEMIRecipe.java
new file mode 100644
index 00000000000..52c6f6ecda2
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/integration/emi/recipe/GTModuleEMIRecipe.java
@@ -0,0 +1,252 @@
+package com.gregtechceu.gtceu.integration.emi.recipe;
+
+import com.gregtechceu.gtceu.GTCEu;
+import com.gregtechceu.gtceu.api.GTValues;
+import com.gregtechceu.gtceu.api.capability.GTCapability;
+import com.gregtechceu.gtceu.api.capability.GTCapabilityHelper;
+import com.gregtechceu.gtceu.api.item.module.IModularItem;
+import com.gregtechceu.gtceu.api.item.module.TieredItemModule;
+import com.gregtechceu.gtceu.api.transfer.item.CustomItemStackHandler;
+import com.gregtechceu.gtceu.common.data.GTBlocks;
+import com.gregtechceu.gtceu.common.data.GTRecipeTypes;
+import com.gregtechceu.gtceu.common.recipe.type.EquipmentFoundryRecipe;
+import com.gregtechceu.gtceu.utils.GTStringUtils;
+import com.gregtechceu.gtceu.utils.GTUtil;
+
+import com.lowdragmc.lowdraglib.emi.ModularEmiRecipe;
+import com.lowdragmc.lowdraglib.gui.widget.ButtonWidget;
+import com.lowdragmc.lowdraglib.gui.widget.LabelWidget;
+import com.lowdragmc.lowdraglib.gui.widget.WidgetGroup;
+
+import net.minecraft.client.Minecraft;
+import net.minecraft.client.gui.Font;
+import net.minecraft.network.chat.Component;
+import net.minecraft.resources.ResourceLocation;
+import net.minecraft.util.FormattedCharSequence;
+import net.minecraft.util.Mth;
+import net.minecraft.world.item.ItemStack;
+import net.minecraft.world.item.Items;
+import net.minecraft.world.item.crafting.Ingredient;
+import net.minecraftforge.items.wrapper.CombinedInvWrapper;
+import net.minecraftforge.items.wrapper.RecipeWrapper;
+
+import dev.emi.emi.api.EmiRegistry;
+import dev.emi.emi.api.recipe.EmiRecipe;
+import dev.emi.emi.api.recipe.EmiRecipeCategory;
+import dev.emi.emi.api.render.EmiTexture;
+import dev.emi.emi.api.stack.EmiIngredient;
+import dev.emi.emi.api.stack.EmiStack;
+import dev.emi.emi.api.widget.WidgetHolder;
+import org.jetbrains.annotations.Nullable;
+import org.lwjgl.glfw.GLFW;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+import java.util.stream.Stream;
+
+public class GTModuleEMIRecipe extends ModularEmiRecipe<WidgetGroup> implements EmiRecipe {
+
+    private static final ItemStack NO_ITEM = Items.BARRIER.getDefaultInstance()
+            .setHoverName(Component.translatable("gtceu.equipment_foundry.gui.tier_too_high"));
+
+    public static final EmiRecipeCategory CATEGORY = new EmiRecipeCategory(
+            GTCEu.id("equipment_foundry"),
+            EmiIngredient.of(Ingredient.of(GTBlocks.EQUIPMENT_FOUNDRY)));
+
+    private final int unique = GTValues.RNG.nextInt();
+    private final EquipmentFoundryRecipe recipe;
+    private int selectedTier = -1;
+
+    public GTModuleEMIRecipe(EquipmentFoundryRecipe recipe) {
+        super(WidgetGroup::new);
+        this.recipe = recipe;
+        this.widget = this::createUIWidget;
+    }
+
+    @Override
+    public EmiRecipeCategory getCategory() {
+        return CATEGORY;
+    }
+
+    @Override
+    public @Nullable ResourceLocation getId() {
+        return recipe.getId();
+    }
+
+    @Override
+    public List<EmiIngredient> getInputs() {
+        return Stream
+                .concat(Arrays.stream(recipe.getEquipment().getItems()),
+                        Arrays.stream(recipe.getIngredient().getItems()))
+                .filter(this::isModular)
+                .map(this::fromStack)
+                .toList();
+    }
+
+    @Override
+    public List<EmiStack> getOutputs() {
+        return List.of();
+    }
+
+    @Override
+    public List<EmiIngredient> getCatalysts() {
+        return List.of(EmiIngredient.of(Ingredient.of(GTBlocks.EQUIPMENT_FOUNDRY)));
+    }
+
+    @Override
+    public int getDisplayWidth() {
+        return 200;
+    }
+
+    @Override
+    public int getDisplayHeight() {
+        int height = 57;
+        height += Minecraft.getInstance().font.wordWrapHeight(recipe.getModules()[0].getInfo(), getDisplayWidth() - 8);
+        return height;
+    }
+
+    @Override
+    public void addWidgets(WidgetHolder widgets) {
+        super.addWidgets(widgets);
+        widgets.addTexture(EmiTexture.PLUS, 35, 11);
+        widgets.addTexture(EmiTexture.EMPTY_ARROW, 83, 9);
+        ItemStack[] stacks = new ItemStack[] { ItemStack.EMPTY, ItemStack.EMPTY, ItemStack.EMPTY };
+        int[] indexes = new int[] { 0, 0 };
+        widgets.addGeneratedSlot(random -> updateStacks(stacks, indexes), unique, 8, 8);
+        widgets.addGeneratedSlot(random -> fromStack(stacks[1]), unique, 56, 8);
+        widgets.addGeneratedSlot(random -> fromStack(stacks[2]), unique, 115, 8);
+    }
+
+    private boolean isModular(ItemStack stack) {
+        return stack.getCapability(GTCapability.CAPABILITY_MODULAR_ITEM).isPresent();
+    }
+
+    private EmiIngredient fromStack(ItemStack stack) {
+        return EmiIngredient.of(Ingredient.of(stack));
+    }
+
+    private EmiIngredient updateStacks(ItemStack[] stacks, int[] indexes) {
+        if (stacks == null || indexes == null) return null;
+        stacks[1] = getModuleItem(indexes, selectedTier);
+        stacks[0] = getEquipment(indexes, stacks[1]);
+        stacks[2] = getResult(stacks[0], stacks[1]);
+        return fromStack(stacks[0]);
+    }
+
+    private ItemStack getModuleItem(int[] indexes, int tier) {
+        ItemStack[] stacks = recipe.getIngredient().getItems();
+        if (tier != -1) {
+            stacks = Arrays.stream(stacks)
+                    .filter(stack -> GTUtil.getTier(stack.getItem()) == tier)
+                    .toArray(ItemStack[]::new);
+        }
+        return stacks.length == 0 ? NO_ITEM : stacks[indexes[1]++ % stacks.length];
+    }
+
+    private ItemStack getEquipment(int[] indexes, ItemStack module) {
+        ItemStack[] stacks;
+        if (module == NO_ITEM) stacks = Arrays.stream(recipe.getEquipment().getItems())
+                .filter(stack -> stack.getCapability(GTCapability.CAPABILITY_MODULAR_ITEM).map(
+                        modularItem -> modularItem.attach(recipe.getModule(selectedTier), true) != null).orElse(false))
+                .toArray(ItemStack[]::new);
+        else stacks = Arrays.stream(recipe.getEquipment().getItems())
+                .filter(this::isModular)
+                .filter(stack -> recipe.matches(new RecipeWrapper(new CombinedInvWrapper(
+                        new CustomItemStackHandler(stack),
+                        new CustomItemStackHandler(module))), 0))
+                .toArray(ItemStack[]::new);
+        return stacks[indexes[0]++ % stacks.length];
+    }
+
+    private ItemStack getResult(ItemStack equipment, ItemStack module) {
+        ItemStack copy = equipment.copy();
+        if (module == NO_ITEM) {
+            IModularItem modularItem = GTCapabilityHelper.getModularItem(copy);
+            if (modularItem != null) modularItem.attach(recipe.getModule(selectedTier), false);
+            return copy;
+        }
+        RecipeWrapper wrapper = new RecipeWrapper(new CombinedInvWrapper(
+                new CustomItemStackHandler(copy),
+                new CustomItemStackHandler(module)));
+        return recipe.assemble(wrapper, 0);
+    }
+
+    public WidgetGroup createUIWidget() {
+        Font font = Minecraft.getInstance().font;
+        WidgetGroup widgets = new WidgetGroup(0, 0, 200, 200);
+        int y = 30;
+        List<LabelWidget> desc = new ArrayList<>();
+        if (recipe.getModules()[0] instanceof TieredItemModule) {
+            TieredItemModule[] tieredModules = Arrays.stream(recipe.getModules())
+                    .map(module -> (TieredItemModule) module).toArray(TieredItemModule[]::new);
+            int minTier = tieredModules[0].getTier();
+            int maxTier = tieredModules[tieredModules.length - 1].getTier();
+            for (int i = minTier; i < maxTier; i++) {
+                if (getModuleItem(new int[] { 0, 0 }, i) == NO_ITEM) minTier++;
+                else break;
+            }
+            for (int i = maxTier; i > minTier; i--) {
+                if (getModuleItem(new int[] { 0, 0 }, i) == NO_ITEM) maxTier--;
+                else break;
+            }
+            if (minTier != maxTier) {
+                widgets.addWidget(new LabelWidget(2, y, Component.translatable(
+                        "gtceu.equipment_foundry.gui.supports_tiers",
+                        GTValues.VNF[minTier],
+                        GTValues.VNF[maxTier])));
+                y += font.lineHeight;
+            }
+            selectedTier = tieredModules[0].getTier();
+            LabelWidget tierLabel = new LabelWidget(2, y, Component.translatable(
+                    "gtceu.equipment_foundry.gui.tier",
+                    GTValues.VNF[selectedTier]));
+            widgets.addWidget(tierLabel);
+            int finalY = y;
+            int finalMinTier = minTier;
+            int finalMaxTier = maxTier;
+            ButtonWidget button = new ButtonWidget(
+                    2 + font.width(Component.translatable("gtceu.equipment_foundry.gui.tier", "")),
+                    tierLabel.getPositionY(),
+                    font.width(GTValues.VNF[GTValues.MAX]), tierLabel.getSizeHeight(),
+                    click -> {
+                        if (click.button == GLFW.GLFW_MOUSE_BUTTON_LEFT) selectedTier++;
+                        if (click.button == GLFW.GLFW_MOUSE_BUTTON_RIGHT) selectedTier--;
+                        selectedTier = Mth.clamp(selectedTier, finalMinTier, finalMaxTier);
+                        tierLabel.setComponent(Component.translatable("gtceu.equipment_foundry.gui.tier",
+                                GTValues.VNF[selectedTier]));
+                        if (!desc.isEmpty()) {
+                            desc.forEach(widget -> widget.setComponent(Component.literal("")));
+                            int i = 0;
+                            for (FormattedCharSequence line : font
+                                    .split(tieredModules[selectedTier - finalMinTier].getInfo(), 196)) {
+                                Component component = GTStringUtils.toComponent(line);
+                                if (desc.size() <= i) {
+                                    desc.add(new LabelWidget(2, finalY + (i + 2) * font.lineHeight, component));
+                                    widgets.addWidget(desc.get(i));
+                                }
+                                desc.get(i).setComponent(component);
+                                i++;
+                            }
+                        }
+                    });
+            button.setHoverTooltips(Component.translatable("gtceu.equipment_foundry.gui.tooltip.tier_switch"));
+            widgets.addWidget(button);
+            y += 2 * font.lineHeight;
+        }
+        for (FormattedCharSequence line : font.split(recipe.getModules()[0].getInfo(), 196)) {
+            desc.add(new LabelWidget(2, y, GTStringUtils.toComponent(line)));
+            widgets.addWidget(desc.get(desc.size() - 1));
+            y += font.lineHeight;
+        }
+        return widgets;
+    }
+
+    public static void addRecipes(EmiRegistry registry) {
+        registry.getRecipeManager()
+                .getAllRecipesFor(GTRecipeTypes.EQUIPMENT_FOUNDRY_RECIPES.get())
+                .stream()
+                .map(GTModuleEMIRecipe::new)
+                .forEach(registry::addRecipe);
+    }
+}
diff --git a/src/main/java/com/gregtechceu/gtceu/integration/jade/provider/RecipeLogicProvider.java b/src/main/java/com/gregtechceu/gtceu/integration/jade/provider/RecipeLogicProvider.java
index 704680393ab..52d05ff5b1c 100644
--- a/src/main/java/com/gregtechceu/gtceu/integration/jade/provider/RecipeLogicProvider.java
+++ b/src/main/java/com/gregtechceu/gtceu/integration/jade/provider/RecipeLogicProvider.java
@@ -120,13 +120,13 @@ protected void addTooltip(CompoundTag capData, ITooltip tooltip, Player player,
             if (blockEntity instanceof IRecipeLogicMachine rlm) {
                 var logic = rlm.getRecipeLogic();
 
-                if (logic.showFancyTooltip() && logic.isWorkingEnabled()) {
+                if (!logic.getWaitingReasons().isEmpty() && logic.isWorkingEnabled()) {
                     Component status = logic.isWaiting() ?
                             Component.translatable("gtceu.recipe_logic.recipe_waiting")
                                     .withStyle(ChatFormatting.YELLOW) :
                             Component.translatable("gtceu.recipe_logic.setup_fail").withStyle(ChatFormatting.RED);
                     tooltip.add(status);
-                    logic.getFancyTooltip().forEach(tooltip::add);
+                    logic.getWaitingReasons().forEach(tooltip::add);
                 }
             }
         }
diff --git a/src/main/java/com/gregtechceu/gtceu/integration/jade/provider/RecipeOutputProvider.java b/src/main/java/com/gregtechceu/gtceu/integration/jade/provider/RecipeOutputProvider.java
index 193e5d5f8ce..879b288f5a5 100644
--- a/src/main/java/com/gregtechceu/gtceu/integration/jade/provider/RecipeOutputProvider.java
+++ b/src/main/java/com/gregtechceu/gtceu/integration/jade/provider/RecipeOutputProvider.java
@@ -235,7 +235,7 @@ private void addFluidTooltips(ITooltip iTooltip, List<FluidIngredient> outputFlu
     }
 
     private Component getItemName(ItemStack stack) {
-        return stack.getDisplayName().copy().withStyle(ChatFormatting.WHITE);
+        return stack.getHoverName().copy().withStyle(ChatFormatting.WHITE);
     }
 
     private Component getFluidName(FluidStack stack) {
diff --git a/src/main/java/com/gregtechceu/gtceu/integration/jei/GTJEIPlugin.java b/src/main/java/com/gregtechceu/gtceu/integration/jei/GTJEIPlugin.java
index ff51702ef24..13219a4cff0 100644
--- a/src/main/java/com/gregtechceu/gtceu/integration/jei/GTJEIPlugin.java
+++ b/src/main/java/com/gregtechceu/gtceu/integration/jei/GTJEIPlugin.java
@@ -25,12 +25,14 @@
 import net.minecraft.world.item.alchemy.Potion;
 import net.minecraftforge.fluids.FluidStack;
 
+import lombok.Getter;
 import mezz.jei.api.IModPlugin;
 import mezz.jei.api.JeiPlugin;
 import mezz.jei.api.forge.ForgeTypes;
 import mezz.jei.api.helpers.IJeiHelpers;
 import mezz.jei.api.helpers.IPlatformFluidHelper;
 import mezz.jei.api.registration.*;
+import mezz.jei.api.runtime.IJeiRuntime;
 import org.jetbrains.annotations.NotNull;
 
 import java.util.ArrayList;
@@ -44,11 +46,19 @@
 @JeiPlugin
 public class GTJEIPlugin implements IModPlugin {
 
+    @Getter
+    private static IJeiRuntime runtime = null;
+
     @Override
     public ResourceLocation getPluginUid() {
         return GTCEu.id("jei_plugin");
     }
 
+    @Override
+    public void onRuntimeAvailable(IJeiRuntime jeiRuntime) {
+        runtime = jeiRuntime;
+    }
+
     @Override
     public void registerCategories(@NotNull IRecipeCategoryRegistration registry) {
         if (GTCEu.Mods.isREILoaded() || GTCEu.Mods.isEMILoaded()) return;
@@ -63,7 +73,7 @@ public void registerCategories(@NotNull IRecipeCategoryRegistration registry) {
             registry.addRecipeCategories(new GTBedrockOreInfoCategory(jeiHelpers));
         for (GTRecipeCategory category : GTRegistries.RECIPE_CATEGORIES) {
             if (category.shouldRegisterDisplays()) {
-                registry.addRecipeCategories(new GTRecipeJEICategory(jeiHelpers, category));
+                // registry.addRecipeCategories(new GTRecipeJEICategory(jeiHelpers, category));
             }
         }
         registry.addRecipeCategories(new GTProgrammedCircuitCategory(jeiHelpers));
@@ -108,6 +118,7 @@ public void registerIngredients(@NotNull IModIngredientRegistration registry) {
 
     @Override
     public void registerItemSubtypes(ISubtypeRegistration registration) {
+        if (GTCEu.Mods.isREILoaded() || GTCEu.Mods.isEMILoaded()) return;
         registration.useNbtForSubtypes(GTItems.PROGRAMMED_CIRCUIT.asItem());
         registration.useNbtForSubtypes(GTItems.TURBINE_ROTOR.asItem());
     }
@@ -115,6 +126,7 @@ public void registerItemSubtypes(ISubtypeRegistration registration) {
     @Override
     public <T> void registerFluidSubtypes(ISubtypeRegistration registration,
                                           IPlatformFluidHelper<T> platformFluidHelper) {
+        if (GTCEu.Mods.isREILoaded() || GTCEu.Mods.isEMILoaded()) return;
         PotionFluidSubtypeInterpreter interpreter = new PotionFluidSubtypeInterpreter();
         PotionFluid potionFluid = GTFluids.POTION.get();
         registration.registerSubtypeInterpreter(ForgeTypes.FLUID_STACK, potionFluid.getSource(), interpreter);
@@ -123,6 +135,7 @@ public <T> void registerFluidSubtypes(ISubtypeRegistration registration,
 
     @Override
     public void registerExtraIngredients(IExtraIngredientRegistration registration) {
+        if (GTCEu.Mods.isREILoaded() || GTCEu.Mods.isEMILoaded()) return;
         Collection<FluidStack> potionFluids = new ArrayList<>(BuiltInRegistries.POTION.size());
         for (Potion potion : BuiltInRegistries.POTION) {
             FluidStack potionFluid = PotionFluid.of(1000, potion);
diff --git a/src/main/java/com/gregtechceu/gtceu/integration/jei/circuit/GTProgrammedCircuitCategory.java b/src/main/java/com/gregtechceu/gtceu/integration/jei/circuit/GTProgrammedCircuitCategory.java
index fdf85cb2564..1e0af9725af 100644
--- a/src/main/java/com/gregtechceu/gtceu/integration/jei/circuit/GTProgrammedCircuitCategory.java
+++ b/src/main/java/com/gregtechceu/gtceu/integration/jei/circuit/GTProgrammedCircuitCategory.java
@@ -2,7 +2,7 @@
 
 import com.gregtechceu.gtceu.GTCEu;
 import com.gregtechceu.gtceu.common.data.GTItems;
-import com.gregtechceu.gtceu.integration.xei.widgets.GTProgrammedCircuitWidget;
+import com.gregtechceu.gtceu.integration.recipeviewer.widgets.GTProgrammedCircuitWidget;
 
 import com.lowdragmc.lowdraglib.jei.ModularUIRecipeCategory;
 import com.lowdragmc.lowdraglib.jei.ModularWrapper;
diff --git a/src/main/java/com/gregtechceu/gtceu/integration/jei/oreprocessing/GTOreProcessingInfoWrapper.java b/src/main/java/com/gregtechceu/gtceu/integration/jei/oreprocessing/GTOreProcessingInfoWrapper.java
index 3f33de6d446..3ab837f790c 100644
--- a/src/main/java/com/gregtechceu/gtceu/integration/jei/oreprocessing/GTOreProcessingInfoWrapper.java
+++ b/src/main/java/com/gregtechceu/gtceu/integration/jei/oreprocessing/GTOreProcessingInfoWrapper.java
@@ -1,7 +1,7 @@
 package com.gregtechceu.gtceu.integration.jei.oreprocessing;
 
 import com.gregtechceu.gtceu.api.data.chemical.material.Material;
-import com.gregtechceu.gtceu.integration.xei.widgets.GTOreByProductWidget;
+import com.gregtechceu.gtceu.integration.recipeviewer.widgets.GTOreByProductWidget;
 
 import com.lowdragmc.lowdraglib.jei.ModularWrapper;
 
diff --git a/src/main/java/com/gregtechceu/gtceu/integration/jei/orevein/GTBedrockFluidInfoCategory.java b/src/main/java/com/gregtechceu/gtceu/integration/jei/orevein/GTBedrockFluidInfoCategory.java
index badbc830993..ea01410570f 100644
--- a/src/main/java/com/gregtechceu/gtceu/integration/jei/orevein/GTBedrockFluidInfoCategory.java
+++ b/src/main/java/com/gregtechceu/gtceu/integration/jei/orevein/GTBedrockFluidInfoCategory.java
@@ -4,7 +4,7 @@
 import com.gregtechceu.gtceu.client.ClientProxy;
 import com.gregtechceu.gtceu.common.data.GTItems;
 import com.gregtechceu.gtceu.common.data.GTMaterials;
-import com.gregtechceu.gtceu.integration.xei.widgets.GTOreVeinWidget;
+import com.gregtechceu.gtceu.integration.recipeviewer.widgets.GTOreVeinWidget;
 
 import com.lowdragmc.lowdraglib.jei.ModularUIRecipeCategory;
 
diff --git a/src/main/java/com/gregtechceu/gtceu/integration/jei/orevein/GTBedrockFluidInfoWrapper.java b/src/main/java/com/gregtechceu/gtceu/integration/jei/orevein/GTBedrockFluidInfoWrapper.java
index 5d0d784a48c..8c97cd1c534 100644
--- a/src/main/java/com/gregtechceu/gtceu/integration/jei/orevein/GTBedrockFluidInfoWrapper.java
+++ b/src/main/java/com/gregtechceu/gtceu/integration/jei/orevein/GTBedrockFluidInfoWrapper.java
@@ -1,7 +1,7 @@
 package com.gregtechceu.gtceu.integration.jei.orevein;
 
 import com.gregtechceu.gtceu.api.data.worldgen.bedrockfluid.BedrockFluidDefinition;
-import com.gregtechceu.gtceu.integration.xei.widgets.GTOreVeinWidget;
+import com.gregtechceu.gtceu.integration.recipeviewer.widgets.GTOreVeinWidget;
 
 import com.lowdragmc.lowdraglib.jei.ModularWrapper;
 
diff --git a/src/main/java/com/gregtechceu/gtceu/integration/jei/orevein/GTBedrockOreInfoCategory.java b/src/main/java/com/gregtechceu/gtceu/integration/jei/orevein/GTBedrockOreInfoCategory.java
index 496fb4bbc52..b0589480b87 100644
--- a/src/main/java/com/gregtechceu/gtceu/integration/jei/orevein/GTBedrockOreInfoCategory.java
+++ b/src/main/java/com/gregtechceu/gtceu/integration/jei/orevein/GTBedrockOreInfoCategory.java
@@ -3,7 +3,7 @@
 import com.gregtechceu.gtceu.GTCEu;
 import com.gregtechceu.gtceu.client.ClientProxy;
 import com.gregtechceu.gtceu.common.data.GTItems;
-import com.gregtechceu.gtceu.integration.xei.widgets.GTOreVeinWidget;
+import com.gregtechceu.gtceu.integration.recipeviewer.widgets.GTOreVeinWidget;
 
 import com.lowdragmc.lowdraglib.jei.ModularUIRecipeCategory;
 
diff --git a/src/main/java/com/gregtechceu/gtceu/integration/jei/orevein/GTBedrockOreInfoWrapper.java b/src/main/java/com/gregtechceu/gtceu/integration/jei/orevein/GTBedrockOreInfoWrapper.java
index 918a802a8d2..2a6446090e0 100644
--- a/src/main/java/com/gregtechceu/gtceu/integration/jei/orevein/GTBedrockOreInfoWrapper.java
+++ b/src/main/java/com/gregtechceu/gtceu/integration/jei/orevein/GTBedrockOreInfoWrapper.java
@@ -1,7 +1,7 @@
 package com.gregtechceu.gtceu.integration.jei.orevein;
 
 import com.gregtechceu.gtceu.api.data.worldgen.bedrockore.BedrockOreDefinition;
-import com.gregtechceu.gtceu.integration.xei.widgets.GTOreVeinWidget;
+import com.gregtechceu.gtceu.integration.recipeviewer.widgets.GTOreVeinWidget;
 
 import com.lowdragmc.lowdraglib.jei.ModularWrapper;
 
diff --git a/src/main/java/com/gregtechceu/gtceu/integration/jei/orevein/GTOreVeinInfoCategory.java b/src/main/java/com/gregtechceu/gtceu/integration/jei/orevein/GTOreVeinInfoCategory.java
index 5337954a192..0abe2f636c1 100644
--- a/src/main/java/com/gregtechceu/gtceu/integration/jei/orevein/GTOreVeinInfoCategory.java
+++ b/src/main/java/com/gregtechceu/gtceu/integration/jei/orevein/GTOreVeinInfoCategory.java
@@ -6,7 +6,7 @@
 import com.gregtechceu.gtceu.client.ClientProxy;
 import com.gregtechceu.gtceu.common.data.GTItems;
 import com.gregtechceu.gtceu.common.data.GTMaterials;
-import com.gregtechceu.gtceu.integration.xei.widgets.GTOreVeinWidget;
+import com.gregtechceu.gtceu.integration.recipeviewer.widgets.GTOreVeinWidget;
 
 import com.lowdragmc.lowdraglib.jei.ModularUIRecipeCategory;
 
diff --git a/src/main/java/com/gregtechceu/gtceu/integration/jei/orevein/GTOreVeinInfoWrapper.java b/src/main/java/com/gregtechceu/gtceu/integration/jei/orevein/GTOreVeinInfoWrapper.java
index 6fbc0feb30b..a782c538a12 100644
--- a/src/main/java/com/gregtechceu/gtceu/integration/jei/orevein/GTOreVeinInfoWrapper.java
+++ b/src/main/java/com/gregtechceu/gtceu/integration/jei/orevein/GTOreVeinInfoWrapper.java
@@ -1,7 +1,7 @@
 package com.gregtechceu.gtceu.integration.jei.orevein;
 
 import com.gregtechceu.gtceu.api.data.worldgen.GTOreDefinition;
-import com.gregtechceu.gtceu.integration.xei.widgets.GTOreVeinWidget;
+import com.gregtechceu.gtceu.integration.recipeviewer.widgets.GTOreVeinWidget;
 
 import com.lowdragmc.lowdraglib.jei.ModularWrapper;
 
diff --git a/src/main/java/com/gregtechceu/gtceu/integration/jei/recipe/GTRecipeJEICategory.java b/src/main/java/com/gregtechceu/gtceu/integration/jei/recipe/GTRecipeJEICategory.java
index 93d359fa065..d07b5a88b6d 100644
--- a/src/main/java/com/gregtechceu/gtceu/integration/jei/recipe/GTRecipeJEICategory.java
+++ b/src/main/java/com/gregtechceu/gtceu/integration/jei/recipe/GTRecipeJEICategory.java
@@ -8,50 +8,55 @@
 import com.gregtechceu.gtceu.api.registry.GTRegistries;
 import com.gregtechceu.gtceu.common.data.GTRecipeTypes;
 
-import com.lowdragmc.lowdraglib.jei.IGui2IDrawable;
-import com.lowdragmc.lowdraglib.jei.ModularUIRecipeCategory;
-
 import net.minecraft.Util;
-import net.minecraft.network.chat.Component;
 import net.minecraft.resources.ResourceLocation;
+import net.minecraft.world.item.crafting.Recipe;
 
-import lombok.Getter;
+import brachy.modularui.api.widget.IWidget;
+import brachy.modularui.integration.jei.recipe.ModularUIRecipeCategory;
 import mezz.jei.api.constants.RecipeTypes;
-import mezz.jei.api.gui.drawable.IDrawable;
-import mezz.jei.api.helpers.IGuiHelper;
-import mezz.jei.api.helpers.IJeiHelpers;
 import mezz.jei.api.recipe.RecipeType;
 import mezz.jei.api.registration.IRecipeCatalystRegistration;
 import mezz.jei.api.registration.IRecipeRegistration;
-import org.jetbrains.annotations.NotNull;
-import org.jetbrains.annotations.Nullable;
 
 import java.util.ArrayList;
 import java.util.List;
 import java.util.function.Function;
 
-public class GTRecipeJEICategory extends ModularUIRecipeCategory<GTRecipe> {
+public abstract class GTRecipeJEICategory<T extends Recipe<?>, W extends IWidget>
+                                         extends ModularUIRecipeCategory<T, W> {
 
     public static final Function<GTRecipeCategory, RecipeType<GTRecipe>> TYPES = Util
             .memoize(c -> new RecipeType<>(c.registryKey, GTRecipe.class));
 
-    private final GTRecipeCategory category;
-    @Getter
-    private final IDrawable background;
-    @Getter
-    private final IDrawable icon;
+    /*
+     * private final GTRecipeCategory category;
+     * 
+     * @Getter
+     * private final IDrawable background;
+     * 
+     * @Getter
+     * private final IDrawable icon;
+     */
 
-    public GTRecipeJEICategory(IJeiHelpers helpers,
-                               @NotNull GTRecipeCategory category) {
-        super(GTRecipeWrapper::new);
-        this.category = category;
-        var recipeType = category.getRecipeType();
-        IGuiHelper guiHelper = helpers.getGuiHelper();
-        var size = recipeType.getRecipeUI().getJEISize();
-        this.background = guiHelper.createBlankDrawable(size.width, size.height);
-        this.icon = IGui2IDrawable.toDrawable(category.getIcon(), 16, 16);
+    protected GTRecipeJEICategory(Function<T, W> wrapperFunction, Function<T, ResourceLocation> recipeIdGetter) {
+        super(wrapperFunction, recipeIdGetter);
     }
 
+    /*
+     * public GTRecipeJEICategory(IJeiHelpers helpers,
+     * 
+     * @NotNull GTRecipeCategory category) {
+     * super(GTRecipeWrapper::new);
+     * this.category = category;
+     * var recipeType = category.getRecipeType();
+     * IGuiHelper guiHelper = helpers.getGuiHelper();
+     * var size = recipeType.getRecipeUI().getJEISize();
+     * this.background = guiHelper.createBlankDrawable(size.width, size.height);
+     * this.icon = IGui2IDrawable.toDrawable(category.getIcon(), 16, 16);
+     * }
+     */
+
     public static void registerRecipes(IRecipeRegistration registration) {
         List<GTRecipeCategory> subCategories = new ArrayList<>();
         // run main categories first
@@ -91,21 +96,4 @@ public static RecipeType<?> machineType(GTRecipeCategory category) {
         if (category == GTRecipeTypes.FURNACE_RECIPES.getCategory()) return RecipeTypes.SMELTING;
         return TYPES.apply(category);
     }
-
-    @Override
-    @NotNull
-    public RecipeType<GTRecipe> getRecipeType() {
-        return TYPES.apply(category);
-    }
-
-    @Override
-    @NotNull
-    public Component getTitle() {
-        return Component.translatable(category.getLanguageKey());
-    }
-
-    @Override
-    public @Nullable ResourceLocation getRegistryName(@NotNull GTRecipe recipe) {
-        return recipe.id;
-    }
 }
diff --git a/src/main/java/com/gregtechceu/gtceu/integration/jei/recipe/GTRecipeWrapper.java b/src/main/java/com/gregtechceu/gtceu/integration/jei/recipe/GTRecipeWrapper.java
index 602b9586ac8..cce39320743 100644
--- a/src/main/java/com/gregtechceu/gtceu/integration/jei/recipe/GTRecipeWrapper.java
+++ b/src/main/java/com/gregtechceu/gtceu/integration/jei/recipe/GTRecipeWrapper.java
@@ -1,7 +1,7 @@
 package com.gregtechceu.gtceu.integration.jei.recipe;
 
 import com.gregtechceu.gtceu.api.recipe.GTRecipe;
-import com.gregtechceu.gtceu.integration.xei.widgets.GTRecipeWidget;
+import com.gregtechceu.gtceu.integration.recipeviewer.widgets.GTRecipeWidget;
 
 import com.lowdragmc.lowdraglib.gui.widget.Widget;
 import com.lowdragmc.lowdraglib.jei.ModularWrapper;
diff --git a/src/main/java/com/gregtechceu/gtceu/integration/kjs/GregTechKubeJSPlugin.java b/src/main/java/com/gregtechceu/gtceu/integration/kjs/GregTechKubeJSPlugin.java
index e007aa4151b..3dc2da88ac8 100644
--- a/src/main/java/com/gregtechceu/gtceu/integration/kjs/GregTechKubeJSPlugin.java
+++ b/src/main/java/com/gregtechceu/gtceu/integration/kjs/GregTechKubeJSPlugin.java
@@ -69,7 +69,7 @@
 import com.gregtechceu.gtceu.common.data.models.GTMachineModels;
 import com.gregtechceu.gtceu.common.data.models.GTModels;
 import com.gregtechceu.gtceu.common.item.armor.PowerlessJetpack;
-import com.gregtechceu.gtceu.common.machine.multiblock.primitive.PrimitiveFancyUIWorkableMachine;
+import com.gregtechceu.gtceu.common.machine.multiblock.primitive.PrimitiveWorkableMachine;
 import com.gregtechceu.gtceu.common.unification.material.MaterialRegistryManager;
 import com.gregtechceu.gtceu.core.mixins.IngredientAccessor;
 import com.gregtechceu.gtceu.data.recipe.CraftingComponent;
@@ -160,8 +160,7 @@ public void init() {
 
         GTRegistryInfo.MACHINE.addType("simple", KJSWrappingMachineBuilder.class,
                 (id) -> new KJSWrappingMachineBuilder(id,
-                        new KJSTieredMachineBuilder(id, SimpleTieredMachine::new,
-                                SimpleTieredMachine.EDITABLE_UI_CREATOR, false)),
+                        new KJSTieredMachineBuilder(id, SimpleTieredMachine::new, false)),
                 true);
         GTRegistryInfo.MACHINE.addType("custom", KJSWrappingMachineBuilder.class,
                 (id) -> new KJSWrappingMachineBuilder(id, new KJSTieredMachineBuilder(id)),
@@ -170,8 +169,7 @@ public void init() {
                 KJSSteamMachineBuilder::new, false);
         GTRegistryInfo.MACHINE.addType("generator", KJSWrappingMachineBuilder.class,
                 (id) -> new KJSWrappingMachineBuilder(id,
-                        new KJSTieredMachineBuilder(id, SimpleGeneratorMachine::new,
-                                SimpleGeneratorMachine.EDITABLE_UI_CREATOR, true)),
+                        new KJSTieredMachineBuilder(id, SimpleGeneratorMachine::new, true)),
                 false);
         GTRegistryInfo.MACHINE.addType("multiblock",
                 (Class<? extends BuilderBase<? extends MachineDefinition>>) (Class<?>) MultiblockMachineBuilder.class,
@@ -180,7 +178,7 @@ public void init() {
                 (id) -> new KJSWrappingMultiblockBuilder(id, new KJSTieredMultiblockBuilder(id)), false);
         GTRegistryInfo.MACHINE.addType("primitive",
                 (Class<? extends BuilderBase<? extends MachineDefinition>>) (Class<?>) MultiblockMachineBuilder.class,
-                (id) -> KJSWrappingMultiblockBuilder.createKJSMulti(id, PrimitiveFancyUIWorkableMachine::new),
+                (id) -> KJSWrappingMultiblockBuilder.createKJSMulti(id, PrimitiveWorkableMachine::new),
                 false);
 
         GTRegistryInfo.WORLD_GEN_LAYER.addType("basic", WorldGenLayerBuilder.class, WorldGenLayerBuilder::new, true);
diff --git a/src/main/java/com/gregtechceu/gtceu/integration/kjs/builders/machine/KJSTieredMachineBuilder.java b/src/main/java/com/gregtechceu/gtceu/integration/kjs/builders/machine/KJSTieredMachineBuilder.java
index 1151cabefd5..ac1fa4bd609 100644
--- a/src/main/java/com/gregtechceu/gtceu/integration/kjs/builders/machine/KJSTieredMachineBuilder.java
+++ b/src/main/java/com/gregtechceu/gtceu/integration/kjs/builders/machine/KJSTieredMachineBuilder.java
@@ -2,7 +2,6 @@
 
 import com.gregtechceu.gtceu.api.GTValues;
 import com.gregtechceu.gtceu.api.blockentity.BlockEntityCreationInfo;
-import com.gregtechceu.gtceu.api.gui.editor.EditableMachineUI;
 import com.gregtechceu.gtceu.api.machine.MachineDefinition;
 import com.gregtechceu.gtceu.api.machine.MetaMachine;
 import com.gregtechceu.gtceu.api.recipe.GTRecipeType;
@@ -23,7 +22,6 @@
 import org.jetbrains.annotations.Nullable;
 
 import java.util.*;
-import java.util.function.BiFunction;
 
 import static com.gregtechceu.gtceu.api.GTValues.*;
 import static com.gregtechceu.gtceu.utils.FormattingUtil.toEnglishName;
@@ -48,8 +46,6 @@ public class KJSTieredMachineBuilder extends BuilderBase<MachineDefinition[]> {
     @Setter
     public transient boolean isGenerator = false;
 
-    public transient BiFunction<ResourceLocation, GTRecipeType, EditableMachineUI> editableUI;
-
     public KJSTieredMachineBuilder(ResourceLocation id) {
         super(id);
         this.addDefaultTooltips = false;
@@ -57,11 +53,9 @@ public KJSTieredMachineBuilder(ResourceLocation id) {
     }
 
     public KJSTieredMachineBuilder(ResourceLocation id, TieredCreationFunction machine,
-                                   BiFunction<ResourceLocation, GTRecipeType, EditableMachineUI> editableUI,
                                    boolean isGenerator) {
         super(id);
         this.machine = machine;
-        this.editableUI = editableUI;
         this.isGenerator = isGenerator;
     }
 
@@ -111,9 +105,6 @@ public void generateLang(@NotNull LangEventJS lang) {
 
             if (builder.recipeTypes().length > 0) {
                 GTRecipeType recipeType = builder.recipeTypes()[0];
-                if (this.editableUI != null && builder.editableUI() == null) {
-                    builder.editableUI(this.editableUI.apply(this.id, recipeType));
-                }
                 if (tankScalingFunction != null && addDefaultTooltips) {
                     builder.tooltips(
                             GTMachineUtils.workableTiered(tier, GTValues.V[tier], GTValues.V[tier] * 64, recipeType,
diff --git a/src/main/java/com/gregtechceu/gtceu/integration/map/layer/builtin/OreRenderLayer.java b/src/main/java/com/gregtechceu/gtceu/integration/map/layer/builtin/OreRenderLayer.java
index 31237f97976..dea2be0b90e 100644
--- a/src/main/java/com/gregtechceu/gtceu/integration/map/layer/builtin/OreRenderLayer.java
+++ b/src/main/java/com/gregtechceu/gtceu/integration/map/layer/builtin/OreRenderLayer.java
@@ -9,7 +9,7 @@
 import com.gregtechceu.gtceu.config.ConfigHolder;
 import com.gregtechceu.gtceu.integration.map.GenericMapRenderer;
 import com.gregtechceu.gtceu.integration.map.layer.MapRenderLayer;
-import com.gregtechceu.gtceu.integration.xei.widgets.GTOreVeinWidget;
+import com.gregtechceu.gtceu.integration.recipeviewer.widgets.GTOreVeinWidget;
 
 import net.minecraft.core.BlockPos;
 import net.minecraft.network.chat.Component;
diff --git a/src/main/java/com/gregtechceu/gtceu/integration/recipeviewer/entry/EntryList.java b/src/main/java/com/gregtechceu/gtceu/integration/recipeviewer/entry/EntryList.java
new file mode 100644
index 00000000000..449b161a476
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/integration/recipeviewer/entry/EntryList.java
@@ -0,0 +1,10 @@
+package com.gregtechceu.gtceu.integration.recipeviewer.entry;
+
+import java.util.List;
+
+public interface EntryList<T> {
+
+    List<T> getStacks();
+
+    boolean isEmpty();
+}
diff --git a/src/main/java/com/gregtechceu/gtceu/integration/recipeviewer/entry/fluid/FluidEntryList.java b/src/main/java/com/gregtechceu/gtceu/integration/recipeviewer/entry/fluid/FluidEntryList.java
new file mode 100644
index 00000000000..c12930cba2d
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/integration/recipeviewer/entry/fluid/FluidEntryList.java
@@ -0,0 +1,15 @@
+package com.gregtechceu.gtceu.integration.recipeviewer.entry.fluid;
+
+import com.gregtechceu.gtceu.integration.recipeviewer.entry.EntryList;
+
+import net.minecraftforge.fluids.FluidStack;
+
+import java.util.List;
+
+public sealed interface FluidEntryList extends EntryList<FluidStack>
+                                       permits FluidStackList, FluidTagList, FluidHolderSetList {
+
+    List<FluidStack> getStacks();
+
+    boolean isEmpty();
+}
diff --git a/src/main/java/com/gregtechceu/gtceu/integration/xei/entry/fluid/FluidHolderSetList.java b/src/main/java/com/gregtechceu/gtceu/integration/recipeviewer/entry/fluid/FluidHolderSetList.java
similarity index 95%
rename from src/main/java/com/gregtechceu/gtceu/integration/xei/entry/fluid/FluidHolderSetList.java
rename to src/main/java/com/gregtechceu/gtceu/integration/recipeviewer/entry/fluid/FluidHolderSetList.java
index e220c96009b..4cf0200be90 100644
--- a/src/main/java/com/gregtechceu/gtceu/integration/xei/entry/fluid/FluidHolderSetList.java
+++ b/src/main/java/com/gregtechceu/gtceu/integration/recipeviewer/entry/fluid/FluidHolderSetList.java
@@ -1,4 +1,4 @@
-package com.gregtechceu.gtceu.integration.xei.entry.fluid;
+package com.gregtechceu.gtceu.integration.recipeviewer.entry.fluid;
 
 import net.minecraft.core.HolderSet;
 import net.minecraft.nbt.CompoundTag;
diff --git a/src/main/java/com/gregtechceu/gtceu/integration/xei/entry/fluid/FluidStackList.java b/src/main/java/com/gregtechceu/gtceu/integration/recipeviewer/entry/fluid/FluidStackList.java
similarity index 94%
rename from src/main/java/com/gregtechceu/gtceu/integration/xei/entry/fluid/FluidStackList.java
rename to src/main/java/com/gregtechceu/gtceu/integration/recipeviewer/entry/fluid/FluidStackList.java
index c24e5ecb76d..196f26261b1 100644
--- a/src/main/java/com/gregtechceu/gtceu/integration/xei/entry/fluid/FluidStackList.java
+++ b/src/main/java/com/gregtechceu/gtceu/integration/recipeviewer/entry/fluid/FluidStackList.java
@@ -1,4 +1,4 @@
-package com.gregtechceu.gtceu.integration.xei.entry.fluid;
+package com.gregtechceu.gtceu.integration.recipeviewer.entry.fluid;
 
 import net.minecraftforge.fluids.FluidStack;
 
diff --git a/src/main/java/com/gregtechceu/gtceu/integration/xei/entry/fluid/FluidTagList.java b/src/main/java/com/gregtechceu/gtceu/integration/recipeviewer/entry/fluid/FluidTagList.java
similarity index 96%
rename from src/main/java/com/gregtechceu/gtceu/integration/xei/entry/fluid/FluidTagList.java
rename to src/main/java/com/gregtechceu/gtceu/integration/recipeviewer/entry/fluid/FluidTagList.java
index 032eead252b..615d6c19510 100644
--- a/src/main/java/com/gregtechceu/gtceu/integration/xei/entry/fluid/FluidTagList.java
+++ b/src/main/java/com/gregtechceu/gtceu/integration/recipeviewer/entry/fluid/FluidTagList.java
@@ -1,4 +1,4 @@
-package com.gregtechceu.gtceu.integration.xei.entry.fluid;
+package com.gregtechceu.gtceu.integration.recipeviewer.entry.fluid;
 
 import net.minecraft.core.HolderSet;
 import net.minecraft.core.registries.BuiltInRegistries;
diff --git a/src/main/java/com/gregtechceu/gtceu/integration/recipeviewer/entry/item/ItemEntryList.java b/src/main/java/com/gregtechceu/gtceu/integration/recipeviewer/entry/item/ItemEntryList.java
new file mode 100644
index 00000000000..8fba73c48b8
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/integration/recipeviewer/entry/item/ItemEntryList.java
@@ -0,0 +1,15 @@
+package com.gregtechceu.gtceu.integration.recipeviewer.entry.item;
+
+import com.gregtechceu.gtceu.integration.recipeviewer.entry.EntryList;
+
+import net.minecraft.world.item.ItemStack;
+
+import java.util.List;
+
+public sealed interface ItemEntryList extends EntryList<ItemStack>
+                                      permits ItemStackList, ItemTagList, ItemHolderSetList {
+
+    List<ItemStack> getStacks();
+
+    boolean isEmpty();
+}
diff --git a/src/main/java/com/gregtechceu/gtceu/integration/xei/entry/item/ItemHolderSetList.java b/src/main/java/com/gregtechceu/gtceu/integration/recipeviewer/entry/item/ItemHolderSetList.java
similarity index 95%
rename from src/main/java/com/gregtechceu/gtceu/integration/xei/entry/item/ItemHolderSetList.java
rename to src/main/java/com/gregtechceu/gtceu/integration/recipeviewer/entry/item/ItemHolderSetList.java
index 7ceeeb8798f..c0bf2a3a672 100644
--- a/src/main/java/com/gregtechceu/gtceu/integration/xei/entry/item/ItemHolderSetList.java
+++ b/src/main/java/com/gregtechceu/gtceu/integration/recipeviewer/entry/item/ItemHolderSetList.java
@@ -1,4 +1,4 @@
-package com.gregtechceu.gtceu.integration.xei.entry.item;
+package com.gregtechceu.gtceu.integration.recipeviewer.entry.item;
 
 import net.minecraft.core.HolderSet;
 import net.minecraft.nbt.CompoundTag;
diff --git a/src/main/java/com/gregtechceu/gtceu/integration/xei/entry/item/ItemStackList.java b/src/main/java/com/gregtechceu/gtceu/integration/recipeviewer/entry/item/ItemStackList.java
similarity index 94%
rename from src/main/java/com/gregtechceu/gtceu/integration/xei/entry/item/ItemStackList.java
rename to src/main/java/com/gregtechceu/gtceu/integration/recipeviewer/entry/item/ItemStackList.java
index f6d336f9798..19946e51e35 100644
--- a/src/main/java/com/gregtechceu/gtceu/integration/xei/entry/item/ItemStackList.java
+++ b/src/main/java/com/gregtechceu/gtceu/integration/recipeviewer/entry/item/ItemStackList.java
@@ -1,4 +1,4 @@
-package com.gregtechceu.gtceu.integration.xei.entry.item;
+package com.gregtechceu.gtceu.integration.recipeviewer.entry.item;
 
 import net.minecraft.world.item.ItemStack;
 
diff --git a/src/main/java/com/gregtechceu/gtceu/integration/xei/entry/item/ItemTagList.java b/src/main/java/com/gregtechceu/gtceu/integration/recipeviewer/entry/item/ItemTagList.java
similarity index 96%
rename from src/main/java/com/gregtechceu/gtceu/integration/xei/entry/item/ItemTagList.java
rename to src/main/java/com/gregtechceu/gtceu/integration/recipeviewer/entry/item/ItemTagList.java
index d8a4e3a7fd8..f269f42d817 100644
--- a/src/main/java/com/gregtechceu/gtceu/integration/xei/entry/item/ItemTagList.java
+++ b/src/main/java/com/gregtechceu/gtceu/integration/recipeviewer/entry/item/ItemTagList.java
@@ -1,4 +1,4 @@
-package com.gregtechceu.gtceu.integration.xei.entry.item;
+package com.gregtechceu.gtceu.integration.recipeviewer.entry.item;
 
 import net.minecraft.core.Holder;
 import net.minecraft.core.HolderSet;
diff --git a/src/main/java/com/gregtechceu/gtceu/integration/xei/handlers/fluid/CycleFluidEntryHandler.java b/src/main/java/com/gregtechceu/gtceu/integration/recipeviewer/handlers/fluid/CycleFluidEntryHandler.java
similarity index 69%
rename from src/main/java/com/gregtechceu/gtceu/integration/xei/handlers/fluid/CycleFluidEntryHandler.java
rename to src/main/java/com/gregtechceu/gtceu/integration/recipeviewer/handlers/fluid/CycleFluidEntryHandler.java
index 5da77a94151..96444cd34d1 100644
--- a/src/main/java/com/gregtechceu/gtceu/integration/xei/handlers/fluid/CycleFluidEntryHandler.java
+++ b/src/main/java/com/gregtechceu/gtceu/integration/recipeviewer/handlers/fluid/CycleFluidEntryHandler.java
@@ -1,19 +1,19 @@
-package com.gregtechceu.gtceu.integration.xei.handlers.fluid;
+package com.gregtechceu.gtceu.integration.recipeviewer.handlers.fluid;
 
-import com.gregtechceu.gtceu.api.transfer.fluid.IFluidHandlerModifiable;
-import com.gregtechceu.gtceu.integration.xei.entry.fluid.FluidEntryList;
-import com.gregtechceu.gtceu.integration.xei.entry.fluid.FluidStackList;
+import com.gregtechceu.gtceu.integration.recipeviewer.entry.fluid.FluidEntryList;
 
 import net.minecraftforge.fluids.FluidStack;
+import net.minecraftforge.fluids.capability.IFluidHandler;
 
 import lombok.Getter;
 import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
 
 import java.util.ArrayList;
 import java.util.List;
 import java.util.stream.Collectors;
 
-public class CycleFluidEntryHandler implements IFluidHandlerModifiable {
+public class CycleFluidEntryHandler implements IFluidHandler {
 
     @Getter
     private final List<FluidEntryList> entries;
@@ -33,7 +33,7 @@ public List<List<FluidStack>> getUnwrapped() {
         return unwrapped;
     }
 
-    private static List<FluidStack> getStacksNullable(FluidEntryList list) {
+    private static @Nullable List<FluidStack> getStacksNullable(FluidEntryList list) {
         if (list == null) return null;
         return list.getStacks();
     }
@@ -55,13 +55,15 @@ public FluidStack getFluidInTank(int tank) {
                 stackList.get(Math.abs((int) (System.currentTimeMillis() / 1000) % stackList.size()));
     }
 
-    @Override
-    public void setFluidInTank(int tank, @NotNull FluidStack fluidStack) {
-        if (tank >= 0 && tank < entries.size()) {
-            entries.set(tank, FluidStackList.of(fluidStack));
-            unwrapped = null;
-        }
-    }
+    /*
+     * @Override
+     * public void setFluidInTank(int tank, @NotNull FluidStack fluidStack) {
+     * if (tank >= 0 && tank < entries.size()) {
+     * entries.set(tank, FluidStackList.of(fluidStack));
+     * unwrapped = null;
+     * }
+     * }
+     */
 
     @Override
     public int getTankCapacity(int tank) {
@@ -78,10 +80,10 @@ public int fill(FluidStack resource, FluidAction action) {
         return 0;
     }
 
-    @Override
-    public boolean supportsFill(int tank) {
-        return false;
-    }
+    // @Override
+    // public boolean supportsFill(int tank) {
+    // return false;
+    // }
 
     @NotNull
     @Override
@@ -94,8 +96,8 @@ public FluidStack drain(FluidStack resource, FluidAction action) {
         return FluidStack.EMPTY;
     }
 
-    @Override
-    public boolean supportsDrain(int tank) {
-        return false;
-    }
+    // @Override
+    // public boolean supportsDrain(int tank) {
+    // return false;
+    // }
 }
diff --git a/src/main/java/com/gregtechceu/gtceu/integration/recipeviewer/handlers/fluid/EmptyFluidTank.java b/src/main/java/com/gregtechceu/gtceu/integration/recipeviewer/handlers/fluid/EmptyFluidTank.java
new file mode 100644
index 00000000000..d57216d41ea
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/integration/recipeviewer/handlers/fluid/EmptyFluidTank.java
@@ -0,0 +1,49 @@
+package com.gregtechceu.gtceu.integration.recipeviewer.handlers.fluid;
+
+import net.minecraftforge.fluids.FluidStack;
+import net.minecraftforge.fluids.IFluidTank;
+import net.minecraftforge.fluids.capability.IFluidHandler;
+
+import org.jetbrains.annotations.NotNull;
+
+public class EmptyFluidTank implements IFluidTank {
+
+    public static final EmptyFluidTank INSTANCE = new EmptyFluidTank();
+
+    protected EmptyFluidTank() {}
+
+    @Override
+    public @NotNull FluidStack getFluid() {
+        return FluidStack.EMPTY;
+    }
+
+    @Override
+    public int getFluidAmount() {
+        return 0;
+    }
+
+    @Override
+    public int getCapacity() {
+        return 0;
+    }
+
+    @Override
+    public boolean isFluidValid(@NotNull FluidStack stack) {
+        return false;
+    }
+
+    @Override
+    public int fill(@NotNull FluidStack resource, @NotNull IFluidHandler.FluidAction action) {
+        return 0;
+    }
+
+    @Override
+    public @NotNull FluidStack drain(int maxDrain, IFluidHandler.FluidAction action) {
+        return FluidStack.EMPTY;
+    }
+
+    @Override
+    public @NotNull FluidStack drain(FluidStack resource, IFluidHandler.FluidAction action) {
+        return FluidStack.EMPTY;
+    }
+}
diff --git a/src/main/java/com/gregtechceu/gtceu/integration/xei/handlers/item/CycleItemEntryHandler.java b/src/main/java/com/gregtechceu/gtceu/integration/recipeviewer/handlers/item/CycleItemEntryHandler.java
similarity index 91%
rename from src/main/java/com/gregtechceu/gtceu/integration/xei/handlers/item/CycleItemEntryHandler.java
rename to src/main/java/com/gregtechceu/gtceu/integration/recipeviewer/handlers/item/CycleItemEntryHandler.java
index c2229967630..469c560a2a6 100644
--- a/src/main/java/com/gregtechceu/gtceu/integration/xei/handlers/item/CycleItemEntryHandler.java
+++ b/src/main/java/com/gregtechceu/gtceu/integration/recipeviewer/handlers/item/CycleItemEntryHandler.java
@@ -1,7 +1,7 @@
-package com.gregtechceu.gtceu.integration.xei.handlers.item;
+package com.gregtechceu.gtceu.integration.recipeviewer.handlers.item;
 
-import com.gregtechceu.gtceu.integration.xei.entry.item.ItemEntryList;
-import com.gregtechceu.gtceu.integration.xei.entry.item.ItemStackList;
+import com.gregtechceu.gtceu.integration.recipeviewer.entry.item.ItemEntryList;
+import com.gregtechceu.gtceu.integration.recipeviewer.entry.item.ItemStackList;
 
 import net.minecraft.world.item.ItemStack;
 import net.minecraftforge.items.IItemHandlerModifiable;
@@ -92,6 +92,6 @@ public int getSlotLimit(int slot) {
 
     @Override
     public boolean isItemValid(int slot, @NotNull ItemStack stack) {
-        return false;
+        return true;
     }
 }
diff --git a/src/main/java/com/gregtechceu/gtceu/integration/recipeviewer/widgets/GTMuiRecipeWidget.java b/src/main/java/com/gregtechceu/gtceu/integration/recipeviewer/widgets/GTMuiRecipeWidget.java
new file mode 100644
index 00000000000..93e2a8a894c
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/integration/recipeviewer/widgets/GTMuiRecipeWidget.java
@@ -0,0 +1,16 @@
+package com.gregtechceu.gtceu.integration.recipeviewer.widgets;
+
+import com.gregtechceu.gtceu.api.recipe.GTRecipe;
+
+import brachy.modularui.widget.ParentWidget;
+
+public class GTMuiRecipeWidget extends ParentWidget<GTMuiRecipeWidget> {
+
+    private final GTRecipe recipe;
+
+    public GTMuiRecipeWidget(GTRecipe recipe) {
+        this.recipe = recipe;
+    }
+
+    private void initializeWidgets() {}
+}
diff --git a/src/main/java/com/gregtechceu/gtceu/integration/xei/widgets/GTOreByProduct.java b/src/main/java/com/gregtechceu/gtceu/integration/recipeviewer/widgets/GTOreByProduct.java
similarity index 96%
rename from src/main/java/com/gregtechceu/gtceu/integration/xei/widgets/GTOreByProduct.java
rename to src/main/java/com/gregtechceu/gtceu/integration/recipeviewer/widgets/GTOreByProduct.java
index 6e1f89112d0..386f21d108b 100644
--- a/src/main/java/com/gregtechceu/gtceu/integration/xei/widgets/GTOreByProduct.java
+++ b/src/main/java/com/gregtechceu/gtceu/integration/recipeviewer/widgets/GTOreByProduct.java
@@ -1,4 +1,4 @@
-package com.gregtechceu.gtceu.integration.xei.widgets;
+package com.gregtechceu.gtceu.integration.recipeviewer.widgets;
 
 import com.gregtechceu.gtceu.api.GTValues;
 import com.gregtechceu.gtceu.api.data.chemical.ChemicalHelper;
@@ -11,12 +11,12 @@
 import com.gregtechceu.gtceu.api.recipe.content.Content;
 import com.gregtechceu.gtceu.common.data.GTMachines;
 import com.gregtechceu.gtceu.common.data.GTMaterials;
-import com.gregtechceu.gtceu.integration.xei.entry.fluid.FluidEntryList;
-import com.gregtechceu.gtceu.integration.xei.entry.fluid.FluidStackList;
-import com.gregtechceu.gtceu.integration.xei.entry.fluid.FluidTagList;
-import com.gregtechceu.gtceu.integration.xei.entry.item.ItemEntryList;
-import com.gregtechceu.gtceu.integration.xei.entry.item.ItemStackList;
-import com.gregtechceu.gtceu.integration.xei.entry.item.ItemTagList;
+import com.gregtechceu.gtceu.integration.recipeviewer.entry.fluid.FluidEntryList;
+import com.gregtechceu.gtceu.integration.recipeviewer.entry.fluid.FluidStackList;
+import com.gregtechceu.gtceu.integration.recipeviewer.entry.fluid.FluidTagList;
+import com.gregtechceu.gtceu.integration.recipeviewer.entry.item.ItemEntryList;
+import com.gregtechceu.gtceu.integration.recipeviewer.entry.item.ItemStackList;
+import com.gregtechceu.gtceu.integration.recipeviewer.entry.item.ItemTagList;
 import com.gregtechceu.gtceu.utils.FormattingUtil;
 
 import net.minecraft.core.NonNullList;
diff --git a/src/main/java/com/gregtechceu/gtceu/integration/xei/widgets/GTOreByProductWidget.java b/src/main/java/com/gregtechceu/gtceu/integration/recipeviewer/widgets/GTOreByProductWidget.java
similarity index 95%
rename from src/main/java/com/gregtechceu/gtceu/integration/xei/widgets/GTOreByProductWidget.java
rename to src/main/java/com/gregtechceu/gtceu/integration/recipeviewer/widgets/GTOreByProductWidget.java
index 750baa14cc2..fd4da1417a5 100644
--- a/src/main/java/com/gregtechceu/gtceu/integration/xei/widgets/GTOreByProductWidget.java
+++ b/src/main/java/com/gregtechceu/gtceu/integration/recipeviewer/widgets/GTOreByProductWidget.java
@@ -1,4 +1,4 @@
-package com.gregtechceu.gtceu.integration.xei.widgets;
+package com.gregtechceu.gtceu.integration.recipeviewer.widgets;
 
 import com.gregtechceu.gtceu.api.data.chemical.material.Material;
 import com.gregtechceu.gtceu.api.gui.GuiTextures;
@@ -7,10 +7,10 @@
 import com.gregtechceu.gtceu.api.recipe.content.Content;
 import com.gregtechceu.gtceu.api.transfer.fluid.CustomFluidTank;
 import com.gregtechceu.gtceu.api.transfer.item.CustomItemStackHandler;
-import com.gregtechceu.gtceu.integration.xei.entry.fluid.FluidEntryList;
-import com.gregtechceu.gtceu.integration.xei.entry.item.ItemEntryList;
-import com.gregtechceu.gtceu.integration.xei.handlers.fluid.CycleFluidEntryHandler;
-import com.gregtechceu.gtceu.integration.xei.handlers.item.CycleItemEntryHandler;
+import com.gregtechceu.gtceu.integration.recipeviewer.entry.fluid.FluidEntryList;
+import com.gregtechceu.gtceu.integration.recipeviewer.entry.item.ItemEntryList;
+import com.gregtechceu.gtceu.integration.recipeviewer.handlers.fluid.CycleFluidEntryHandler;
+import com.gregtechceu.gtceu.integration.recipeviewer.handlers.item.CycleItemEntryHandler;
 
 import com.lowdragmc.lowdraglib.gui.texture.IGuiTexture;
 import com.lowdragmc.lowdraglib.gui.widget.ImageWidget;
diff --git a/src/main/java/com/gregtechceu/gtceu/integration/xei/widgets/GTOreVeinWidget.java b/src/main/java/com/gregtechceu/gtceu/integration/recipeviewer/widgets/GTOreVeinWidget.java
similarity index 99%
rename from src/main/java/com/gregtechceu/gtceu/integration/xei/widgets/GTOreVeinWidget.java
rename to src/main/java/com/gregtechceu/gtceu/integration/recipeviewer/widgets/GTOreVeinWidget.java
index c1dfe009a6c..ae7fcf3d6d7 100644
--- a/src/main/java/com/gregtechceu/gtceu/integration/xei/widgets/GTOreVeinWidget.java
+++ b/src/main/java/com/gregtechceu/gtceu/integration/recipeviewer/widgets/GTOreVeinWidget.java
@@ -1,4 +1,4 @@
-package com.gregtechceu.gtceu.integration.xei.widgets;
+package com.gregtechceu.gtceu.integration.recipeviewer.widgets;
 
 import com.gregtechceu.gtceu.api.data.DimensionMarker;
 import com.gregtechceu.gtceu.api.data.chemical.ChemicalHelper;
diff --git a/src/main/java/com/gregtechceu/gtceu/integration/xei/widgets/GTProgrammedCircuitWidget.java b/src/main/java/com/gregtechceu/gtceu/integration/recipeviewer/widgets/GTProgrammedCircuitWidget.java
similarity index 95%
rename from src/main/java/com/gregtechceu/gtceu/integration/xei/widgets/GTProgrammedCircuitWidget.java
rename to src/main/java/com/gregtechceu/gtceu/integration/recipeviewer/widgets/GTProgrammedCircuitWidget.java
index 72404571157..c3fef8d35b3 100644
--- a/src/main/java/com/gregtechceu/gtceu/integration/xei/widgets/GTProgrammedCircuitWidget.java
+++ b/src/main/java/com/gregtechceu/gtceu/integration/recipeviewer/widgets/GTProgrammedCircuitWidget.java
@@ -1,4 +1,4 @@
-package com.gregtechceu.gtceu.integration.xei.widgets;
+package com.gregtechceu.gtceu.integration.recipeviewer.widgets;
 
 import com.gregtechceu.gtceu.api.gui.GuiTextures;
 import com.gregtechceu.gtceu.api.gui.widget.SlotWidget;
diff --git a/src/main/java/com/gregtechceu/gtceu/integration/xei/widgets/GTRecipeWidget.java b/src/main/java/com/gregtechceu/gtceu/integration/recipeviewer/widgets/GTRecipeWidget.java
similarity index 99%
rename from src/main/java/com/gregtechceu/gtceu/integration/xei/widgets/GTRecipeWidget.java
rename to src/main/java/com/gregtechceu/gtceu/integration/recipeviewer/widgets/GTRecipeWidget.java
index f08ffa59d66..36b8f1c5a0d 100644
--- a/src/main/java/com/gregtechceu/gtceu/integration/xei/widgets/GTRecipeWidget.java
+++ b/src/main/java/com/gregtechceu/gtceu/integration/recipeviewer/widgets/GTRecipeWidget.java
@@ -1,4 +1,4 @@
-package com.gregtechceu.gtceu.integration.xei.widgets;
+package com.gregtechceu.gtceu.integration.recipeviewer.widgets;
 
 import com.gregtechceu.gtceu.GTCEu;
 import com.gregtechceu.gtceu.api.GTValues;
diff --git a/src/main/java/com/gregtechceu/gtceu/integration/rei/circuit/GTProgrammedCircuitCategory.java b/src/main/java/com/gregtechceu/gtceu/integration/rei/circuit/GTProgrammedCircuitCategory.java
index 871f56969f7..b28c65433a8 100644
--- a/src/main/java/com/gregtechceu/gtceu/integration/rei/circuit/GTProgrammedCircuitCategory.java
+++ b/src/main/java/com/gregtechceu/gtceu/integration/rei/circuit/GTProgrammedCircuitCategory.java
@@ -2,7 +2,7 @@
 
 import com.gregtechceu.gtceu.GTCEu;
 import com.gregtechceu.gtceu.common.data.GTItems;
-import com.gregtechceu.gtceu.integration.xei.widgets.GTProgrammedCircuitWidget;
+import com.gregtechceu.gtceu.integration.recipeviewer.widgets.GTProgrammedCircuitWidget;
 
 import com.lowdragmc.lowdraglib.gui.texture.ItemStackTexture;
 import com.lowdragmc.lowdraglib.gui.widget.WidgetGroup;
diff --git a/src/main/java/com/gregtechceu/gtceu/integration/rei/oreprocessing/GTOreProcessingDisplay.java b/src/main/java/com/gregtechceu/gtceu/integration/rei/oreprocessing/GTOreProcessingDisplay.java
index 0e47c68a237..a0b17b42ab2 100644
--- a/src/main/java/com/gregtechceu/gtceu/integration/rei/oreprocessing/GTOreProcessingDisplay.java
+++ b/src/main/java/com/gregtechceu/gtceu/integration/rei/oreprocessing/GTOreProcessingDisplay.java
@@ -1,7 +1,7 @@
 package com.gregtechceu.gtceu.integration.rei.oreprocessing;
 
 import com.gregtechceu.gtceu.api.data.chemical.material.Material;
-import com.gregtechceu.gtceu.integration.xei.widgets.GTOreByProductWidget;
+import com.gregtechceu.gtceu.integration.recipeviewer.widgets.GTOreByProductWidget;
 
 import com.lowdragmc.lowdraglib.gui.widget.WidgetGroup;
 import com.lowdragmc.lowdraglib.rei.ModularDisplay;
diff --git a/src/main/java/com/gregtechceu/gtceu/integration/rei/orevein/GTBedrockFluidDisplay.java b/src/main/java/com/gregtechceu/gtceu/integration/rei/orevein/GTBedrockFluidDisplay.java
index 8dbef3a050f..c7ca98bdeb7 100644
--- a/src/main/java/com/gregtechceu/gtceu/integration/rei/orevein/GTBedrockFluidDisplay.java
+++ b/src/main/java/com/gregtechceu/gtceu/integration/rei/orevein/GTBedrockFluidDisplay.java
@@ -1,7 +1,7 @@
 package com.gregtechceu.gtceu.integration.rei.orevein;
 
 import com.gregtechceu.gtceu.api.data.worldgen.bedrockfluid.BedrockFluidDefinition;
-import com.gregtechceu.gtceu.integration.xei.widgets.GTOreVeinWidget;
+import com.gregtechceu.gtceu.integration.recipeviewer.widgets.GTOreVeinWidget;
 
 import com.lowdragmc.lowdraglib.gui.widget.WidgetGroup;
 import com.lowdragmc.lowdraglib.rei.ModularDisplay;
diff --git a/src/main/java/com/gregtechceu/gtceu/integration/rei/orevein/GTBedrockFluidDisplayCategory.java b/src/main/java/com/gregtechceu/gtceu/integration/rei/orevein/GTBedrockFluidDisplayCategory.java
index 69dd53d0809..1d32a4b855a 100644
--- a/src/main/java/com/gregtechceu/gtceu/integration/rei/orevein/GTBedrockFluidDisplayCategory.java
+++ b/src/main/java/com/gregtechceu/gtceu/integration/rei/orevein/GTBedrockFluidDisplayCategory.java
@@ -5,7 +5,7 @@
 import com.gregtechceu.gtceu.client.ClientProxy;
 import com.gregtechceu.gtceu.common.data.GTItems;
 import com.gregtechceu.gtceu.common.data.GTMaterials;
-import com.gregtechceu.gtceu.integration.xei.widgets.GTOreVeinWidget;
+import com.gregtechceu.gtceu.integration.recipeviewer.widgets.GTOreVeinWidget;
 
 import com.lowdragmc.lowdraglib.gui.texture.ItemStackTexture;
 import com.lowdragmc.lowdraglib.rei.IGui2Renderer;
diff --git a/src/main/java/com/gregtechceu/gtceu/integration/rei/orevein/GTBedrockOreDisplay.java b/src/main/java/com/gregtechceu/gtceu/integration/rei/orevein/GTBedrockOreDisplay.java
index 22e570e2523..43d10393d5f 100644
--- a/src/main/java/com/gregtechceu/gtceu/integration/rei/orevein/GTBedrockOreDisplay.java
+++ b/src/main/java/com/gregtechceu/gtceu/integration/rei/orevein/GTBedrockOreDisplay.java
@@ -4,7 +4,7 @@
 import com.gregtechceu.gtceu.api.data.chemical.material.Material;
 import com.gregtechceu.gtceu.api.data.tag.TagPrefix;
 import com.gregtechceu.gtceu.api.data.worldgen.bedrockore.BedrockOreDefinition;
-import com.gregtechceu.gtceu.integration.xei.widgets.GTOreVeinWidget;
+import com.gregtechceu.gtceu.integration.recipeviewer.widgets.GTOreVeinWidget;
 
 import com.lowdragmc.lowdraglib.gui.widget.WidgetGroup;
 import com.lowdragmc.lowdraglib.rei.ModularDisplay;
diff --git a/src/main/java/com/gregtechceu/gtceu/integration/rei/orevein/GTBedrockOreDisplayCategory.java b/src/main/java/com/gregtechceu/gtceu/integration/rei/orevein/GTBedrockOreDisplayCategory.java
index 273de569831..07db738a459 100644
--- a/src/main/java/com/gregtechceu/gtceu/integration/rei/orevein/GTBedrockOreDisplayCategory.java
+++ b/src/main/java/com/gregtechceu/gtceu/integration/rei/orevein/GTBedrockOreDisplayCategory.java
@@ -5,7 +5,7 @@
 import com.gregtechceu.gtceu.client.ClientProxy;
 import com.gregtechceu.gtceu.common.data.GTItems;
 import com.gregtechceu.gtceu.common.data.GTMaterials;
-import com.gregtechceu.gtceu.integration.xei.widgets.GTOreVeinWidget;
+import com.gregtechceu.gtceu.integration.recipeviewer.widgets.GTOreVeinWidget;
 
 import com.lowdragmc.lowdraglib.gui.texture.ItemStackTexture;
 import com.lowdragmc.lowdraglib.rei.IGui2Renderer;
diff --git a/src/main/java/com/gregtechceu/gtceu/integration/rei/orevein/GTOreVeinDisplay.java b/src/main/java/com/gregtechceu/gtceu/integration/rei/orevein/GTOreVeinDisplay.java
index 730ec06f0ad..ffd68cfb57e 100644
--- a/src/main/java/com/gregtechceu/gtceu/integration/rei/orevein/GTOreVeinDisplay.java
+++ b/src/main/java/com/gregtechceu/gtceu/integration/rei/orevein/GTOreVeinDisplay.java
@@ -1,7 +1,7 @@
 package com.gregtechceu.gtceu.integration.rei.orevein;
 
 import com.gregtechceu.gtceu.api.data.worldgen.GTOreDefinition;
-import com.gregtechceu.gtceu.integration.xei.widgets.GTOreVeinWidget;
+import com.gregtechceu.gtceu.integration.recipeviewer.widgets.GTOreVeinWidget;
 
 import com.lowdragmc.lowdraglib.gui.widget.WidgetGroup;
 import com.lowdragmc.lowdraglib.rei.ModularDisplay;
diff --git a/src/main/java/com/gregtechceu/gtceu/integration/rei/orevein/GTOreVeinDisplayCategory.java b/src/main/java/com/gregtechceu/gtceu/integration/rei/orevein/GTOreVeinDisplayCategory.java
index 0a9d538f50d..0935a15e5d6 100644
--- a/src/main/java/com/gregtechceu/gtceu/integration/rei/orevein/GTOreVeinDisplayCategory.java
+++ b/src/main/java/com/gregtechceu/gtceu/integration/rei/orevein/GTOreVeinDisplayCategory.java
@@ -4,7 +4,7 @@
 import com.gregtechceu.gtceu.api.data.worldgen.GTOreDefinition;
 import com.gregtechceu.gtceu.client.ClientProxy;
 import com.gregtechceu.gtceu.common.data.GTItems;
-import com.gregtechceu.gtceu.integration.xei.widgets.GTOreVeinWidget;
+import com.gregtechceu.gtceu.integration.recipeviewer.widgets.GTOreVeinWidget;
 
 import com.lowdragmc.lowdraglib.gui.texture.ItemStackTexture;
 import com.lowdragmc.lowdraglib.rei.IGui2Renderer;
diff --git a/src/main/java/com/gregtechceu/gtceu/integration/rei/recipe/GTRecipeDisplay.java b/src/main/java/com/gregtechceu/gtceu/integration/rei/recipe/GTRecipeDisplay.java
index d017e7aec76..9e84d189fea 100644
--- a/src/main/java/com/gregtechceu/gtceu/integration/rei/recipe/GTRecipeDisplay.java
+++ b/src/main/java/com/gregtechceu/gtceu/integration/rei/recipe/GTRecipeDisplay.java
@@ -1,7 +1,7 @@
 package com.gregtechceu.gtceu.integration.rei.recipe;
 
 import com.gregtechceu.gtceu.api.recipe.GTRecipe;
-import com.gregtechceu.gtceu.integration.xei.widgets.GTRecipeWidget;
+import com.gregtechceu.gtceu.integration.recipeviewer.widgets.GTRecipeWidget;
 
 import com.lowdragmc.lowdraglib.gui.widget.WidgetGroup;
 import com.lowdragmc.lowdraglib.rei.ModularDisplay;
diff --git a/src/main/java/com/gregtechceu/gtceu/integration/xei/entry/fluid/FluidEntryList.java b/src/main/java/com/gregtechceu/gtceu/integration/xei/entry/fluid/FluidEntryList.java
deleted file mode 100644
index c1ae543f1c3..00000000000
--- a/src/main/java/com/gregtechceu/gtceu/integration/xei/entry/fluid/FluidEntryList.java
+++ /dev/null
@@ -1,12 +0,0 @@
-package com.gregtechceu.gtceu.integration.xei.entry.fluid;
-
-import net.minecraftforge.fluids.FluidStack;
-
-import java.util.List;
-
-public sealed interface FluidEntryList permits FluidStackList, FluidTagList, FluidHolderSetList {
-
-    List<FluidStack> getStacks();
-
-    boolean isEmpty();
-}
diff --git a/src/main/java/com/gregtechceu/gtceu/integration/xei/entry/item/ItemEntryList.java b/src/main/java/com/gregtechceu/gtceu/integration/xei/entry/item/ItemEntryList.java
deleted file mode 100644
index 6d4947fbf5c..00000000000
--- a/src/main/java/com/gregtechceu/gtceu/integration/xei/entry/item/ItemEntryList.java
+++ /dev/null
@@ -1,12 +0,0 @@
-package com.gregtechceu.gtceu.integration.xei.entry.item;
-
-import net.minecraft.world.item.ItemStack;
-
-import java.util.List;
-
-public sealed interface ItemEntryList permits ItemStackList, ItemTagList, ItemHolderSetList {
-
-    List<ItemStack> getStacks();
-
-    boolean isEmpty();
-}
diff --git a/src/main/java/com/gregtechceu/gtceu/utils/BlockPosUtil.java b/src/main/java/com/gregtechceu/gtceu/utils/BlockPosUtil.java
new file mode 100644
index 00000000000..5829c4646a4
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/utils/BlockPosUtil.java
@@ -0,0 +1,97 @@
+package com.gregtechceu.gtceu.utils;
+
+import net.minecraft.core.BlockPos;
+import net.minecraft.world.phys.Vec3;
+
+import org.joml.Vector3f;
+
+public class BlockPosUtil {
+
+    public static final BlockPos MAX = new BlockPos(Integer.MAX_VALUE, Integer.MAX_VALUE, Integer.MAX_VALUE);
+    public static final BlockPos MIN = new BlockPos(Integer.MIN_VALUE, Integer.MIN_VALUE, Integer.MIN_VALUE);
+
+    public static int getBlockCountInside(BlockPos p1, BlockPos p2) {
+        return getXDist(p1, p2) * getYDist(p1, p2) * getZDist(p1, p2);
+    }
+
+    public static int getXDist(BlockPos p1, BlockPos p2) {
+        return Math.abs(p1.getX() - p2.getX());
+    }
+
+    public static int getYDist(BlockPos p1, BlockPos p2) {
+        return Math.abs(p1.getY() - p2.getY());
+    }
+
+    public static int getZDist(BlockPos p1, BlockPos p2) {
+        return Math.abs(p1.getZ() - p2.getZ());
+    }
+
+    public static BlockPos getMin(BlockPos p1, BlockPos p2) {
+        return new BlockPos(Math.min(p1.getX(), p2.getX()),
+                Math.min(p1.getY(), p2.getY()),
+                Math.min(p1.getZ(), p2.getZ()));
+    }
+
+    public static BlockPos getMax(BlockPos p1, BlockPos p2) {
+        return new BlockPos(Math.max(p1.getX(), p2.getX()), Math.max(p1.getY(), p2.getY()),
+                Math.max(p1.getZ(), p2.getZ()));
+    }
+
+    public static void setMin(BlockPos.MutableBlockPos p1, BlockPos p2) {
+        p1.set(Math.min(p1.getX(), p2.getX()), Math.min(p1.getY(), p2.getY()), Math.min(p1.getZ(), p2.getZ()));
+    }
+
+    public static void setMax(BlockPos.MutableBlockPos p1, BlockPos p2) {
+        p1.set(Math.max(p1.getX(), p2.getX()), Math.max(p1.getY(), p2.getY()), Math.max(p1.getZ(), p2.getZ()));
+    }
+
+    public static BlockPos getCenter(BlockPos p1, BlockPos p2) {
+        BlockPos min = getMin(p1, p2);
+        return new BlockPos(getXDist(p1, p2) / 2 + min.getX(), getYDist(p1, p2) / 2 + min.getY(),
+                getYDist(p1, p2) / 2 + min.getY());
+    }
+
+    public static Vector3f getCenterF(BlockPos p1, BlockPos p2) {
+        BlockPos min = getMin(p1, p2);
+        return getCenterF(min.getX(), min.getY(), min.getZ(), getXDist(p1, p2), getYDist(p1, p2), getZDist(p1, p2));
+    }
+
+    public static Vector3f getCenterF(int oX, int oY, int oZ, int dX, int dY, int dZ) {
+        return new Vector3f(dX / 2.0f + oX, dY / 2.0f + oY, dZ / 2.0f + oZ);
+    }
+
+    public static Vec3 getCenterD(BlockPos p1, BlockPos p2) {
+        BlockPos min = getMin(p1, p2);
+        return getCenterD(min.getX(), min.getY(), min.getZ(), getXDist(p1, p2), getYDist(p1, p2), getZDist(p1, p2));
+    }
+
+    public static Vec3 getCenterD(int oX, int oY, int oZ, int dX, int dY, int dZ) {
+        return new Vec3(dX / 2.0 + oX, dY / 2.0 + oY, dZ / 2.0 + oZ);
+    }
+
+    public static Iterable<BlockPos> getAllInside(BlockPos p1, BlockPos p2, boolean includeBorder) {
+        int x0 = Math.min(p1.getX(), p2.getX());
+        int y0 = Math.min(p1.getY(), p2.getY());
+        int z0 = Math.min(p1.getZ(), p2.getZ());
+        int x1 = Math.max(p1.getX(), p2.getX());
+        int y1 = Math.max(p1.getY(), p2.getY());
+        int z1 = Math.max(p1.getZ(), p2.getZ());
+
+        if (includeBorder) {
+            x0--;
+            y0--;
+            z0--;
+        } else {
+            x1--;
+            y1--;
+            z1--;
+        }
+        return BlockPos.betweenClosed(x0, y0, z0, x1, y1, z1);
+    }
+
+    public static boolean isOnBorder(BlockPos boxMin, BlockPos boxMax, BlockPos p) {
+        return p.getX() == boxMin.getX() || p.getX() == boxMax.getX() ||
+                p.getY() == boxMin.getY() || p.getY() == boxMax.getY() ||
+                p.getZ() == boxMin.getZ() || p.getZ() == boxMax.getZ();
+    }
+}
diff --git a/src/main/java/com/gregtechceu/gtceu/utils/FluidStackHashStrategy.java b/src/main/java/com/gregtechceu/gtceu/utils/FluidStackHashStrategy.java
deleted file mode 100644
index b8933c1ff3f..00000000000
--- a/src/main/java/com/gregtechceu/gtceu/utils/FluidStackHashStrategy.java
+++ /dev/null
@@ -1,113 +0,0 @@
-package com.gregtechceu.gtceu.utils;
-
-import net.minecraftforge.fluids.FluidStack;
-
-import it.unimi.dsi.fastutil.Hash;
-import org.jetbrains.annotations.Nullable;
-
-import java.util.Objects;
-
-/**
- * A configurable generator of hashing strategies, allowing for consideration of select properties of FluidStacks when
- * considering equality.
- */
-public interface FluidStackHashStrategy extends Hash.Strategy<FluidStack> {
-
-    /**
-     * @return a builder object for producing a custom FluidStackHashStrategy.
-     */
-    static FluidStackHashStrategy.FluidStackHashStrategyBuilder builder() {
-        return new FluidStackHashStrategy.FluidStackHashStrategyBuilder();
-    }
-
-    /**
-     * Generates an FluidStackHash configured to compare every aspect of FluidStacks.
-     *
-     * @return the FluidStackHashStrategy as described above.
-     */
-    static FluidStackHashStrategy comparingAll() {
-        return builder().compareFluid(true)
-                .compareCount(true)
-                .compareTag(true)
-                .build();
-    }
-
-    /**
-     * Generates an FluidStackHash configured to compare every aspect of FluidStacks except the number
-     * of fluids in the stack.
-     *
-     * @return the FluidStackHashStrategy as described above.
-     */
-    static FluidStackHashStrategy comparingAllButAmount() {
-        return builder().compareFluid(true)
-                .compareTag(true)
-                .build();
-    }
-
-    /**
-     * Builder pattern class for generating customized FluidStackHashStrategy
-     */
-    class FluidStackHashStrategyBuilder {
-
-        private boolean fluid, amount, damage, tag;
-
-        /**
-         * Defines whether the Fluid type should be considered for equality.
-         *
-         * @param choice {@code true} to consider this property, {@code false} to ignore it.
-         * @return {@code this}
-         */
-        public FluidStackHashStrategy.FluidStackHashStrategyBuilder compareFluid(boolean choice) {
-            fluid = choice;
-            return this;
-        }
-
-        /**
-         * Defines whether stack size should be considered for equality.
-         *
-         * @param choice {@code true} to consider this property, {@code false} to ignore it.
-         * @return {@code this}
-         */
-        public FluidStackHashStrategy.FluidStackHashStrategyBuilder compareCount(boolean choice) {
-            amount = choice;
-            return this;
-        }
-
-        /**
-         * Defines whether NBT Tags should be considered for equality.
-         *
-         * @param choice {@code true} to consider this property, {@code false} to ignore it.
-         * @return {@code this}
-         */
-        public FluidStackHashStrategy.FluidStackHashStrategyBuilder compareTag(boolean choice) {
-            tag = choice;
-            return this;
-        }
-
-        /**
-         * @return the FluidStackHashStrategy as configured by "compare" methods.
-         */
-        public FluidStackHashStrategy build() {
-            return new FluidStackHashStrategy() {
-
-                @Override
-                public int hashCode(@Nullable FluidStack o) {
-                    return o == null || o.isEmpty() ? 0 : Objects.hash(
-                            fluid ? o.getFluid() : null,
-                            amount ? o.getAmount() : null,
-                            tag ? o.getTag() : null);
-                }
-
-                @Override
-                public boolean equals(@Nullable FluidStack a, @Nullable FluidStack b) {
-                    if (a == null || a.isEmpty()) return b == null || b.isEmpty();
-                    if (b == null || b.isEmpty()) return false;
-
-                    return (!fluid || a.getFluid() == b.getFluid()) &&
-                            (!amount || a.getAmount() == b.getAmount()) &&
-                            (!tag || Objects.equals(a.getTag(), b.getTag()));
-                }
-            };
-        }
-    }
-}
diff --git a/src/main/java/com/gregtechceu/gtceu/utils/FormattingUtil.java b/src/main/java/com/gregtechceu/gtceu/utils/FormattingUtil.java
index caeaf139aed..fb5519913ef 100644
--- a/src/main/java/com/gregtechceu/gtceu/utils/FormattingUtil.java
+++ b/src/main/java/com/gregtechceu/gtceu/utils/FormattingUtil.java
@@ -7,7 +7,6 @@
 import net.minecraft.network.chat.MutableComponent;
 
 import org.apache.commons.lang3.StringUtils;
-import org.jetbrains.annotations.ApiStatus;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 
@@ -104,15 +103,6 @@ public static String toLowerCaseUnderscore(String string) {
         return result.toString();
     }
 
-    /**
-     * @deprecated use {@link FormattingUtil#toLowerCaseUnderscore(String) toLowerCaseUnderscore} instead.
-     */
-    @ApiStatus.Obsolete(since = "7.0.0")
-    @Deprecated(since = "7.0.0")
-    public static String toLowerCaseUnder(String string) {
-        return toLowerCaseUnderscore(string);
-    }
-
     /**
      * Check if {@code string} has any uppercase characters.
      *
diff --git a/src/main/java/com/gregtechceu/gtceu/utils/GTMath.java b/src/main/java/com/gregtechceu/gtceu/utils/GTMath.java
index ce8ec066a59..a6ba89da4ab 100644
--- a/src/main/java/com/gregtechceu/gtceu/utils/GTMath.java
+++ b/src/main/java/com/gregtechceu/gtceu/utils/GTMath.java
@@ -1,11 +1,19 @@
 package com.gregtechceu.gtceu.utils;
 
+import com.gregtechceu.gtceu.utils.math.ParseResult;
+import com.gregtechceu.gtceu.utils.math.PostfixPercentOperator;
+import com.gregtechceu.gtceu.utils.math.SIPrefix;
+
 import net.minecraft.MethodsReturnNonnullByDefault;
 import net.minecraft.core.Direction;
 import net.minecraft.util.Mth;
 import net.minecraft.world.item.ItemStack;
 import net.minecraftforge.fluids.FluidStack;
 
+import com.ezylang.evalex.BaseException;
+import com.ezylang.evalex.Expression;
+import com.ezylang.evalex.config.ExpressionConfiguration;
+import com.ezylang.evalex.data.EvaluationValue;
 import it.unimi.dsi.fastutil.ints.IntArrayList;
 import it.unimi.dsi.fastutil.objects.ObjectArrayList;
 import org.apache.commons.lang3.tuple.ImmutablePair;
@@ -13,6 +21,7 @@
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 import org.joml.Vector3f;
+import org.joml.Vector3fc;
 
 import java.math.BigDecimal;
 import java.math.BigInteger;
@@ -27,10 +36,50 @@
 @ParametersAreNonnullByDefault
 public class GTMath {
 
-    public static long clamp(long value, long min, long max) {
-        return Math.max(min, Math.min(max, value));
+    public static final float PI = (float) Math.PI;
+    public static final float PI2 = 2f * PI;
+    public static final float PI_HALF = PI / 2f;
+    public static final float PI_QUART = PI / 4f;
+
+    public static final ExpressionConfiguration MATH_CFG = ExpressionConfiguration.builder()
+            .arraysAllowed(false)
+            .structuresAllowed(false)
+            .stripTrailingZeros(true)
+            .build()
+            .withAdditionalOperators(Pair.of("%", new PostfixPercentOperator()));
+
+    public static ParseResult parseExpression(String expression) {
+        return parseExpression(expression, Double.NaN, false);
+    }
+
+    public static ParseResult parseExpression(String expression, boolean useSiPrefixes) {
+        return parseExpression(expression, Double.NaN, useSiPrefixes);
+    }
+
+    public static ParseResult parseExpression(String expression, double defaultValue) {
+        return parseExpression(expression, defaultValue, true);
+    }
+
+    public static ParseResult parseExpression(String expression, double defaultValue, boolean useSiPrefixes) {
+        if (expression == null || expression.isEmpty()) {
+            return ParseResult.success(EvaluationValue.numberValue(new BigDecimal(defaultValue)));
+        }
+
+        Expression e = new Expression(expression, MATH_CFG);
+        if (useSiPrefixes) {
+            SIPrefix.addAllToExpression(e);
+        }
+        try {
+            return ParseResult.success(e.evaluate());
+        } catch (BaseException exception) {
+            return ParseResult.failure(exception);
+        }
     }
 
+    public static final Vector3fc UNIT_X = new Vector3f(1f, 0f, 0f);
+    public static final Vector3fc UNIT_Y = new Vector3f(0f, 1f, 0f);
+    public static final Vector3fc UNIT_Z = new Vector3f(0f, 0f, 1f);
+
     public static int lerpInt(double delta, int start, int end) {
         return start + Mth.floor(delta * (end - start));
     }
@@ -64,7 +113,7 @@ public static List<FluidStack> splitFluidStacks(FluidStack stack, long amount) {
     public static int[] split(long value) {
         IntArrayList result = new IntArrayList();
         while (value > 0) {
-            int intValue = (int) Math.min(value, Integer.MAX_VALUE);
+            int intValue = (int) java.lang.Math.min(value, Integer.MAX_VALUE);
             result.add(intValue);
             value -= intValue;
         }
@@ -100,6 +149,39 @@ public static int ceilDiv(int x, int y) {
         return q;
     }
 
+    public static long clamp(long v, long min, long max) {
+        return Math.max(min, Math.min(max, v));
+    }
+
+    public static float clamp(float v, float min, float max) {
+        return Math.max(min, Math.min(max, v));
+    }
+
+    public static int cycler(int x, int min, int max) {
+        return x < min ? max : (x > max ? min : x);
+    }
+
+    public static float cycler(float x, float min, float max) {
+        return x < min ? max : (x > max ? min : x);
+    }
+
+    public static double cycler(double x, double min, double max) {
+        return x < min ? max : (x > max ? min : x);
+    }
+
+    public static int gridIndex(int x, int y, int size, int width) {
+        x = x / size;
+        y = y / size;
+
+        return x + y * width / size;
+    }
+
+    public static int gridRows(int count, int size, int width) {
+        double x = count * size / (double) width;
+
+        return count <= 0 ? 1 : (int) Math.ceil(x);
+    }
+
     public static float min(float @NotNull... values) {
         // noinspection ConstantValue
         if (values == null || values.length == 0) throw new IllegalArgumentException();
@@ -114,6 +196,20 @@ public static float min(float @NotNull... values) {
         return min;
     }
 
+    public static int min(int @NotNull... values) {
+        // noinspection ConstantValue
+        if (values == null || values.length == 0) throw new IllegalArgumentException();
+        if (values.length == 1) return values[0];
+        if (values.length == 2) return Math.min(values[0], values[1]);
+        int min = Integer.MAX_VALUE;
+        for (int i : values) {
+            if (i < min) {
+                min = i;
+            }
+        }
+        return min;
+    }
+
     public static float max(float @NotNull... values) {
         // noinspection ConstantValue
         if (values == null || values.length == 0) throw new IllegalArgumentException();
@@ -128,6 +224,20 @@ public static float max(float @NotNull... values) {
         return max;
     }
 
+    public static int max(int @NotNull... values) {
+        // noinspection ConstantValue
+        if (values == null || values.length == 0) throw new IllegalArgumentException();
+        if (values.length == 1) return values[0];
+        if (values.length == 2) return Math.max(values[0], values[1]);
+        int max = Integer.MIN_VALUE;
+        for (int i : values) {
+            if (i > max) {
+                max = i;
+            }
+        }
+        return max;
+    }
+
     public static Pair<Vector3f, Vector3f> getCoordinates(@Nullable Direction dir, float min, float max) {
         float x1 = min, y1 = min, z1 = min, x2 = max, y2 = max, z2 = max;
         if (dir != null) {
@@ -160,4 +270,38 @@ public static Pair<Vector3f, Vector3f> getCoordinates(@Nullable Direction dir, f
         }
         return ImmutablePair.of(new Vector3f(x1, y1, z1), new Vector3f(x2, y2, z2));
     }
+
+    public static float arithmeticGeometricMean(float a, float b) {
+        return arithmeticGeometricMean(a, b, 5);
+    }
+
+    public static float arithmeticGeometricMean(float a, float b, int iterations) {
+        a = (a + b) / 2;
+        b = Mth.sqrt(a * b);
+        if (--iterations == 0) return a;
+        return arithmeticGeometricMean(a, b, iterations);
+    }
+
+    public static double rescaleLinear(double v, double fromMin, double fromMax, double toMin, double toMax) {
+        v = (v - fromMin) / (fromMax - fromMin); // reverse lerp
+        return toMin + (toMax - toMin) * v; // forward lerp
+    }
+
+    public static float rescaleLinear(float v, float fromMin, float fromMax, float toMin, float toMax) {
+        v = (v - fromMin) / (fromMax - fromMin); // reverse lerp
+        return toMin + (toMax - toMin) * v; // forward lerp
+    }
+
+    public static int intPlaces(BigDecimal x) {
+        return Math.max(1, x.precision() - x.scale());
+    }
+
+    public static int intPlaces(double x) {
+        if (x == 0.0) return 1;
+        x = Math.abs(x);
+        int d = (int) Math.floor(Math.log10(x)) + 1;
+        // correct rounding errors
+        if (Math.pow(10, d - 1) > x) d--;
+        return Math.max(d, 1);
+    }
 }
diff --git a/src/main/java/com/gregtechceu/gtceu/utils/GTMatrixUtils.java b/src/main/java/com/gregtechceu/gtceu/utils/GTMatrixUtils.java
index 44f6ad29e34..5ab77d3718d 100644
--- a/src/main/java/com/gregtechceu/gtceu/utils/GTMatrixUtils.java
+++ b/src/main/java/com/gregtechceu/gtceu/utils/GTMatrixUtils.java
@@ -2,6 +2,7 @@
 
 import net.minecraft.MethodsReturnNonnullByDefault;
 import net.minecraft.Util;
+import net.minecraft.client.Minecraft;
 import net.minecraft.core.Direction;
 import net.minecraft.util.Mth;
 
@@ -9,10 +10,16 @@
 import com.google.common.collect.ImmutableMap;
 import com.google.common.collect.Table;
 import com.google.common.collect.Tables;
+import com.mojang.blaze3d.platform.GlUtil;
+import com.mojang.blaze3d.platform.Window;
+import com.mojang.blaze3d.systems.RenderSystem;
+import com.mojang.blaze3d.vertex.PoseStack;
 import org.jetbrains.annotations.Contract;
 import org.joml.*;
+import org.lwjgl.opengl.GL11;
 
 import java.lang.Math;
+import java.nio.ByteBuffer;
 import java.security.InvalidParameterException;
 import java.util.Objects;
 
@@ -33,6 +40,9 @@ public class GTMatrixUtils {
     private static final Table<Direction, Direction, Matrix4fc> rotations = Tables
             .synchronizedTable(HashBasedTable.create());
 
+    private static final ByteBuffer PIXEL_DEPTH_BUFFER = GlUtil.allocateMemory(4);
+    private static final int[] VIEWPORT_COORDS = { 0, 0, 0, 0 };
+
     /**
      * @param from the original vector
      * @param to   the wanted vector
@@ -135,12 +145,12 @@ public static float upwardFacingAngle(Direction upward) {
 
     public static Vector3f rotateMatrixToFront(Matrix4f matrix, Direction frontFace) {
         // rotate frontFacing to correct cardinal direction
-        var front = frontFace.step();
+        Vector3f front = frontFace.step();
         rotateMatrix(matrix, Direction.NORTH.step(), getDirectionAxis(frontFace), front);
         return front;
     }
 
-    public static void rotateMatrixToUp(Matrix4f matrix, Vector3f front, Direction upwardsFace) {
+    public static void rotateMatrixToUp(Matrix4f matrix, Vector3fc front, Direction upwardsFace) {
         // rotate upwards face to the correct orientation
         rotateMatrix(matrix, upwardFacingAngle(upwardsFace), front);
     }
@@ -162,4 +172,125 @@ public static Matrix4fc createRotationState(Direction frontFace, Direction upwar
     public static Vector3fc getDirectionAxis(Direction dir) {
         return Objects.requireNonNull(directionAxises.get(dir));
     }
+
+    /**
+     * {@link Matrix4f#lookAt(Vector3fc, Vector3fc, Vector3fc) Matrix4f#lookAt} with an up axis of {@code (0, 1, 0)}
+     *
+     * @see Matrix4f#lookAt(Vector3fc, Vector3fc, Vector3fc)
+     */
+    public static Matrix4f lookAt(Vector3fc eyePos, Vector3fc target) {
+        return new Matrix4f().lookAt(eyePos, target, GTMath.UNIT_Y);
+    }
+
+    /**
+     * Make the pose stack's topmost transformation look at a point
+     *
+     * @param poseStack the pose stack to modify
+     * @param eyePos    the position of the camera
+     * @param target    the point to look at
+     */
+    public static void lookAt(PoseStack poseStack, Vector3fc eyePos, Vector3fc target) {
+        lookAt(poseStack.last(), eyePos, target);
+    }
+
+    /**
+     * Make the pose stack's topmost transformation look at a point
+     *
+     * @param pose   the pose stack layer to modify
+     * @param eyePos the position of the camera
+     * @param target the point to look at
+     */
+    public static void lookAt(PoseStack.Pose pose, Vector3fc eyePos, Vector3fc target) {
+        pose.pose().lookAt(eyePos, target, GTMath.UNIT_Y);
+        pose.normal().lookAlong(target, GTMath.UNIT_Y);
+    }
+
+    /**
+     * This is in essence the same code as in gluProject, but it returns the resulting transformation matrix instead of
+     * applying it to the deprecated OpenGL transformation stack.
+     *
+     * @param worldPos world space position
+     * @apiNote the Z component of the return value is the distance from the screen.
+     */
+    public static Vector3f projectWorldToScreen(Vector3fc worldPos) {
+        Window window = Minecraft.getInstance().getWindow();
+        return projectWorldToScreen(worldPos, window.getWidth(), window.getHeight());
+    }
+
+    /**
+     * This is in essence the same code as in gluProject, but it returns the resulting transformation matrix instead of
+     * applying it to the deprecated OpenGL transformation stack.
+     *
+     * @param worldPos   world space position
+     * @param viewWidth  the viewport's width
+     * @param viewHeight the viewport's height
+     * @apiNote the Z component of the return value is the distance from the screen.
+     */
+    public static Vector3f projectWorldToScreen(Vector3fc worldPos, int viewWidth, int viewHeight) {
+        // read projection and model view matrices
+        Matrix4f transform = new Matrix4f(RenderSystem.getProjectionMatrix()).mul(RenderSystem.getModelViewMatrix());
+        Vector3f screenPos = new Vector3f(worldPos).mulPosition(transform);
+        screenPos.x = viewWidth * (screenPos.x + 1.0f) / 2.0f;
+        screenPos.y = viewHeight * (screenPos.y + 1.0f) / 2.0f;
+        screenPos.z = (screenPos.z + 1.0f) / 2.0f;
+
+        return screenPos;
+    }
+
+    /**
+     * This is in essence the same code as in gluProject, but it returns the resulting transformation matrix instead of
+     * applying it to the deprecated OpenGL transformation stack.
+     *
+     * @param x X-coordinate in pixels
+     * @param y Y-coordinate in pixels
+     * @return world pos
+     */
+    public static Vector3f projectScreenToWorld(int x, int y) {
+        Window window = Minecraft.getInstance().getWindow();
+        return projectScreenToWorld(x, y, window.getWidth(), window.getHeight(), true);
+    }
+
+    /**
+     * This is in essence the same code as in gluProject, but it returns the resulting transformation matrix instead of
+     * applying it to the deprecated OpenGL transformation stack.
+     *
+     * @param x          X-coordinate in pixels
+     * @param y          Y-coordinate in pixels
+     * @param viewWidth  the viewport's width
+     * @param viewHeight the viewport's height
+     * @param checkDepth whether to read the depth value of the targeted position
+     * @return world pos
+     */
+    public static Vector3f projectScreenToWorld(int x, int y, int viewWidth, int viewHeight, boolean checkDepth) {
+        // update the viewport size array
+        VIEWPORT_COORDS[2] = viewWidth;
+        VIEWPORT_COORDS[3] = viewHeight;
+        return projectScreenToWorld(x, y, VIEWPORT_COORDS, checkDepth);
+    }
+
+    /**
+     * This is in essence the same code as in gluProject, but it returns the resulting transformation matrixinstead of
+     * applying it to the deprecated OpenGL transformation stack.
+     *
+     * @param x          X-coordinate in pixels
+     * @param y          Y-coordinate in pixels
+     * @param viewport   the viewport described by {@code [x, y, width, height]}
+     * @param checkDepth whether to read the depth value of the targeted position
+     * @return world pos
+     */
+    public static Vector3f projectScreenToWorld(int x, int y, int[] viewport, boolean checkDepth) {
+        // read projection and model view matrices
+        Matrix4f transform = new Matrix4f(RenderSystem.getProjectionMatrix()).mul(RenderSystem.getModelViewMatrix());
+
+        float depth = 1.0f;
+        if (checkDepth) {
+            // read depth under mouse
+            RenderSystem.readPixels(x, y, 1, 1, GL11.GL_DEPTH_COMPONENT, GL11.GL_FLOAT, PIXEL_DEPTH_BUFFER);
+            PIXEL_DEPTH_BUFFER.rewind();
+            depth = PIXEL_DEPTH_BUFFER.getFloat();
+            PIXEL_DEPTH_BUFFER.rewind();
+        }
+
+        return transform.unproject(x, y, depth, viewport, new Vector3f());
+    }
 }
diff --git a/src/main/java/com/gregtechceu/gtceu/utils/GTStringUtils.java b/src/main/java/com/gregtechceu/gtceu/utils/GTStringUtils.java
index 70912110719..07263a173a8 100644
--- a/src/main/java/com/gregtechceu/gtceu/utils/GTStringUtils.java
+++ b/src/main/java/com/gregtechceu/gtceu/utils/GTStringUtils.java
@@ -7,6 +7,7 @@
 import net.minecraft.network.chat.ComponentContents;
 import net.minecraft.network.chat.MutableComponent;
 import net.minecraft.resources.ResourceLocation;
+import net.minecraft.util.FormattedCharSequence;
 import net.minecraft.world.item.ItemStack;
 import net.minecraftforge.fluids.FluidStack;
 
@@ -15,6 +16,7 @@
 
 import java.util.ArrayList;
 import java.util.List;
+import java.util.Map;
 import java.util.Objects;
 
 public class GTStringUtils {
@@ -57,82 +59,6 @@ public static String getIntOrderingSuffix(int x) {
         return x + "th";
     }
 
-    /**
-     * Returns a string with the result of the provided expression.
-     * This function is intended for use with user input.
-     * For example:
-     * <ul>
-     * <li>{@code {"12", "+", "34"}} -> {@code "46"}</li>
-     * <li>{@code {"sqrt", "16"}} -> {@code "4"}</li>
-     * <li>{@code {"round", "4.5"}} -> {@code "5"}</li>
-     * <li>{@code {"literally any string"}} -> {@code "literally any string"}</li>
-     * <li>{@code {"~", "0"}} -> {@code "-1"} // signed bitwise inversion</li>
-     * </ul>
-     * Currently the operations are: {@code {"+", "-", "*", "/", "%", ">>", "<<", "~", "round", "ceil", "floor",
-     * "sqrt"}}
-     * 
-     * @param args the arguments, including operands and operation to calculate
-     * @return the result of the calculation, {@code "Invalid number!"} or {@code "Invalid expression!"}
-     */
-    @NotNull
-    public static String calc(@NotNull List<String> args) {
-        // yes I know this is terrible code, but I want to be able to do math in placeholders
-        // not going to do anything crazy like including lua or python here
-        if (args.size() == 3) {
-            try {
-                long a = Long.parseLong(args.get(0));
-                long b = Long.parseLong(args.get(2));
-                return switch (args.get(1)) {
-                    case "+" -> String.valueOf(a + b);
-                    case "-" -> String.valueOf(a - b);
-                    case "*" -> String.valueOf(a * b);
-                    case "/" -> String.valueOf(a / b);
-                    case "%" -> String.valueOf(a % b);
-                    case "<<" -> String.valueOf(a << b);
-                    case ">>" -> String.valueOf(a >> b);
-                    default -> "No such operation: '%s'".formatted(args.get(1));
-                };
-            } catch (NumberFormatException e) {
-                try {
-                    double a = Double.parseDouble(args.get(0));
-                    double b = Double.parseDouble(args.get(2));
-                    return switch (args.get(1)) {
-                        case "/" -> String.valueOf(a / b);
-                        case "+" -> String.valueOf(a + b);
-                        case "-" -> String.valueOf(a - b);
-                        case "*" -> String.valueOf(a * b);
-                        default -> "Invalid number: '%s' or operation '%s'".formatted(e.getMessage(), args.get(1));
-                    };
-                } catch (NumberFormatException ex) {
-                    return "Invalid number '%s'!".formatted(ex.getMessage());
-                }
-            }
-        } else if (args.size() == 2) {
-            try {
-                long a = Long.parseLong(args.get(1));
-                return switch (args.get(0)) {
-                    case "~" -> String.valueOf(~a);
-                    case "sqrt" -> String.valueOf(Math.sqrt(a));
-                    default -> "No such operation: '%s'".formatted(args.get(0));
-                };
-            } catch (NumberFormatException e) {
-                try {
-                    double a = Double.parseDouble(args.get(1));
-                    return switch (args.get(0)) {
-                        case "round" -> String.valueOf(Math.round(a));
-                        case "ceil" -> String.valueOf(Math.ceil(a));
-                        case "floor" -> String.valueOf(Math.floor(a));
-                        case "sqrt" -> String.valueOf(Math.sqrt(a));
-                        default -> "Invalid number '%s' or operation '%s'!".formatted(e.getMessage(), args.get(0));
-                    };
-                } catch (NumberFormatException e2) {
-                    return "Invalid number '%s'!".formatted(e2.getMessage());
-                }
-            }
-        } else if (args.size() == 1) return args.get(0);
-        return "Invalid expression!";
-    }
-
     public static List<MutableComponent> literalLine(String s) {
         return new ArrayList<>(List.of(Component.literal(s)));
     }
@@ -222,4 +148,35 @@ public static Component toComponent(ListTag arr) {
         component.append("]");
         return component;
     }
+
+    public static Component toComponent(List<Component> components) {
+        MutableComponent component = Component.empty();
+        for (Component comp : components) {
+            component.append(comp).append("\n");
+        }
+        return component;
+    }
+
+    public static String formatInt(long n) {
+        Map<Long, String> suffixes = Map.of(
+                1L, "",
+                1000L, "K",
+                1000000L, "M",
+                1000000000L, "B",
+                1000000000000L, "T");
+        long max = 1;
+        for (Long i : suffixes.keySet()) {
+            if (n >= i && max < i) max = i;
+        }
+        return "%.2f%s".formatted(((double) n) / max, suffixes.get(max));
+    }
+
+    public static MutableComponent toComponent(FormattedCharSequence charSequence) {
+        MutableComponent component = MutableComponent.create(ComponentContents.EMPTY);
+        charSequence.accept((pos, style, codePoint) -> {
+            component.append(Component.literal(Character.toString(codePoint)).withStyle(style));
+            return true;
+        });
+        return component;
+    }
 }
diff --git a/src/main/java/com/gregtechceu/gtceu/utils/GTUtil.java b/src/main/java/com/gregtechceu/gtceu/utils/GTUtil.java
index f43ee33f385..c9b0d38ef2c 100644
--- a/src/main/java/com/gregtechceu/gtceu/utils/GTUtil.java
+++ b/src/main/java/com/gregtechceu/gtceu/utils/GTUtil.java
@@ -6,7 +6,10 @@
 import com.gregtechceu.gtceu.api.data.chemical.material.properties.PropertyKey;
 import com.gregtechceu.gtceu.api.data.tag.TagPrefix;
 import com.gregtechceu.gtceu.api.fluids.store.FluidStorageKeys;
+import com.gregtechceu.gtceu.api.item.IComponentItem;
+import com.gregtechceu.gtceu.api.item.component.IItemComponent;
 import com.gregtechceu.gtceu.api.item.tool.GTToolType;
+import com.gregtechceu.gtceu.common.item.TieredBehaviour;
 import com.gregtechceu.gtceu.config.ConfigHolder;
 import com.gregtechceu.gtceu.data.recipe.CustomTags;
 
@@ -33,6 +36,7 @@
 import net.minecraft.world.item.DyeColor;
 import net.minecraft.world.item.Item;
 import net.minecraft.world.item.ItemStack;
+import net.minecraft.world.level.ItemLike;
 import net.minecraft.world.level.Level;
 import net.minecraft.world.level.biome.Biome;
 import net.minecraft.world.level.block.Block;
@@ -41,6 +45,9 @@
 import net.minecraft.world.level.block.state.BlockState;
 import net.minecraft.world.level.material.Fluid;
 import net.minecraft.world.level.material.MapColor;
+import net.minecraft.world.phys.AABB;
+import net.minecraft.world.phys.shapes.Shapes;
+import net.minecraft.world.phys.shapes.VoxelShape;
 import net.minecraftforge.client.extensions.common.IClientFluidTypeExtensions;
 import net.minecraftforge.common.ForgeHooks;
 import net.minecraftforge.common.Tags;
@@ -55,6 +62,7 @@
 import org.apache.commons.lang3.ArrayUtils;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
+import org.joml.Vector3f;
 import org.lwjgl.glfw.GLFW;
 
 import java.lang.reflect.ParameterizedType;
@@ -192,7 +200,7 @@ public static float getExplosionPower(long voltage) {
      * @return Index of the nearest value lesser or equal than {@code value},
      *         or {@code -1} if there's no entry matching the condition
      */
-    public static int nearestLesserOrEqual(@NotNull long[] array, long value) {
+    public static int nearestLesserOrEqual(long @NotNull [] array, long value) {
         int low = 0, high = array.length - 1;
         while (true) {
             int median = (low + high) / 2;
@@ -212,7 +220,7 @@ public static int nearestLesserOrEqual(@NotNull long[] array, long value) {
      * @return Index of the nearest value lesser than {@code value},
      *         or {@code -1} if there's no entry matching the condition
      */
-    public static int nearestLesser(@NotNull long[] array, long value) {
+    public static int nearestLesser(long @NotNull [] array, long value) {
         int low = 0, high = array.length - 1;
         while (true) {
             int median = (low + high) / 2;
@@ -692,4 +700,76 @@ public static void setOnFire(Level level, BlockPos pos, double additionalFireCha
             }
         }
     }
+
+    public static AABB rotateAABB(AABB AABB, Direction facing) {
+        switch (facing) {
+            case SOUTH -> {
+                return rotateAABB(AABB, new Vector3f(0, 1, 0), 180);
+            }
+            case EAST -> {
+                return rotateAABB(AABB, new Vector3f(0, 1, 0), -90);
+            }
+            case WEST -> {
+                return rotateAABB(AABB, new Vector3f(0, 1, 0), 90);
+            }
+            case UP -> {
+                return rotateAABB(AABB, new Vector3f(1, 0, 0), 90);
+            }
+            case DOWN -> {
+                return rotateAABB(AABB, new Vector3f(1, 0, 0), -90);
+            }
+        }
+        return AABB;
+    }
+
+    public static AABB rotateAABB(AABB AABB, Vector3f axis, double degree) {
+        Vector3f min = new Vector3f((float) AABB.minX, (float) AABB.minY, (float) AABB.minZ).sub(0.5f, 0.5f, 0.5f);
+        Vector3f max = new Vector3f((float) AABB.minX, (float) AABB.minY, (float) AABB.minZ).sub(0.5f, 0.5f, 0.5f);
+        float radians = (float) Math.toRadians(degree);
+        min.rotateAxis(radians, axis.x, axis.y, axis.z);
+        max.rotateAxis(radians, axis.x, axis.y, axis.z);
+        min.add(0.5f, 0.5f, 0.5f);
+        max.add(0.5f, 0.5f, 0.5f);
+        return new AABB(min.x, min.y, min.z, max.x, max.y, max.z);
+    }
+
+    public static VoxelShape rotateVoxelShape(VoxelShape shape, Vector3f axis, double degree) {
+        return shape.toAabbs().stream().map(AABB -> Shapes.create(rotateAABB(AABB, axis, degree)))
+                .reduce(Shapes.empty(), Shapes::or);
+    }
+
+    public static VoxelShape rotateVoxelShape(VoxelShape shape, Direction dir) {
+        return shape.toAabbs().stream().map(AABB -> Shapes.create(rotateAABB(AABB, dir))).reduce(Shapes.empty(),
+                Shapes::or);
+    }
+
+    public static boolean resourceExists(@NotNull ResourceLocation rs) {
+        if (GTCEu.isClientSide()) {
+            return Minecraft.getInstance().getResourceManager().getResource(rs).isPresent();
+        } else {
+            return false;
+        }
+    }
+
+    public static boolean textureResourceExists(@NotNull ResourceLocation location) {
+        var textureLocation = new ResourceLocation(location.getNamespace(),
+                "textures/%s.png".formatted(location.getPath()));
+        return resourceExists(textureLocation);
+    }
+
+    public static boolean modelResourceExists(@NotNull ResourceLocation location) {
+        var modelLocation = new ResourceLocation(location.getNamespace(),
+                "models/%s.json".formatted(location.getPath()));
+        return resourceExists(modelLocation);
+    }
+
+    public static int getTier(ItemLike itemLike) {
+        Item item = itemLike.asItem();
+        if (item instanceof IComponentItem componentItem) {
+            for (IItemComponent component : componentItem.getComponents()) {
+                if (component instanceof TieredBehaviour tieredBehaviour) return tieredBehaviour.tier();
+            }
+        }
+        return -1;
+    }
 }
diff --git a/src/main/java/com/gregtechceu/gtceu/utils/TagExprFilter.java b/src/main/java/com/gregtechceu/gtceu/utils/TagExprFilter.java
index 8897801b1e6..e17b1183762 100644
--- a/src/main/java/com/gregtechceu/gtceu/utils/TagExprFilter.java
+++ b/src/main/java/com/gregtechceu/gtceu/utils/TagExprFilter.java
@@ -13,6 +13,13 @@
 
 public class TagExprFilter {
 
+    private static final Pattern DOUBLE_WILDCARD = Pattern.compile("\\*{2,}");
+    private static final Pattern DOUBLE_AND = Pattern.compile("&{2,}");
+    private static final Pattern DOUBLE_OR = Pattern.compile("\\|{2,}");
+    private static final Pattern DOUBLE_NOT = Pattern.compile("!{2,}");
+    private static final Pattern DOUBLE_XOR = Pattern.compile("\\^{2,}");
+    private static final Pattern DOUBLE_SPACE = Pattern.compile(" {2,}");
+
     public static class TagExprParser {
 
         public enum TokenType {
@@ -292,4 +299,59 @@ public static boolean tagsMatch(TagExprParser.MatchExpr expr, FluidStack stack)
 
         return expr != null && expr.matches(tags);
     }
+
+    public static String tagInputValidator(String input) {
+        // remove all operators that are double
+        input = DOUBLE_WILDCARD.matcher(input).replaceAll("*");
+        input = DOUBLE_AND.matcher(input).replaceAll("&");
+        input = DOUBLE_OR.matcher(input).replaceAll("|");
+        input = DOUBLE_NOT.matcher(input).replaceAll("!");
+        input = DOUBLE_XOR.matcher(input).replaceAll("^");
+        input = DOUBLE_SPACE.matcher(input).replaceAll(" ");
+        // move ( and ) so it doesn't create invalid expressions f.e. xxx (& yyy) => xxx & (yyy)
+        // append or prepend ( and ) if the amount is not equal
+        StringBuilder builder = new StringBuilder();
+        int unclosed = 0;
+        char last = ' ';
+        for (int i = 0; i < input.length(); i++) {
+            char c = input.charAt(i);
+            if (c == ' ') {
+                if (last != '(')
+                    builder.append(" ");
+                continue;
+            }
+            if (c == '(')
+                unclosed++;
+            else if (c == ')') {
+                unclosed--;
+                if (last == '&' || last == '|' || last == '^') {
+                    int l = builder.lastIndexOf(" " + last);
+                    int l2 = builder.lastIndexOf(String.valueOf(last));
+                    builder.insert(l == l2 - 1 ? l : l2, ")");
+                    continue;
+                }
+                if (i > 0 && builder.charAt(builder.length() - 1) == ' ') {
+                    builder.deleteCharAt(builder.length() - 1);
+                }
+            } else if ((c == '&' || c == '|' || c == '^') && last == '(') {
+                builder.deleteCharAt(builder.lastIndexOf("("));
+                builder.append(c).append(" (");
+                continue;
+            }
+
+            builder.append(c);
+            last = c;
+        }
+        if (unclosed > 0) {
+            builder.append(")".repeat(unclosed));
+        } else if (unclosed < 0) {
+            unclosed = -unclosed;
+            for (int i = 0; i < unclosed; i++) {
+                builder.insert(0, "(");
+            }
+        }
+        input = builder.toString();
+        input = input.replaceAll(" {2,}", " ");
+        return input;
+    }
 }
diff --git a/src/main/java/com/gregtechceu/gtceu/utils/data/NBTToJsonConverter.java b/src/main/java/com/gregtechceu/gtceu/utils/data/NBTToJsonConverter.java
new file mode 100644
index 00000000000..43c33ded0da
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/utils/data/NBTToJsonConverter.java
@@ -0,0 +1,58 @@
+package com.gregtechceu.gtceu.utils.data;
+
+import net.minecraft.nbt.*;
+
+import com.google.gson.*;
+
+import java.util.Set;
+
+public class NBTToJsonConverter {
+
+    public static JsonElement getObject(Tag tag) {
+        JsonElement jsonRoot;
+        if (tag instanceof CompoundTag compoundTag) {
+            Set<String> keys = compoundTag.getAllKeys();
+            jsonRoot = new JsonObject();
+            for (String key : keys) {
+                Tag nbt = compoundTag.get(key);
+                ((JsonObject) jsonRoot).add(key, getObject(nbt));
+            }
+        } else if (tag instanceof NumericTag numericTag) {
+            jsonRoot = new JsonPrimitive(numericTag.getAsNumber());
+        } else if (tag instanceof StringTag) {
+            jsonRoot = new JsonPrimitive(tag.getAsString());
+        } else {
+            JsonArray array;
+            if (tag instanceof ListTag tagList) {
+                array = new JsonArray();
+                for (Tag value : tagList) {
+                    array.add(getObject(value));
+                }
+                jsonRoot = array;
+            } else if (tag instanceof IntArrayTag intArray) {
+                array = new JsonArray();
+                for (int i : intArray.getAsIntArray()) {
+                    array.add(new JsonPrimitive(i));
+                }
+                jsonRoot = array;
+            } else if (tag instanceof ByteArrayTag intArray) {
+                array = new JsonArray();
+                for (byte i : intArray.getAsByteArray()) {
+                    array.add(new JsonPrimitive(i));
+                }
+                jsonRoot = array;
+            } else if (tag instanceof LongArrayTag intArray) {
+                array = new JsonArray();
+                for (long i : intArray.getAsLongArray()) {
+                    array.add(new JsonPrimitive(i));
+                }
+                jsonRoot = array;
+            } else {
+                throw new JsonParseException(
+                        "NBT to JSON converter doesn't support the nbt tag: " + tag.getType() + ", tag: " + tag);
+            }
+        }
+
+        return jsonRoot;
+    }
+}
diff --git a/src/main/java/com/gregtechceu/gtceu/utils/input/SyncedKeyMappings.java b/src/main/java/com/gregtechceu/gtceu/utils/input/SyncedKeyMappings.java
index f59598a7104..1f268d6b57e 100644
--- a/src/main/java/com/gregtechceu/gtceu/utils/input/SyncedKeyMappings.java
+++ b/src/main/java/com/gregtechceu/gtceu/utils/input/SyncedKeyMappings.java
@@ -1,12 +1,15 @@
 package com.gregtechceu.gtceu.utils.input;
 
 import com.gregtechceu.gtceu.GTCEu;
+import com.gregtechceu.gtceu.api.mui.factory.ModularItemUIFactory;
 
 import net.minecraft.client.Minecraft;
 import net.minecraftforge.client.settings.KeyConflictContext;
 import net.minecraftforge.common.MinecraftForge;
 import net.minecraftforge.fml.ModLoader;
 
+import brachy.modularui.factory.GuiData;
+import brachy.modularui.factory.GuiManager;
 import com.mojang.blaze3d.platform.InputConstants;
 
 public final class SyncedKeyMappings {
@@ -41,6 +44,12 @@ public final class SyncedKeyMappings {
     public static final SyncedKeyMapping STEP_ASSIST_ENABLE = SyncedKeyMapping.createConfigurable(
             "gtceu.key.enable_step_assist", KeyConflictContext.IN_GAME,
             InputConstants.KEY_APOSTROPHE);
+    public static final SyncedKeyMapping MODULAR_ITEM_GUI = SyncedKeyMapping.createConfigurable(
+            "gtceu.key.modular_item_gui", KeyConflictContext.IN_GAME,
+            InputConstants.KEY_V).registerGlobalListener((player, key, isDown) -> {
+                if (isDown)
+                    GuiManager.open(ModularItemUIFactory.INSTANCE, new GuiData(player), player);
+            });
 
     public static void init() {
         if (GTCEu.isClientSide()) {
diff --git a/src/main/java/com/gregtechceu/gtceu/utils/math/ParseResult.java b/src/main/java/com/gregtechceu/gtceu/utils/math/ParseResult.java
new file mode 100644
index 00000000000..0ea2581c4d0
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/utils/math/ParseResult.java
@@ -0,0 +1,51 @@
+package com.gregtechceu.gtceu.utils.math;
+
+import com.ezylang.evalex.BaseException;
+import com.ezylang.evalex.data.EvaluationValue;
+import lombok.Getter;
+import org.jetbrains.annotations.NotNull;
+
+public class ParseResult {
+
+    @Getter
+    private final EvaluationValue result;
+    @Getter
+    private final BaseException error;
+
+    public static ParseResult success(EvaluationValue result) {
+        return new ParseResult(result, null);
+    }
+
+    public static ParseResult failure(@NotNull BaseException error) {
+        return failure(null, error);
+    }
+
+    public static ParseResult failure(EvaluationValue value, @NotNull BaseException error) {
+        return new ParseResult(value, error);
+    }
+
+    private ParseResult(EvaluationValue result, BaseException error) {
+        this.result = result;
+        this.error = error;
+    }
+
+    public boolean isSuccess() {
+        return this.error == null;
+    }
+
+    public boolean isFailure() {
+        return this.error != null;
+    }
+
+    public boolean hasValue() {
+        return this.result != null;
+    }
+
+    public String getErrorMessage() {
+        return isFailure() ?
+                String.format("%s for Token %s at %d:%d",
+                        this.error.getMessage(), this.error.getTokenString(),
+                        this.error.getStartPosition(), this.error.getEndPosition()) :
+                null;
+    }
+}
diff --git a/src/main/java/com/gregtechceu/gtceu/utils/math/PostfixPercentOperator.java b/src/main/java/com/gregtechceu/gtceu/utils/math/PostfixPercentOperator.java
new file mode 100644
index 00000000000..14da7a72b33
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/utils/math/PostfixPercentOperator.java
@@ -0,0 +1,30 @@
+package com.gregtechceu.gtceu.utils.math;
+
+import com.ezylang.evalex.EvaluationException;
+import com.ezylang.evalex.Expression;
+import com.ezylang.evalex.data.EvaluationValue;
+import com.ezylang.evalex.operators.AbstractOperator;
+import com.ezylang.evalex.operators.OperatorIfc;
+import com.ezylang.evalex.operators.PostfixOperator;
+import com.ezylang.evalex.parser.Token;
+
+import java.math.BigDecimal;
+
+@PostfixOperator(precedence = OperatorIfc.OPERATOR_PRECEDENCE_MULTIPLICATIVE - 1)
+public class PostfixPercentOperator extends AbstractOperator {
+
+    public static final BigDecimal HUNDRED = new BigDecimal(100);
+
+    @Override
+    public EvaluationValue evaluate(Expression expression, Token operatorToken,
+                                    EvaluationValue... operands) throws EvaluationException {
+        EvaluationValue operand = operands[0];
+
+        if (operand.isNumberValue()) {
+            return expression.convertValue(
+                    operand.getNumberValue().divide(HUNDRED, expression.getConfiguration().getMathContext()));
+        } else {
+            throw EvaluationException.ofUnsupportedDataTypeInOperation(operatorToken);
+        }
+    }
+}
diff --git a/src/main/java/com/gregtechceu/gtceu/utils/math/SIPrefix.java b/src/main/java/com/gregtechceu/gtceu/utils/math/SIPrefix.java
new file mode 100644
index 00000000000..6e630a51e54
--- /dev/null
+++ b/src/main/java/com/gregtechceu/gtceu/utils/math/SIPrefix.java
@@ -0,0 +1,90 @@
+package com.gregtechceu.gtceu.utils.math;
+
+import com.ezylang.evalex.Expression;
+
+import java.math.BigDecimal;
+
+public enum SIPrefix {
+
+    Infinite('∞', Double.MAX_VALUE, true),
+    Quetta('Q', 30),
+    Ronna('R', 27),
+    Yotta('Y', 24),
+    Zetta('Z', 21),
+    Exa('X', 18), // this should actually be E, but this clashes with euler's number e = 2.71...
+    Peta('P', 15),
+    Tera('T', 12),
+    Giga('G', 9),
+    Mega('M', 6),
+    Kilo('k', 3),
+    One(),
+    Milli('m', -3),
+    Micro('µ', -6),
+    Nano('n', -9),
+    Pico('p', -12),
+    Femto('f', -15),
+    Atto('a', -18),
+    Zepto('z', -21),
+    Yocto('y', -24),
+    Ronto('r', -27),
+    Quecto('q', -30),
+    Infinitesimal('∞', Double.MIN_NORMAL, true);
+
+    public final char symbol;
+    public final String stringSymbol;
+    public final double factor;
+    public final double oneOverFactor;
+    public final BigDecimal bigFactor;
+    public final BigDecimal bigOneOverFactor;
+    public final boolean infiniteLike;
+
+    SIPrefix() {
+        this.symbol = Character.MIN_VALUE;
+        this.stringSymbol = "";
+        this.factor = 1.0;
+        this.oneOverFactor = 1.0;
+        this.bigFactor = BigDecimal.ONE;
+        this.bigOneOverFactor = BigDecimal.ONE;
+        this.infiniteLike = false;
+    }
+
+    SIPrefix(char symbol, double f, boolean inf) {
+        this.symbol = symbol;
+        this.stringSymbol = Character.toString(symbol);
+        this.factor = f;
+        this.oneOverFactor = 1 / f;
+        this.bigFactor = new BigDecimal(f);
+        this.bigOneOverFactor = new BigDecimal(this.oneOverFactor);
+        this.infiniteLike = inf;
+    }
+
+    SIPrefix(char symbol, int powerOfTen) {
+        this(symbol, Math.pow(10, powerOfTen), false);
+    }
+
+    public boolean isOne() {
+        return this == One;
+    }
+
+    public void addToExpression(Expression e) {
+        e.with(String.valueOf(this.symbol), this.factor);
+    }
+
+    public static final SIPrefix[] VALUES = values();
+    public static final SIPrefix[] HIGH = new SIPrefix[values().length / 2];
+    public static final SIPrefix[] LOW = new SIPrefix[values().length / 2];
+
+    static {
+        SIPrefix[] values = values();
+        for (int i = 0; i < HIGH.length; i++) {
+            HIGH[i] = values[HIGH.length - 1 - i];
+            LOW[i] = values[HIGH.length + 1 + i];
+        }
+    }
+
+    public static void addAllToExpression(Expression e) {
+        for (SIPrefix siPrefix : VALUES) {
+            siPrefix.addToExpression(e);
+        }
+    }
+}
diff --git a/src/main/java/com/gregtechceu/gtceu/utils/memoization/GTMemoizer.java b/src/main/java/com/gregtechceu/gtceu/utils/memoization/GTMemoizer.java
index 36728327d77..5dc365689c3 100644
--- a/src/main/java/com/gregtechceu/gtceu/utils/memoization/GTMemoizer.java
+++ b/src/main/java/com/gregtechceu/gtceu/utils/memoization/GTMemoizer.java
@@ -6,11 +6,13 @@
 
 import net.minecraft.world.level.block.Block;
 
+import com.google.common.base.Suppliers;
 import lombok.Getter;
 import org.apache.commons.lang3.function.TriFunction;
 import org.apache.commons.lang3.tuple.Pair;
 import org.apache.commons.lang3.tuple.Triple;
 
+import java.time.Duration;
 import java.util.Map;
 import java.util.concurrent.ConcurrentHashMap;
 import java.util.function.BiFunction;
@@ -30,6 +32,40 @@ public static <T> MemoizedSupplier<T> memoize(Supplier<T> delegate) {
         return new MemoizedSupplier<>(delegate);
     }
 
+    /**
+     * Store a supplier in a delegate function to be computed once, and only again after time to live has expired.
+     * <p>
+     * If you need thread safety, you should use
+     * {@link Suppliers#memoize(com.google.common.base.Supplier) Suppliers#memoize} instead.
+     * </p>
+     *
+     * @param <T>        The type of object supplied
+     * @param delegate   The supplier to memoize
+     * @param timeToLive Time to retain calculation. If negative, retain indefinitely.
+     * @see #memoize(Supplier)
+     * @see Suppliers#memoize(com.google.common.base.Supplier)
+     */
+    public static <T> MemoizedSupplier<T> memoize(Supplier<T> delegate, Duration timeToLive) {
+        return memoize(delegate, timeToLive.toNanos());
+    }
+
+    /**
+     * Store a supplier in a delegate function to be computed once, and only again after time to live has expired.
+     * <p>
+     * If you need thread safety, you should use
+     * {@link Suppliers#memoize(com.google.common.base.Supplier) Suppliers#memoize} instead.
+     * </p>
+     *
+     * @param <T>        The type of object supplied
+     * @param delegate   The supplier to memoize
+     * @param timeToLive Time in nanoseconds to retain calculation. If negative, retain indefinitely.
+     * @see #memoize(Supplier)
+     * @see Suppliers#memoize(com.google.common.base.Supplier)
+     */
+    public static <T> MemoizedSupplier<T> memoize(Supplier<T> delegate, long timeToLive) {
+        return new MemoizedSupplier<>(delegate, timeToLive);
+    }
+
     public static <T extends Block> MemoizedBlockSupplier<T> memoizeBlockSupplier(Supplier<T> delegate) {
         return new MemoizedBlockSupplier<>(delegate);
     }
diff --git a/src/main/java/com/gregtechceu/gtceu/utils/memoization/MemoizedSupplier.java b/src/main/java/com/gregtechceu/gtceu/utils/memoization/MemoizedSupplier.java
index 065d68ed01b..d4d35e143fe 100644
--- a/src/main/java/com/gregtechceu/gtceu/utils/memoization/MemoizedSupplier.java
+++ b/src/main/java/com/gregtechceu/gtceu/utils/memoization/MemoizedSupplier.java
@@ -8,12 +8,28 @@ public class MemoizedSupplier<T> implements Supplier<T> {
     protected boolean initialized = false;
     protected final Supplier<T> delegate;
 
+    protected long timeToLiveNanos = -1;
+    private volatile long lastAccessNanos;
+
     protected MemoizedSupplier(Supplier<T> delegate) {
         this.delegate = delegate;
     }
 
+    protected MemoizedSupplier(Supplier<T> delegate, long timeToLiveNanos) {
+        this.delegate = delegate;
+        this.timeToLiveNanos = timeToLiveNanos;
+    }
+
     @Override
     public T get() {
+        if (timeToLiveNanos != -1) {
+            long now = System.nanoTime();
+            if (lastAccessNanos == 0 || (timeToLiveNanos >= 0 && now - lastAccessNanos >= timeToLiveNanos)) {
+                value = delegate.get();
+            }
+            lastAccessNanos = now;
+            return value;
+        }
         if (!initialized) {
             value = delegate.get();
             initialized = true;
@@ -22,12 +38,14 @@ public T get() {
     }
 
     public void invalidate() {
+        lastAccessNanos = 0;
         initialized = false;
         value = null;
     }
 
     @Override
     public String toString() {
-        return getClass().getSimpleName() + "(" + (initialized ? value : "Uninitialized") + ")";
+        return getClass().getSimpleName() + "(" + ((initialized || lastAccessNanos != 0) ? value : "Uninitialized") +
+                ")";
     }
 }
diff --git a/src/main/resources/assets/gtceu/font/include/mono_space.json b/src/main/resources/assets/gtceu/font/include/mono_space.json
new file mode 100644
index 00000000000..b155b49d77e
--- /dev/null
+++ b/src/main/resources/assets/gtceu/font/include/mono_space.json
@@ -0,0 +1,11 @@
+{
+  "providers": [
+    {
+      "type": "space",
+      "advances": {
+        " ": 6,
+        "\u200c": 0
+      }
+    }
+  ]
+}
diff --git a/src/main/resources/assets/gtceu/font/include/monocraft.json b/src/main/resources/assets/gtceu/font/include/monocraft.json
new file mode 100644
index 00000000000..415a3246722
--- /dev/null
+++ b/src/main/resources/assets/gtceu/font/include/monocraft.json
@@ -0,0 +1,101 @@
+{
+    "providers": [
+        {
+            "type": "bitmap",
+            "file": "gtceu:font/nonlatin_european_mono.png",
+            "ascent": 7,
+            "chars": [
+                "\u00a1\u2030\u00ad\u00b7\u20b4\u2260\u00bf\u00d7\u00d8\u00de\u04bb\u00f0\u00f8\u00fe\u0391\u0392",
+                "\u0393\u0394\u0395\u0396\u0397\u0398\u0399\u039a\u039b\u039c\u039d\u039e\u039f\u03a0\u03a1\u03a3",
+                "\u03a4\u03a5\u03a6\u03a7\u03a8\u03a9\u03b1\u03b2\u03b3\u03b4\u03b5\u03b6\u03b7\u03b8\u03b9\u03ba",
+                "\u03bb\u03bc\u03bd\u03be\u03bf\u03c0\u03c1\u03c2\u03c3\u03c4\u03c5\u03c6\u03c7\u03c8\u03c9\u0402",
+                "\u0405\u0406\u0408\u0409\u040a\u040b\u0410\u0411\u0412\u0413\u0414\u0415\u0416\u0417\u0418\u041a",
+                "\u041b\u041c\u041d\u041e\u041f\u0420\u0421\u0422\u0423\u0424\u0425\u0426\u0427\u0428\u0429\u042a",
+                "\u042b\u042c\u042d\u042e\u042f\u0430\u0431\u0432\u0433\u0434\u0435\u0436\u0437\u0438\u043a\u043b",
+                "\u043c\u043d\u043e\u043f\u0440\u0441\u0442\u0443\u0444\u0445\u0446\u0447\u0448\u0449\u044a\u044b",
+                "\u044c\u044d\u044e\u044f\u0454\u0455\u0456\u0458\u0459\u045a\u2013\u2014\u2018\u2019\u201c\u201d",
+                "\u201e\u2026\u204a\u2190\u2191\u2192\u2193\u21c4\uff0b\u018f\u0259\u025b\u026a\u04ae\u04af\u04e8",
+                "\u04e9\u02bb\u02cc\u037e\u0138\u1e9e\u00df\u20bd\u20ac\u0462\u0463\u0474\u0475\u04c0\u0472\u0473",
+                "\u2070\u00b9\u00b3\u2074\u2075\u2076\u2077\u2078\u2079\u207a\u207b\u207c\u207d\u207e\u2071\u2122",
+                "\u0294\u0295\u29c8\u2694\u2620\u049a\u049b\u0492\u0493\u04b0\u04b1\u04d8\u04d9\u0496\u0497\u04a2",
+                "\u04a3\u04ba\u05d0\u05d1\u05d2\u05d3\u05d4\u05d5\u05d6\u05d7\u05d8\u05d9\u05db\u05dc\u05de\u05dd",
+                "\u05e0\u05df\u05e1\u05e2\u05e4\u05e3\u05e6\u05e5\u05e7\u05e8\u00a2\u00a4\u00a5\u00a9\u00ae\u00b5",
+                "\u00b6\u00bc\u00bd\u00be\u0387\u2010\u201a\u2020\u2021\u2022\u2031\u2032\u2033\u2034\u2035\u2036",
+                "\u2037\u2039\u203a\u203b\u203c\u203d\u2042\u2048\u2049\u204b\u204e\u204f\u2051\u2052\u2057\u2117",
+                "\u2212\u2213\u221e\u2600\u2601\u2608\u0404\u2632\u2635\u263d\u2640\u2642\u26a5\u2660\u2663\u2665",
+                "\u2666\u2669\u266a\u266b\u266c\u266d\u266e\u266f\u2680\u2681\u2682\u2683\u2684\u2685\u02ac\u26a1",
+                "\u26cf\u2714\u2744\u274c\u2764\u2b50\u2e18\u2e2e\u2e35\u2e38\u2e41\u2e4b\u295d\u1614\u0190\u07c8",
+                "\u03db\u3125\u2c6f\u15fa\u0186\u15e1\u018e\u2132\u2141\ua7b0\ua780\u0500\ua779\u1d1a\u27d8\u2229",
+                "\u0245\u2144\u0250\u0254\u01dd\u025f\u1d77\u0265\u1d09\u027e\u029e\ua781\u026f\u0279\u0287\u028c",
+                "\u028d\u028e\u0531\u0532\u0533\u0534\u0536\u0537\u0539\u053a\u053b\u053c\u053d\u053e\u053f\u0540",
+                "\u0541\u0542\u0543\u0544\u0545\u0546\u0547\u0548\u0549\u054b\u054c\u054d\u054e\u054f\u0550\u0551",
+                "\u0552\u0553\u0554\u0555\u0556\u0559\u0561\u0562\u0563\u0564\u0565\u0566\u0567\u0568\u0569\u056a",
+                "\u056b\u056c\u056d\u056e\u056f\u0570\u0571\u0572\u0573\u0574\u0575\u0576\u0577\u0578\u0579\u057a",
+                "\u057b\u057c\u057d\u057e\u057f\u0580\u0581\u0582\u0583\u0584\u0585\u0586\u0587\u05e9\u05ea\u0538",
+                "\u055a\u055b\u055c\u055d\u055e\u055f\u0560\u0588\u058f\u00af\u017f\u01b7\u0292\u01f7\u01bf\u021c",
+                "\u021d\u0224\u0225\u02d9\ua75a\ua75b\u2011\u214b\u23cf\u23e9\u23ea\u23ed\u23ee\u23ef\u23f4\u23f5",
+                "\u23f6\u23f7\u23f8\u23f9\u23fa\u23fb\u23fc\u23fd\u2b58\u25b2\u25b6\u25bc\u25c0\u25cf\u25e6\u25d8",
+                "\u2693\u26e8\u0132\u0133\u01c9\ua728\ua729\ua739\ua73b\ufb00\ufb01\ufb02\ufb03\ufb05\ufffd\u0535",
+                "\u054a\u16a0\u16a2\u16a3\u16a4\u16a5\u16a6\u16a7\u16a8\u16a9\u16aa\u16ab\u16ac\u16ad\u16ae\u16af",
+                "\u16b0\u16b1\u16b2\u16b3\u16b4\u16b6\u16b7\u16b8\u16b9\u16ba\u16bb\u16bc\u16bd\u16be\u16bf\u16c0",
+                "\u16c1\u16c2\u16c3\u16c4\u16c5\u16c6\u16c7\u16c8\u16c9\u16ca\u16cb\u16cc\u16cd\u16ce\u16cf\u16d0",
+                "\u16d1\u16d2\u16d3\u16d4\u16d5\u16d6\u16d7\u16d8\u16d9\u16da\u16db\u16dc\u16dd\u16de\u16df\u16e0",
+                "\u16e1\u16e2\u16e3\u16e4\u16e5\u16e6\u16e7\u16e8\u16e9\u16ea\u16eb\u16ec\u16ed\u16ee\u16ef\u16f0",
+                "\u16f1\u16f2\u16f3\u16f4\u16f5\u16f6\u16f7\u16f8\u263a\u263b\u00a6\u2639\u05da\u05f3\u05f4\u05f0",
+                "\u05f1\u05f2\u05be\u05c3\u05c6\u00b4\u00a8\u1d00\u0299\u1d04\u1d05\u1d07\ua730\u0262\u029c\u1d0a",
+                "\u1d0b\u029f\u1d0d\u0274\u1d0f\u1d18\ua7af\u0280\ua731\u1d1b\u1d1c\u1d20\u1d21\u028f\u1d22\u00a7",
+                "\u0271\u0273\u0272\u0288\u0256\u0261\u02a1\u0255\u0291\u0278\u029d\u02a2\u027b\u0281\u0266\u028b",
+                "\u0270\u026c\u026e\u0298\u01c0\u01c3\u01c2\u01c1\u0253\u0257\u1d91\u0284\u0260\u029b\u0267\u026b",
+                "\u0268\u0289\u028a\u0258\u0275\u0264\u025c\u025e\u0251\u0252\u025a\u025d\u0181\u0189\u0191\u01a9",
+                "\u01b2\u10a0\u10a1\u10a2\u10a3\u10a4\u10a5\u10a6\u10a7\u10a8\u10a9\u10aa\u10ab\u10ac\u10ad\u10ae",
+                "\u10af\u10b0\u10b1\u10b2\u10b3\u10b4\u10b5\u10b6\u10b7\u10b8\u10b9\u10ba\u10bb\u10bc\u10bd\u10be",
+                "\u10bf\u10c0\u10c1\u10c2\u10c3\u10c4\u10c5\u10c7\u10cd\u10d0\u10d1\u10d2\u10d3\u10d4\u10d5\u10d6",
+                "\u10d7\u10d8\u10d9\u10da\u10db\u10dc\u10dd\u10de\u10df\u10e0\u10e1\u10e2\u10e3\u10e4\u10e5\u10e6",
+                "\u10e7\u10e8\u10e9\u10ea\u10eb\u10ec\u10ed\u10ee\u10ef\u10f0\u10f1\u10f2\u10f3\u10f4\u10f5\u10f6",
+                "\u10f7\u10f8\u10f9\u10fa\u10fb\u10fc\u10fd\u10fe\u10ff\ufb4a\ufb2b\ufb4e\ufb44\ufb3b\ufb1f\ufb1d",
+                "\ufb4b\ufb35\ufb4c\ufb31\ua727\ua726\u027a\u2c71\u02a0\u0297\u0296\u026d\u0277\u027f\u0285\u0286",
+                "\u0293\u029a\u20aa\u20be\u058a\u2d00\u2d01\u2d02\u2d03\u2d04\u2d05\u2d06\u2d21\u2d07\u2d08\u2d09",
+                "\u2d0a\u2d0b\u2d0c\u2d22\u2d0d\u2d0e\u2d0f\u2d10\u2d11\u2d12\u2d23\u2d13\u2d14\u2d15\u2d16\u2d17",
+                "\u2d18\u2d19\u2d1a\u2d1b\u2d1c\u2d1d\u2d1e\u2d24\u2d1f\u2d20\u2d25\u215b\u215c\u215d\u215e\u2153",
+                "\u2154\u2709\u2602\u2614\u2604\u26c4\u2603\u231b\u231a\u2690\u270e\u2763\u2664\u2667\u2661\u2662",
+                "\u26c8\u2630\u2631\u2633\u2634\u2636\u2637\u2194\u21d2\u21cf\u21d4\u21f5\u2200\u2203\u2204\u2209",
+                "\u220b\u220c\u2282\u2283\u2284\u2285\u2227\u2228\u22bb\u22bc\u22bd\u2225\u2262\u22c6\u2211\u22a4",
+                "\u22a5\u22a2\u22a8\u2254\u2201\u2234\u2235\u221b\u221c\u2202\u22c3\u2286\u2287\u25a1\u25b3\u25b7",
+                "\u25bd\u25c1\u25c6\u25c7\u25cb\u25ce\u2606\u2605\u2718\u2080\u2081\u2082\u2083\u2084\u2085\u2086",
+                "\u2087\u2088\u2089\u208a\u208b\u208c\u208d\u208e\u222b\u222e\u221d\u2300\u2302\u2318\u3012\u027c",
+                "\u0184\u0185\u1e9f\u023d\u019a\u019b\u0220\u019e\u019f\u01a7\u01a8\u01aa\u01b8\u01b9\u01bb\u01bc",
+                "\u01bd\u01be\u0221\u0234\u0235\u0236\u023a\u2c65\u023b\u023c\u0246\u0247\u023e\u2c66\u0241\u0242",
+                "\u0243\u0244\u0248\u0249\u024a\u024b\u024c\u024d\u024e\u024f\u1e9c\u1e9d\u1efc\u1efd\u1efe\u1eff",
+                "\ua7a8\ua7a9\ud800\udf30\ud800\udf31\ud800\udf32\ud800\udf33\ud800\udf34\ud800\udf35\ud800\udf36\ud800\udf37\ud800\udf38\ud800\udf39\ud800\udf3a\ud800\udf3b\ud800\udf3c\ud800\udf3d",
+                "\ud800\udf3e\ud800\udf3f\ud800\udf40\ud800\udf41\ud800\udf42\ud800\udf43\ud800\udf44\ud800\udf45\ud800\udf46\ud800\udf47\ud800\udf48\ud800\udf49\ud800\udf4a\ud83c\udf27\ud83d\udd25\ud83c\udf0a",
+                "\u2150\u2151\u2155\u2156\u2157\u2159\u215a\u215f\u2189\ud83d\udde1\ud83c\udff9\ud83e\ude93\ud83d\udd31\ud83c\udfa3\ud83e\uddea\u2697",
+                "\u2bea\u2beb\u2c6d\ud83d\udee1\u2702\ud83c\udf56\ud83e\udea3\ud83d\udd14\u23f3\u2691\u20a0\u20a1\u20a2\u20a3\u20a4\u20a5",
+                "\u20a6\u20a9\u20ab\u20ad\u20ae\u20b0\u20b1\u20b2\u20b3\u20b5\u20b6\u20b7\u20b8\u20b9\u20ba\u20bb",
+                "\u20bc\u20bf\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000"
+            ]
+        },
+        {
+            "type": "bitmap",
+            "file": "gtceu:font/ascii_mono.png",
+            "ascent": 7,
+            "chars": [
+                "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000",
+                "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000",
+                "\u0020\u0021\u0022\u0023\u0024\u0025\u0026\u0027\u0028\u0029\u002a\u002b\u002c\u002d\u002e\u002f",
+                "\u0030\u0031\u0032\u0033\u0034\u0035\u0036\u0037\u0038\u0039\u003a\u003b\u003c\u003d\u003e\u003f",
+                "\u0040\u0041\u0042\u0043\u0044\u0045\u0046\u0047\u0048\u0049\u004a\u004b\u004c\u004d\u004e\u004f",
+                "\u0050\u0051\u0052\u0053\u0054\u0055\u0056\u0057\u0058\u0059\u005a\u005b\u005c\u005d\u005e\u005f",
+                "\u0060\u0061\u0062\u0063\u0064\u0065\u0066\u0067\u0068\u0069\u006a\u006b\u006c\u006d\u006e\u006f",
+                "\u0070\u0071\u0072\u0073\u0074\u0075\u0076\u0077\u0078\u0079\u007a\u007b\u007c\u007d\u007e\u0000",
+                "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000",
+                "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u00a3\u0000\u0000\u0192",
+                "\u0000\u0000\u0000\u0000\u0000\u0000\u00aa\u00ba\u0000\u0000\u00ac\u0000\u0000\u0000\u00ab\u00bb",
+                "\u2591\u2592\u2593\u2502\u2524\u2561\u2562\u2556\u2555\u2563\u2551\u2557\u255d\u255c\u255b\u2510",
+                "\u2514\u2534\u252c\u251c\u2500\u253c\u255e\u255f\u255a\u2554\u2569\u2566\u2560\u2550\u256c\u2567",
+                "\u2568\u2564\u2565\u2559\u2558\u2552\u2553\u256b\u256a\u2518\u250c\u2588\u2584\u258c\u2590\u2580",
+                "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u2205\u2208\u0000",
+                "\u2261\u00b1\u2265\u2264\u2320\u2321\u00f7\u2248\u00b0\u2219\u0000\u221a\u207f\u00b2\u25a0\u0000"
+            ]
+        }
+    ]
+}
diff --git a/src/main/resources/assets/gtceu/font/monocraft.json b/src/main/resources/assets/gtceu/font/monocraft.json
new file mode 100644
index 00000000000..04e2da6dd45
--- /dev/null
+++ b/src/main/resources/assets/gtceu/font/monocraft.json
@@ -0,0 +1,16 @@
+{
+    "providers": [
+        {
+            "type": "reference",
+            "id": "gtceu:include/mono_space"
+        },
+        {
+            "type": "reference",
+            "id": "gtceu:include/monocraft"
+        },
+        {
+            "type": "reference",
+            "id": "minecraft:default"
+        }
+    ]
+}
diff --git a/src/main/resources/assets/gtceu/textures/block/equipment_foundry.png b/src/main/resources/assets/gtceu/textures/block/equipment_foundry.png
new file mode 100644
index 00000000000..7f57a8703a8
Binary files /dev/null and b/src/main/resources/assets/gtceu/textures/block/equipment_foundry.png differ
diff --git a/src/main/resources/assets/gtceu/textures/font/LICENSE.txt b/src/main/resources/assets/gtceu/textures/font/LICENSE.txt
new file mode 100644
index 00000000000..10ab55db6eb
--- /dev/null
+++ b/src/main/resources/assets/gtceu/textures/font/LICENSE.txt
@@ -0,0 +1,86 @@
+-----------------------------------------------------------
+SIL OPEN FONT LICENSE Version 1.1 - 26 February 2007
+-----------------------------------------------------------
+
+PREAMBLE
+The goals of the Open Font License (OFL) are to stimulate worldwide
+development of collaborative font projects, to support the font creation
+efforts of academic and linguistic communities, and to provide a free and
+open framework in which fonts may be shared and improved in partnership
+with others.
+
+The OFL allows the licensed fonts to be used, studied, modified and
+redistributed freely as long as they are not sold by themselves. The
+fonts, including any derivative works, can be bundled, embedded,
+redistributed and/or sold with any software provided that any reserved
+names are not used by derivative works. The fonts and derivatives,
+however, cannot be released under any other type of license. The
+requirement for fonts to remain under this license does not apply
+to any document created using the fonts or their derivatives.
+
+DEFINITIONS
+"Font Software" refers to the set of files released by the Copyright
+Holder(s) under this license and clearly marked as such. This may
+include source files, build scripts and documentation.
+
+"Reserved Font Name" refers to any names specified as such after the
+copyright statement(s).
+
+"Original Version" refers to the collection of Font Software components as
+distributed by the Copyright Holder(s).
+
+"Modified Version" refers to any derivative made by adding to, deleting,
+or substituting -- in part or in whole -- any of the components of the
+Original Version, by changing formats or by porting the Font Software to a
+new environment.
+
+"Author" refers to any designer, engineer, programmer, technical
+writer or other person who contributed to the Font Software.
+
+PERMISSION & CONDITIONS
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of the Font Software, to use, study, copy, merge, embed, modify,
+redistribute, and sell modified and unmodified copies of the Font
+Software, subject to the following conditions:
+
+1) Neither the Font Software nor any of its individual components,
+in Original or Modified Versions, may be sold by itself.
+
+2) Original or Modified Versions of the Font Software may be bundled,
+redistributed and/or sold with any software, provided that each copy
+contains the above copyright notice and this license. These can be
+included either as stand-alone text files, human-readable headers or
+in the appropriate machine-readable metadata fields within text or
+binary files as long as those fields can be easily viewed by the user.
+
+3) No Modified Version of the Font Software may use the Reserved Font
+Name(s) unless explicit written permission is granted by the corresponding
+Copyright Holder. This restriction only applies to the primary font name as
+presented to the users.
+
+4) The name(s) of the Copyright Holder(s) or the Author(s) of the Font
+Software shall not be used to promote, endorse or advertise any
+Modified Version, except to acknowledge the contribution(s) of the
+Copyright Holder(s) and the Author(s) or with their explicit written
+permission.
+
+5) The Font Software, modified or unmodified, in part or in whole,
+must be distributed entirely under this license, and must not be
+distributed under any other license. The requirement for fonts to
+remain under this license does not apply to any document created
+using the Font Software.
+
+TERMINATION
+This license becomes null and void if any of the above conditions are
+not met.
+
+DISCLAIMER
+THE FONT SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO ANY WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT
+OF COPYRIGHT, PATENT, TRADEMARK, OR OTHER RIGHT. IN NO EVENT SHALL THE
+COPYRIGHT HOLDER BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+INCLUDING ANY GENERAL, SPECIAL, INDIRECT, INCIDENTAL, OR CONSEQUENTIAL
+DAMAGES, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+FROM, OUT OF THE USE OR INABILITY TO USE THE FONT SOFTWARE OR FROM
+OTHER DEALINGS IN THE FONT SOFTWARE.
diff --git a/src/main/resources/assets/gtceu/textures/font/ascii_mono.png b/src/main/resources/assets/gtceu/textures/font/ascii_mono.png
new file mode 100644
index 00000000000..dcef3c8ef55
Binary files /dev/null and b/src/main/resources/assets/gtceu/textures/font/ascii_mono.png differ
diff --git a/src/main/resources/assets/gtceu/textures/font/nonlatin_european_mono.png b/src/main/resources/assets/gtceu/textures/font/nonlatin_european_mono.png
new file mode 100644
index 00000000000..8b1c81e7ed1
Binary files /dev/null and b/src/main/resources/assets/gtceu/textures/font/nonlatin_european_mono.png differ
diff --git a/src/main/resources/assets/gtceu/textures/gui/base/background.png b/src/main/resources/assets/gtceu/textures/gui/base/background.png
index 38fe4cecd3c..59c1f2b2863 100644
Binary files a/src/main/resources/assets/gtceu/textures/gui/base/background.png and b/src/main/resources/assets/gtceu/textures/gui/base/background.png differ
diff --git a/src/main/resources/assets/gtceu/textures/gui/base/background_bronze.png b/src/main/resources/assets/gtceu/textures/gui/base/background_bronze.png
index 1ac941e4649..2f618f05651 100644
Binary files a/src/main/resources/assets/gtceu/textures/gui/base/background_bronze.png and b/src/main/resources/assets/gtceu/textures/gui/base/background_bronze.png differ
diff --git a/src/main/resources/assets/gtceu/textures/gui/base/background_steel.png b/src/main/resources/assets/gtceu/textures/gui/base/background_steel.png
index 3f1b678aa91..cfa2e53eeab 100644
Binary files a/src/main/resources/assets/gtceu/textures/gui/base/background_steel.png and b/src/main/resources/assets/gtceu/textures/gui/base/background_steel.png differ
diff --git a/src/main/resources/assets/gtceu/textures/gui/base/bordered_background.png b/src/main/resources/assets/gtceu/textures/gui/base/bordered_background.png
index f77849e8f7b..96c6fd89bf1 100644
Binary files a/src/main/resources/assets/gtceu/textures/gui/base/bordered_background.png and b/src/main/resources/assets/gtceu/textures/gui/base/bordered_background.png differ
diff --git a/src/main/resources/assets/gtceu/textures/gui/base/title_bar_background.png b/src/main/resources/assets/gtceu/textures/gui/base/title_bar_background.png
index 3b2669c8b3b..9ce9c329362 100644
Binary files a/src/main/resources/assets/gtceu/textures/gui/base/title_bar_background.png and b/src/main/resources/assets/gtceu/textures/gui/base/title_bar_background.png differ
diff --git a/src/main/resources/assets/gtceu/textures/gui/cursor/cursor_resize.png b/src/main/resources/assets/gtceu/textures/gui/cursor/cursor_resize.png
new file mode 100644
index 00000000000..2c826218043
Binary files /dev/null and b/src/main/resources/assets/gtceu/textures/gui/cursor/cursor_resize.png differ
diff --git a/src/main/resources/assets/gtceu/textures/gui/cursor/cursor_resize_diag.png b/src/main/resources/assets/gtceu/textures/gui/cursor/cursor_resize_diag.png
new file mode 100644
index 00000000000..4927da44091
Binary files /dev/null and b/src/main/resources/assets/gtceu/textures/gui/cursor/cursor_resize_diag.png differ
diff --git a/src/main/resources/assets/gtceu/textures/gui/icon/seperator/seperator_simple.png b/src/main/resources/assets/gtceu/textures/gui/icon/seperator/seperator_simple.png
new file mode 100644
index 00000000000..2b3163a346d
Binary files /dev/null and b/src/main/resources/assets/gtceu/textures/gui/icon/seperator/seperator_simple.png differ
diff --git a/src/main/resources/assets/gtceu/textures/gui/overlay/mode_eu.png b/src/main/resources/assets/gtceu/textures/gui/overlay/mode_eu.png
new file mode 100644
index 00000000000..e1d54b00372
Binary files /dev/null and b/src/main/resources/assets/gtceu/textures/gui/overlay/mode_eu.png differ
diff --git a/src/main/resources/assets/gtceu/textures/gui/overlay/mode_percent.png b/src/main/resources/assets/gtceu/textures/gui/overlay/mode_percent.png
new file mode 100644
index 00000000000..06a6ba6e9ec
Binary files /dev/null and b/src/main/resources/assets/gtceu/textures/gui/overlay/mode_percent.png differ
diff --git a/src/main/resources/assets/gtceu/textures/gui/overlay/redstone_off.png b/src/main/resources/assets/gtceu/textures/gui/overlay/redstone_off.png
new file mode 100644
index 00000000000..99f7bc97d12
Binary files /dev/null and b/src/main/resources/assets/gtceu/textures/gui/overlay/redstone_off.png differ
diff --git a/src/main/resources/assets/gtceu/textures/gui/overlay/redstone_on.png b/src/main/resources/assets/gtceu/textures/gui/overlay/redstone_on.png
new file mode 100644
index 00000000000..27568a06470
Binary files /dev/null and b/src/main/resources/assets/gtceu/textures/gui/overlay/redstone_on.png differ
diff --git a/src/main/resources/assets/gtceu/textures/gui/overlay/transfer_mode_overlay.png b/src/main/resources/assets/gtceu/textures/gui/overlay/transfer_mode_overlay.png
new file mode 100644
index 00000000000..5d25ec7dfa4
Binary files /dev/null and b/src/main/resources/assets/gtceu/textures/gui/overlay/transfer_mode_overlay.png differ
diff --git a/src/main/resources/assets/gtceu/textures/gui/slot/item.png b/src/main/resources/assets/gtceu/textures/gui/slot/item.png
new file mode 100644
index 00000000000..41973affbf8
Binary files /dev/null and b/src/main/resources/assets/gtceu/textures/gui/slot/item.png differ
diff --git a/src/main/resources/assets/gtceu/textures/gui/tab/tabs_bottom.png b/src/main/resources/assets/gtceu/textures/gui/tab/tabs_bottom.png
deleted file mode 100644
index b4cee091f8e..00000000000
Binary files a/src/main/resources/assets/gtceu/textures/gui/tab/tabs_bottom.png and /dev/null differ
diff --git a/src/main/resources/assets/gtceu/textures/gui/tab/tabs_left.png b/src/main/resources/assets/gtceu/textures/gui/tab/tabs_left.png
deleted file mode 100644
index 3e8334793cf..00000000000
Binary files a/src/main/resources/assets/gtceu/textures/gui/tab/tabs_left.png and /dev/null differ
diff --git a/src/main/resources/assets/gtceu/textures/gui/tab/tabs_right.png b/src/main/resources/assets/gtceu/textures/gui/tab/tabs_right.png
deleted file mode 100644
index 8dfef9e2634..00000000000
Binary files a/src/main/resources/assets/gtceu/textures/gui/tab/tabs_right.png and /dev/null differ
diff --git a/src/main/resources/assets/gtceu/textures/gui/tab/tabs_top.png b/src/main/resources/assets/gtceu/textures/gui/tab/tabs_top.png
deleted file mode 100644
index c6423541ef3..00000000000
Binary files a/src/main/resources/assets/gtceu/textures/gui/tab/tabs_top.png and /dev/null differ
diff --git a/src/main/resources/assets/gtceu/textures/gui/widget/equipment_foundry_background.png b/src/main/resources/assets/gtceu/textures/gui/widget/equipment_foundry_background.png
new file mode 100644
index 00000000000..abaff1824f7
Binary files /dev/null and b/src/main/resources/assets/gtceu/textures/gui/widget/equipment_foundry_background.png differ
diff --git a/src/main/resources/assets/gtceu/textures/item/creative_flight_module.png b/src/main/resources/assets/gtceu/textures/item/creative_flight_module.png
new file mode 100644
index 00000000000..990859bb651
Binary files /dev/null and b/src/main/resources/assets/gtceu/textures/item/creative_flight_module.png differ
diff --git a/src/main/resources/assets/gtceu/textures/item/plugin.fake_gui.png b/src/main/resources/assets/gtceu/textures/item/gui_module.png
similarity index 100%
rename from src/main/resources/assets/gtceu/textures/item/plugin.fake_gui.png
rename to src/main/resources/assets/gtceu/textures/item/gui_module.png
diff --git a/src/main/resources/assets/gtceu/textures/item/plugin.online_pic.png b/src/main/resources/assets/gtceu/textures/item/plugin.online_pic.png
deleted file mode 100644
index 8b532f20234..00000000000
Binary files a/src/main/resources/assets/gtceu/textures/item/plugin.online_pic.png and /dev/null differ
diff --git a/src/main/resources/assets/gtceu/textures/item/plugin.text.png b/src/main/resources/assets/gtceu/textures/item/plugin.text.png
deleted file mode 100644
index ad997f1a0ab..00000000000
Binary files a/src/main/resources/assets/gtceu/textures/item/plugin.text.png and /dev/null differ
diff --git a/src/main/resources/assets/gtceu/textures/armor/advanced_nano_muscle_suite_1.png b/src/main/resources/assets/gtceu/textures/models/armor/advanced_nano_muscle_suite_layer_1.png
similarity index 100%
rename from src/main/resources/assets/gtceu/textures/armor/advanced_nano_muscle_suite_1.png
rename to src/main/resources/assets/gtceu/textures/models/armor/advanced_nano_muscle_suite_layer_1.png
diff --git a/src/main/resources/assets/gtceu/textures/armor/advanced_nano_muscle_suite_2.png b/src/main/resources/assets/gtceu/textures/models/armor/advanced_nano_muscle_suite_layer_2.png
similarity index 100%
rename from src/main/resources/assets/gtceu/textures/armor/advanced_nano_muscle_suite_2.png
rename to src/main/resources/assets/gtceu/textures/models/armor/advanced_nano_muscle_suite_layer_2.png
diff --git a/src/main/resources/assets/gtceu/textures/armor/advanced_quark_tech_suite_1.png b/src/main/resources/assets/gtceu/textures/models/armor/advanced_quark_tech_suite_layer_1.png
similarity index 100%
rename from src/main/resources/assets/gtceu/textures/armor/advanced_quark_tech_suite_1.png
rename to src/main/resources/assets/gtceu/textures/models/armor/advanced_quark_tech_suite_layer_1.png
diff --git a/src/main/resources/assets/gtceu/textures/armor/advanced_quark_tech_suite_2.png b/src/main/resources/assets/gtceu/textures/models/armor/advanced_quark_tech_suite_layer_2.png
similarity index 100%
rename from src/main/resources/assets/gtceu/textures/armor/advanced_quark_tech_suite_2.png
rename to src/main/resources/assets/gtceu/textures/models/armor/advanced_quark_tech_suite_layer_2.png
diff --git a/src/main/resources/assets/gtceu/textures/armor/nano_muscule_suite_1.png b/src/main/resources/assets/gtceu/textures/models/armor/nano_muscle_suite_layer_1.png
similarity index 100%
rename from src/main/resources/assets/gtceu/textures/armor/nano_muscule_suite_1.png
rename to src/main/resources/assets/gtceu/textures/models/armor/nano_muscle_suite_layer_1.png
diff --git a/src/main/resources/assets/gtceu/textures/armor/nano_muscule_suite_2.png b/src/main/resources/assets/gtceu/textures/models/armor/nano_muscle_suite_layer_2.png
similarity index 100%
rename from src/main/resources/assets/gtceu/textures/armor/nano_muscule_suite_2.png
rename to src/main/resources/assets/gtceu/textures/models/armor/nano_muscle_suite_layer_2.png
diff --git a/src/main/resources/assets/gtceu/textures/armor/quark_tech_suite_1.png b/src/main/resources/assets/gtceu/textures/models/armor/quark_tech_suite_layer_1.png
similarity index 100%
rename from src/main/resources/assets/gtceu/textures/armor/quark_tech_suite_1.png
rename to src/main/resources/assets/gtceu/textures/models/armor/quark_tech_suite_layer_1.png
diff --git a/src/main/resources/assets/gtceu/textures/armor/quark_tech_suite_2.png b/src/main/resources/assets/gtceu/textures/models/armor/quark_tech_suite_layer_2.png
similarity index 100%
rename from src/main/resources/assets/gtceu/textures/armor/quark_tech_suite_2.png
rename to src/main/resources/assets/gtceu/textures/models/armor/quark_tech_suite_layer_2.png
diff --git a/src/main/resources/data/curios/tags/items/gtceu_magnet.json b/src/main/resources/data/curios/tags/items/gtceu_magnet.json
index 4b56b55b3ac..f8bf8aeac0b 100644
--- a/src/main/resources/data/curios/tags/items/gtceu_magnet.json
+++ b/src/main/resources/data/curios/tags/items/gtceu_magnet.json
@@ -4,4 +4,4 @@
     "gtceu:lv_item_magnet",
     "gtceu:hv_item_magnet"
   ]
-}
\ No newline at end of file
+}
diff --git a/src/main/resources/data/curios/tags/items/hands.json b/src/main/resources/data/curios/tags/items/hands.json
index 90d5a15104d..b5c7e21d805 100644
--- a/src/main/resources/data/curios/tags/items/hands.json
+++ b/src/main/resources/data/curios/tags/items/hands.json
@@ -1,5 +1,6 @@
 {
     "values": [
-        "gtceu:rubber_gloves"
+        "gtceu:rubber_gloves",
+        "gtceu:mui_test_item"
     ]
 }
diff --git a/src/main/resources/gtceu.mixins.json b/src/main/resources/gtceu.mixins.json
index 5661b433819..18bc34a9854 100644
--- a/src/main/resources/gtceu.mixins.json
+++ b/src/main/resources/gtceu.mixins.json
@@ -46,12 +46,14 @@
         "InventoryMixin",
         "ItemValueAccessor",
         "LevelMixin",
+        "LivingEntityMixin",
         "LootDataManagerMixin",
         "LootPoolAccessor",
         "OreConfigurationMixin",
         "OreVeinifierMixin",
         "PotionBrewingAccessor",
         "PrimedTntAccessor",
+        "RangedAttributeAccessor",
         "RecipeManagerMixin",
         "RepairItemRecipeMixin",
         "ServerChunkProviderMixin",
@@ -74,7 +76,6 @@
         "forge.PartialNBTIngredientAccessor",
         "forge.StrictNBTIngredientAccessor",
         "jei.FluidHelperMixin",
-        "ldlib.SyncUtilsMixin",
         "registrate.AbstractRegistrateAccessor",
         "registrate.RegistrateDataProviderAccessor",
         "rei.InputSlotCrafterMixin",